pressclaw 0.2.0 → 0.4.0

package/index.ts

@@ -0,0 +1,4237 @@
+import fs from "node:fs";
+import path from "node:path";
+import readline from "node:readline/promises";
+import crypto from "node:crypto";
+import https from "node:https";
+import {
+  escapeHtml,
+  slugify,
+  excerptFrom,
+  renderMarkdown,
+  renderPostPage,
+  renderIndexPage,
+  renderRss,
+  STRUCTURES as CORE_STRUCTURES,
+  type StructureDefinition,
+  SUBREDDIT_GUIDELINES,
+  DEFAULT_SUBREDDIT_GUIDELINE,
+  KNOWN_SUBREDDITS,
+} from "@pressclaw/core";
+
+// ── Helpers ──────────────────────────────────────────────────────────
+
+function resolveWorkspace(api: any): string {
+  return (
+    api.config?.agents?.defaults?.workspace ||
+    process.env.HOME + "/.openclaw/workspace"
+  );
+}
+
+function resolveConfig(api: any) {
+  const cfg = api.config.plugins?.entries?.["pressclaw"]?.config ?? {};
+  const workspace = resolveWorkspace(api);
+  return {
+    notesDir: cfg.notesDir || path.join(workspace, "notes"),
+    outputDir: cfg.outputDir || path.join(workspace, "public"),
+    publicPath: cfg.publicPath || "/public",
+    siteTitle: cfg.siteTitle || "Your Thinking",
+    authorName: cfg.authorName || "",
+    baseUrl: cfg.baseUrl || "",
+    dailyPrompt: {
+      enabled: cfg.dailyPrompt?.enabled ?? true,
+      schedule: cfg.dailyPrompt?.schedule || "0 10 * * *",
+      timezone: cfg.dailyPrompt?.timezone || "UTC",
+      prompt:
+        cfg.dailyPrompt?.prompt ||
+        'Review yesterday\'s conversations and daily notes. Identify any interesting ideas, insights, or learnings worth sharing publicly. If you find something compelling, draft a short note (3-8 paragraphs) that distills the idea for a general audience. Use `openclaw notes new "<title>"` to create it, then write the content. Don\'t publish yet — just draft. If nothing stands out, that\'s fine — skip today.',
+    },
+  };
+}
+
+function ensureDirs(outputDir: string) {
+  fs.mkdirSync(outputDir, { recursive: true });
+  fs.mkdirSync(path.join(outputDir, "posts"), { recursive: true });
+}
+
+function parseFrontMatter(content: string) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!match) return { meta: {} as Record<string, any>, body: content };
+  const metaLines = match[1].split("\n");
+  const meta: Record<string, any> = {};
+  for (const line of metaLines) {
+    const [key, ...rest] = line.split(":");
+    if (!key) continue;
+    meta[key.trim()] = rest.join(":").trim().replace(/^"|"$/g, "");
+  }
+  return { meta, body: match[2].trim() };
+}
+
+function listNotes(notesDir: string) {
+  if (!fs.existsSync(notesDir)) return [];
+  return fs.readdirSync(notesDir).filter((f) => f.endsWith(".md"));
+}
+
+// ── Style DNA: Per-note analysis + aggregate profile evolution ───────
+
+function estimateSyllables(word: string): number {
+  word = word.toLowerCase().replace(/[^a-z]/g, "");
+  if (word.length <= 3) return 1;
+  word = word.replace(/(?:[^laeiouy]es|ed|[^laeiouy]e)$/, "");
+  word = word.replace(/^y/, "");
+  const vowelGroups = word.match(/[aeiouy]{1,2}/g);
+  return vowelGroups ? vowelGroups.length : 1;
+}
+
+function extractStyleMarkers(body: string): Record<string, any> {
+  // Strip markdown formatting for analysis
+  const text = body
+    .replace(/^#+\s+.*/gm, "")           // headers
+    .replace(/\*\*([^*]+)\*\*/g, "$1")    // bold
+    .replace(/\*([^*]+)\*/g, "$1")        // italic
+    .replace(/`[^`]+`/g, "CODE")          // inline code
+    .replace(/```[\s\S]*?```/g, "")       // code blocks
+    .replace(/\[([^\]]+)\]\([^)]+\)/g, "$1") // links
+    .replace(/^>\s+/gm, "")              // blockquotes
+    .replace(/^[-*]\s+/gm, "")           // list items
+    .replace(/^\d+\.\s+/gm, "")          // numbered lists
+    .trim();
+
+  const sentences = text.split(/[.!?]+/).map((s) => s.trim()).filter((s) => s.length > 3);
+  const paragraphs = text.split(/\n\s*\n/).filter((p) => p.trim().length > 0);
+  const words = text.split(/\s+/).filter((w) => w.length > 0);
+
+  const avgSentenceLength = sentences.length > 0
+    ? Math.round((words.length / sentences.length) * 10) / 10
+    : 0;
+  const avgParagraphSentences = paragraphs.length > 0
+    ? Math.round((sentences.length / paragraphs.length) * 10) / 10
+    : 0;
+
+  // Perspective detection
+  const firstPerson = (text.match(/\b(I|I've|I'm|my|me|we|we've|our)\b/gi) || []).length;
+  const secondPerson = (text.match(/\b(you|your|you're|you've)\b/gi) || []).length;
+  const perspective = firstPerson > secondPerson * 2 ? "first-person"
+    : secondPerson > firstPerson * 2 ? "second-person"
+    : "mixed";
+
+  // Emoji detection
+  const emojiCount = (text.match(/[\u{1F300}-\u{1F6FF}\u{2600}-\u{26FF}\u{2700}-\u{27BF}\u{1F900}-\u{1F9FF}]/gu) || []).length;
+  const emojiUsage = emojiCount === 0 ? "none" : emojiCount < 3 ? "rare" : "frequent";
+
+  // Flesch-Kincaid readability approximation
+  const syllableCount = words.reduce((sum, w) => sum + estimateSyllables(w), 0);
+  const readability = Math.round(
+    206.835 - 1.015 * (words.length / Math.max(sentences.length, 1)) -
+    84.6 * (syllableCount / Math.max(words.length, 1))
+  );
+
+  return {
+    sentences: sentences.length,
+    paragraphs: paragraphs.length,
+    wordCount: words.length,
+    avgSentenceLength,
+    avgParagraphSentences,
+    perspective,
+    emojiUsage,
+    readabilityScore: Math.max(0, Math.min(100, readability)),
+  };
+}
+
+function writeFrontmatterWithMarkers(
+  meta: Record<string, any>,
+  body: string,
+  markers: Record<string, any>
+): string {
+  const lines: string[] = ["---"];
+  // Preserve key order: title, slug, status, published_at, then the rest
+  const ordered = ["title", "slug", "status", "published_at", "publish_reason", "topic_id", "input_type", "tone", "structure", "confidence"];
+  const written = new Set<string>();
+
+  for (const key of ordered) {
+    if (meta[key] !== undefined && meta[key] !== null) {
+      const val = meta[key];
+      if (key === "title" || key === "slug" || key === "publish_reason" || key === "topic_id" || key === "input_type") {
+        lines.push(`${key}: "${val}"`);
+      } else {
+        lines.push(`${key}: ${val}`);
+      }
+      written.add(key);
+    }
+  }
+
+  // Tags (array)
+  if (meta.tags) {
+    lines.push(`tags: ${typeof meta.tags === "string" ? meta.tags : JSON.stringify(meta.tags)}`);
+    written.add("tags");
+  }
+
+  // Style markers as single-line JSON
+  lines.push(`style_markers: ${JSON.stringify(markers)}`);
+  written.add("style_markers");
+
+  // Any remaining meta fields
+  for (const [key, val] of Object.entries(meta)) {
+    if (written.has(key)) continue;
+    if (key === "style_markers") continue; // skip old one
+    lines.push(`${key}: ${val}`);
+  }
+
+  lines.push("---");
+  return lines.join("\n") + "\n\n" + body + "\n";
+}
+
+function updateAggregateProfile(notesDir: string): { noteCount: number; updated: boolean } {
+  const files = listNotes(notesDir);
+  const now = new Date();
+  const noteData: {
+    slug: string;
+    markers: Record<string, any>;
+    publishedAt: string | null;
+    weight: number;
+  }[] = [];
+
+  for (const f of files) {
+    const full = fs.readFileSync(path.join(notesDir, f), "utf8");
+    const { meta, body } = parseFrontMatter(full);
+    if (meta.status !== "public" && meta.status !== "refined") continue;
+
+    const slug = f.replace(/\.md$/, "");
+
+    // Use cached markers from frontmatter, or compute fresh
+    let markers: Record<string, any>;
+    if (meta.style_markers) {
+      try {
+        markers = typeof meta.style_markers === "string"
+          ? JSON.parse(meta.style_markers)
+          : meta.style_markers;
+      } catch {
+        markers = extractStyleMarkers(body);
+      }
+    } else {
+      markers = extractStyleMarkers(body);
+    }
+
+    // Weight by recency (slow decay)
+    const pubDate = meta.published_at ? new Date(meta.published_at) : now;
+    const daysSince = Math.max(0, (now.getTime() - pubDate.getTime()) / (1000 * 60 * 60 * 24));
+    const weight = 1 / (1 + daysSince * 0.01);
+
+    noteData.push({
+      slug,
+      markers,
+      publishedAt: meta.published_at || null,
+      weight,
+    });
+  }
+
+  if (noteData.length === 0) return { noteCount: 0, updated: false };
+
+  // Weighted averages for numeric fields
+  const totalWeight = noteData.reduce((s, n) => s + n.weight, 0);
+  const wavg = (field: string) => {
+    const sum = noteData.reduce((s, n) => s + (n.markers[field] || 0) * n.weight, 0);
+    return Math.round((sum / totalWeight) * 10) / 10;
+  };
+
+  const aggAvgSentenceLength = wavg("avgSentenceLength");
+  const aggAvgWordCount = wavg("wordCount");
+  const aggAvgReadability = wavg("readabilityScore");
+  const aggAvgParagraphSentences = wavg("avgParagraphSentences");
+
+  // Perspective: majority vote weighted
+  const perspectiveCounts: Record<string, number> = {};
+  for (const n of noteData) {
+    const p = n.markers.perspective || "mixed";
+    perspectiveCounts[p] = (perspectiveCounts[p] || 0) + n.weight;
+  }
+  const aggPerspective = Object.entries(perspectiveCounts).sort((a, b) => b[1] - a[1])[0]?.[0] || "mixed";
+
+  // Emoji: majority vote weighted
+  const emojiCounts: Record<string, number> = {};
+  for (const n of noteData) {
+    const e = n.markers.emojiUsage || "none";
+    emojiCounts[e] = (emojiCounts[e] || 0) + n.weight;
+  }
+  const aggEmoji = Object.entries(emojiCounts).sort((a, b) => b[1] - a[1])[0]?.[0] || "none";
+
+  // Sentence length category
+  const slCat = aggAvgSentenceLength < 12 ? "short" : aggAvgSentenceLength > 20 ? "long" : "medium";
+  const plCat = aggAvgParagraphSentences < 3 ? "short" : aggAvgParagraphSentences > 5 ? "long" : "medium";
+
+  // Build per-note markers map
+  const perNoteMarkers: Record<string, any> = {};
+  for (const n of noteData) {
+    perNoteMarkers[n.slug] = {
+      ...n.markers,
+      weight: Math.round(n.weight * 1000) / 1000,
+      publishedAt: n.publishedAt,
+    };
+  }
+
+  // Load existing profile to preserve qualitative fields
+  const profilePath = path.join(notesDir, ".style-profile.json");
+  let existing: any = {};
+  if (fs.existsSync(profilePath)) {
+    try { existing = JSON.parse(fs.readFileSync(profilePath, "utf8")); } catch {}
+  }
+
+  // Evolution tracking — append snapshot if date changed
+  const evolution: any[] = existing.evolution || [];
+  const todayStr = now.toISOString().slice(0, 10);
+  const lastEvolution = evolution[evolution.length - 1];
+  if (!lastEvolution || lastEvolution.date !== todayStr) {
+    evolution.push({
+      date: todayStr,
+      noteCount: noteData.length,
+      avgSentenceLength: aggAvgSentenceLength,
+      avgWordCount: aggAvgWordCount,
+      avgReadability: aggAvgReadability,
+    });
+    // Keep last 50
+    while (evolution.length > 50) evolution.shift();
+  } else {
+    // Update today's entry
+    lastEvolution.noteCount = noteData.length;
+    lastEvolution.avgSentenceLength = aggAvgSentenceLength;
+    lastEvolution.avgWordCount = aggAvgWordCount;
+    lastEvolution.avgReadability = aggAvgReadability;
+  }
+
+  const updated: any = {
+    updated: now.toISOString(),
+    analyzedNotes: noteData.map((n) => n.slug),
+    noteCount: noteData.length,
+    markers: {
+      avgSentenceLength: slCat,
+      paragraphLength: plCat,
+      emojiUsage: aggEmoji,
+      perspective: aggPerspective,
+      // Preserve existing qualitative markers
+      ...(existing.markers?.vocabulary ? { vocabulary: existing.markers.vocabulary } : {}),
+      ...(existing.markers?.toneDefault ? { toneDefault: existing.markers.toneDefault } : {}),
+      ...(existing.markers?.openingStyle ? { openingStyle: existing.markers.openingStyle } : {}),
+      ...(existing.markers?.closingStyle ? { closingStyle: existing.markers.closingStyle } : {}),
+    },
+    perNoteMarkers,
+    evolution,
+    // Preserve qualitative fields from existing profile
+    voiceDescription: existing.voiceDescription || "",
+    avoid: existing.avoid || [],
+    examples: existing.examples || {},
+  };
+
+  fs.writeFileSync(profilePath, JSON.stringify(updated, null, 2) + "\n", "utf8");
+  return { noteCount: noteData.length, updated: true };
+}
+
+// ── Branding OS Helpers ─────────────────────────────────────────────
+
+interface StyleProfile {
+  updated: string;
+  analyzedNotes: string[];
+  markers: Record<string, string>;
+  voiceDescription: string;
+  avoid: string[];
+  examples: { strongOpeners: string[]; strongClosers: string[] };
+}
+
+interface VariationEntry {
+  file: string;
+  tone: string;
+  structure: string;
+  wordCount: number;
+  tested: boolean;
+  confidence: number | null;
+  selected: boolean;
+}
+
+interface VariationManifest {
+  source: string;
+  generated: string;
+  variations: VariationEntry[];
+  selectedVariation: string | null;
+}
+
+function loadStructureTemplates(pluginDir: string): StructureDefinition[] {
+  // Use custom structures.json as override if it exists, otherwise fall back to core's STRUCTURES
+  const p = path.join(pluginDir, "templates", "structures.json");
+  if (fs.existsSync(p)) {
+    try {
+      return JSON.parse(fs.readFileSync(p, "utf8"));
+    } catch {}
+  }
+  return CORE_STRUCTURES;
+}
+
+function getStructureTemplate(pluginDir: string, name: string): StructureDefinition | undefined {
+  return loadStructureTemplates(pluginDir).find((t) => t.name === name);
+}
+
+function loadStyleProfile(notesDir: string): StyleProfile | null {
+  const p = path.join(notesDir, ".style-profile.json");
+  if (!fs.existsSync(p)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function variationsDir(notesDir: string, slug: string): string {
+  return path.join(notesDir, ".variations", slug);
+}
+
+function loadManifest(notesDir: string, slug: string): VariationManifest | null {
+  const p = path.join(variationsDir(notesDir, slug), "_manifest.json");
+  if (!fs.existsSync(p)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function loadTestResults(notesDir: string, slug: string): any | null {
+  const p = path.join(variationsDir(notesDir, slug), "_test-results.json");
+  if (!fs.existsSync(p)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function loadPersonas(notesDir: string): any | null {
+  const p = path.join(notesDir, ".personas.json");
+  if (!fs.existsSync(p)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+// ── Performance Feedback Helpers ────────────────────────────────────
+
+interface FeedbackEntry {
+  date: string;
+  score: number;
+  metrics: { views?: number; likes?: number; shares?: number; comments?: number };
+  platform?: string;
+  note?: string;
+}
+
+interface TweetRecord {
+  id: string;
+  text: string;
+  postedAt: string;
+  platform: "twitter" | "linkedin";
+}
+
+interface FeedbackFile {
+  slug: string;
+  entries: FeedbackEntry[];
+  tweets?: TweetRecord[];
+  aggregate: {
+    avgScore: number;
+    totalViews: number;
+    totalLikes: number;
+    totalShares: number;
+    totalComments: number;
+    entries: number;
+  };
+}
+
+function feedbackDir(notesDir: string): string {
+  return path.join(notesDir, ".feedback");
+}
+
+function feedbackPath(notesDir: string, slug: string): string {
+  return path.join(feedbackDir(notesDir), `${slug}.json`);
+}
+
+function loadFeedback(notesDir: string, slug: string): FeedbackFile | null {
+  const p = feedbackPath(notesDir, slug);
+  if (!fs.existsSync(p)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function loadAllFeedback(notesDir: string): FeedbackFile[] {
+  const dir = feedbackDir(notesDir);
+  if (!fs.existsSync(dir)) return [];
+  const results: FeedbackFile[] = [];
+  for (const f of fs.readdirSync(dir).filter((f) => f.endsWith(".json"))) {
+    try {
+      results.push(JSON.parse(fs.readFileSync(path.join(dir, f), "utf8")));
+    } catch {}
+  }
+  return results;
+}
+
+function recalcAggregate(entries: FeedbackEntry[]): FeedbackFile["aggregate"] {
+  const n = entries.length;
+  if (n === 0) return { avgScore: 0, totalViews: 0, totalLikes: 0, totalShares: 0, totalComments: 0, entries: 0 };
+  const totalViews = entries.reduce((s, e) => s + (e.metrics.views || 0), 0);
+  const totalLikes = entries.reduce((s, e) => s + (e.metrics.likes || 0), 0);
+  const totalShares = entries.reduce((s, e) => s + (e.metrics.shares || 0), 0);
+  const totalComments = entries.reduce((s, e) => s + (e.metrics.comments || 0), 0);
+  const avgScore = Math.round((entries.reduce((s, e) => s + e.score, 0) / n) * 10) / 10;
+  return { avgScore, totalViews, totalLikes, totalShares, totalComments, entries: n };
+}
+
+function saveFeedback(notesDir: string, data: FeedbackFile): void {
+  const dir = feedbackDir(notesDir);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(feedbackPath(notesDir, data.slug), JSON.stringify(data, null, 2) + "\n", "utf8");
+}
+
+// ── Twitter/X Posting Helpers ──────────────────────────────────────
+
+function twitterOAuthHeader(method: string, url: string, consumerKey: string, consumerSecret: string, token: string, tokenSecret: string): string {
+  const enc = (s: string) => encodeURIComponent(s).replace(/[!'()*]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
+  const params: Record<string, string> = {
+    oauth_consumer_key: consumerKey,
+    oauth_nonce: crypto.randomUUID().replace(/-/g, ""),
+    oauth_signature_method: "HMAC-SHA1",
+    oauth_timestamp: String(Math.floor(Date.now() / 1000)),
+    oauth_token: token,
+    oauth_version: "1.0",
+  };
+  const sorted = Object.keys(params).sort().map((k) => `${enc(k)}=${enc(params[k])}`).join("&");
+  const baseString = `${method}&${enc(url)}&${enc(sorted)}`;
+  const signingKey = `${enc(consumerSecret)}&${enc(tokenSecret)}`;
+  const signature = crypto.createHmac("sha1", signingKey).update(baseString).digest("base64");
+  params.oauth_signature = signature;
+  return "OAuth " + Object.keys(params).sort().map((k) => `${enc(k)}="${enc(params[k])}"`).join(", ");
+}
+
+function postTweet(text: string): Promise<{ id: string; text: string }> {
+  const apiKey = process.env.TWITTER_API_KEY;
+  const apiSecret = process.env.TWITTER_API_SECRET;
+  const accessToken = process.env.TWITTER_ACCESS_TOKEN;
+  const accessSecret = process.env.TWITTER_ACCESS_SECRET;
+  if (!apiKey || !apiSecret || !accessToken || !accessSecret) {
+    return Promise.reject(new Error("Twitter credentials not configured. Set TWITTER_API_KEY, TWITTER_API_SECRET, TWITTER_ACCESS_TOKEN, TWITTER_ACCESS_SECRET environment variables."));
+  }
+  const url = "https://api.twitter.com/2/tweets";
+  const auth = twitterOAuthHeader("POST", url, apiKey, apiSecret, accessToken, accessSecret);
+  const body = JSON.stringify({ text });
+  return new Promise((resolve, reject) => {
+    const req = https.request(url, { method: "POST", headers: { Authorization: auth, "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) } }, (res) => {
+      let data = "";
+      res.on("data", (chunk) => (data += chunk));
+      res.on("end", () => {
+        try {
+          const parsed = JSON.parse(data);
+          if (res.statusCode === 201 && parsed.data) {
+            resolve({ id: parsed.data.id, text: parsed.data.text });
+          } else {
+            reject(new Error(`Twitter API error (${res.statusCode}): ${data}`));
+          }
+        } catch {
+          reject(new Error(`Twitter API parse error: ${data}`));
+        }
+      });
+    });
+    req.on("error", reject);
+    req.write(body);
+    req.end();
+  });
+}
+
+function fetchTweetMetrics(tweetIds: string[]): Promise<{ id: string; metrics: { views: number; likes: number; shares: number; comments: number } }[]> {
+  const apiKey = process.env.TWITTER_API_KEY;
+  const apiSecret = process.env.TWITTER_API_SECRET;
+  const accessToken = process.env.TWITTER_ACCESS_TOKEN;
+  const accessSecret = process.env.TWITTER_ACCESS_SECRET;
+  if (!apiKey || !apiSecret || !accessToken || !accessSecret) {
+    return Promise.reject(new Error("Twitter credentials not configured. Set TWITTER_API_KEY, TWITTER_API_SECRET, TWITTER_ACCESS_TOKEN, TWITTER_ACCESS_SECRET environment variables."));
+  }
+  const batches: string[][] = [];
+  for (let i = 0; i < tweetIds.length; i += 100) {
+    batches.push(tweetIds.slice(i, i + 100));
+  }
+  return Promise.all(batches.map((batch) => {
+    const url = `https://api.twitter.com/2/tweets?ids=${batch.join(",")}&tweet.fields=public_metrics`;
+    const auth = twitterOAuthHeader("GET", url.split("?")[0], apiKey, apiSecret, accessToken, accessSecret);
+    return new Promise<{ id: string; metrics: { views: number; likes: number; shares: number; comments: number } }[]>((resolve, reject) => {
+      const req = https.request(url, { method: "GET", headers: { Authorization: auth } }, (res) => {
+        let data = "";
+        res.on("data", (chunk) => (data += chunk));
+        res.on("end", () => {
+          try {
+            const parsed = JSON.parse(data);
+            if (res.statusCode === 200 && parsed.data) {
+              resolve(parsed.data.map((t: any) => ({
+                id: t.id,
+                metrics: {
+                  views: t.public_metrics?.impression_count || 0,
+                  likes: t.public_metrics?.like_count || 0,
+                  shares: (t.public_metrics?.retweet_count || 0) + (t.public_metrics?.quote_count || 0),
+                  comments: t.public_metrics?.reply_count || 0,
+                },
+              })));
+            } else {
+              reject(new Error(`Twitter API error (${res.statusCode}): ${data}`));
+            }
+          } catch {
+            reject(new Error(`Twitter API parse error: ${data}`));
+          }
+        });
+      });
+      req.on("error", reject);
+      req.end();
+    });
+  })).then((results) => results.flat());
+}
+
+// ── Scheduled Posting Helpers ──────────────────────────────────────
+
+interface ScheduleEntry {
+  slug: string;
+  platform: "twitter" | "linkedin";
+  scheduledAt: string; // ISO datetime
+  text: string;
+  status: "queued" | "posted" | "failed" | "cancelled";
+  tweetId?: string;
+  error?: string;
+  createdAt: string;
+}
+
+function scheduleDir(notesDir: string): string {
+  return path.join(notesDir, ".schedule");
+}
+
+function schedulePath(notesDir: string): string {
+  return path.join(scheduleDir(notesDir), "queue.json");
+}
+
+function loadQueue(notesDir: string): ScheduleEntry[] {
+  const p = schedulePath(notesDir);
+  if (!fs.existsSync(p)) return [];
+  try {
+    return JSON.parse(fs.readFileSync(p, "utf8"));
+  } catch {
+    return [];
+  }
+}
+
+function saveQueue(notesDir: string, queue: ScheduleEntry[]): void {
+  const dir = scheduleDir(notesDir);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(schedulePath(notesDir), JSON.stringify(queue, null, 2) + "\n", "utf8");
+}
+
+// ── LinkedIn Posting Helpers ──────────────────────────────────────
+
+function postLinkedIn(text: string): Promise<{ id: string }> {
+  const accessToken = process.env.LINKEDIN_ACCESS_TOKEN;
+  const personUrn = process.env.LINKEDIN_PERSON_URN;
+  if (!accessToken || !personUrn) {
+    return Promise.reject(
+      new Error(
+        "LinkedIn credentials not configured. Set LINKEDIN_ACCESS_TOKEN and LINKEDIN_PERSON_URN environment variables.\n" +
+        "Run: openclaw notes linkedin-auth"
+      )
+    );
+  }
+
+  const payload = JSON.stringify({
+    author: personUrn,
+    commentary: text,
+    visibility: "PUBLIC",
+    distribution: {
+      feedDistribution: "MAIN_FEED",
+      targetEntities: [],
+      thirdPartyDistributionChannels: [],
+    },
+    lifecycleState: "PUBLISHED",
+    isReshareDisabledByAuthor: false,
+  });
+
+  return new Promise((resolve, reject) => {
+    const req = https.request(
+      "https://api.linkedin.com/rest/posts",
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(payload),
+          "LinkedIn-Version": "202401",
+          "X-Restli-Protocol-Version": "2.0.0",
+        },
+      },
+      (res) => {
+        let data = "";
+        res.on("data", (chunk) => (data += chunk));
+        res.on("end", () => {
+          if (res.statusCode === 201) {
+            const postId = res.headers["x-restli-id"] as string || "";
+            resolve({ id: postId });
+          } else {
+            reject(new Error(`LinkedIn API error (${res.statusCode}): ${data}`));
+          }
+        });
+      }
+    );
+    req.on("error", reject);
+    req.write(payload);
+    req.end();
+  });
+}
+
+function exchangeLinkedInAuthCode(
+  clientId: string,
+  clientSecret: string,
+  code: string,
+  redirectUri: string
+): Promise<{ access_token: string; expires_in: number; scope: string }> {
+  const body = [
+    `grant_type=authorization_code`,
+    `code=${encodeURIComponent(code)}`,
+    `client_id=${encodeURIComponent(clientId)}`,
+    `client_secret=${encodeURIComponent(clientSecret)}`,
+    `redirect_uri=${encodeURIComponent(redirectUri)}`,
+  ].join("&");
+
+  return new Promise((resolve, reject) => {
+    const req = https.request(
+      "https://www.linkedin.com/oauth/v2/accessToken",
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+          "Content-Length": Buffer.byteLength(body),
+        },
+      },
+      (res) => {
+        let data = "";
+        res.on("data", (chunk) => (data += chunk));
+        res.on("end", () => {
+          try {
+            const parsed = JSON.parse(data);
+            if (res.statusCode === 200 && parsed.access_token) {
+              resolve(parsed);
+            } else {
+              reject(
+                new Error(
+                  `LinkedIn OAuth error (${res.statusCode}): ${parsed.error_description || parsed.error || data}`
+                )
+              );
+            }
+          } catch {
+            reject(new Error(`LinkedIn OAuth parse error: ${data}`));
+          }
+        });
+      }
+    );
+    req.on("error", reject);
+    req.write(body);
+    req.end();
+  });
+}
+
+function fetchLinkedInPersonUrn(accessToken: string): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const req = https.request(
+      "https://api.linkedin.com/v2/me",
+      {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "X-Restli-Protocol-Version": "2.0.0",
+        },
+      },
+      (res) => {
+        let data = "";
+        res.on("data", (chunk) => (data += chunk));
+        res.on("end", () => {
+          try {
+            const parsed = JSON.parse(data);
+            if (res.statusCode === 200 && parsed.id) {
+              resolve(`urn:li:person:${parsed.id}`);
+            } else {
+              reject(new Error(`LinkedIn profile API error (${res.statusCode}): ${data}`));
+            }
+          } catch {
+            reject(new Error(`LinkedIn profile API parse error: ${data}`));
+          }
+        });
+      }
+    );
+    req.on("error", reject);
+    req.end();
+  });
+}
+
+// ── Persona Marketplace Helpers ───────────────────────────────────
+
+interface Persona {
+  name: string;
+  displayName: string;
+  description: string;
+  version: string;
+  author: string;
+  style: {
+    tone: string;
+    avgSentenceLength?: number;
+    vocabulary?: string;
+    perspective?: string;
+    patterns: string[];
+  };
+  examples: string[];
+  tags: string[];
+}
+
+function personasDir(notesDir: string): string {
+  return path.join(notesDir, ".personas");
+}
+
+function ensurePersonasDir(notesDir: string): void {
+  const dir = personasDir(notesDir);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+function loadInstalledPersonas(notesDir: string): Persona[] {
+  const dir = personasDir(notesDir);
+  if (!fs.existsSync(dir)) return [];
+  const files = fs.readdirSync(dir).filter((f: string) => f.endsWith(".json"));
+  const personas: Persona[] = [];
+  for (const file of files) {
+    try {
+      const data = JSON.parse(fs.readFileSync(path.join(dir, file), "utf8"));
+      personas.push(data as Persona);
+    } catch {
+      // skip malformed files
+    }
+  }
+  return personas;
+}
+
+function loadInstalledPersona(notesDir: string, name: string): Persona | null {
+  const file = path.join(personasDir(notesDir), `${name}.json`);
+  if (!fs.existsSync(file)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8")) as Persona;
+  } catch {
+    return null;
+  }
+}
+
+function validatePersona(data: any): data is Persona {
+  return (
+    typeof data === "object" && data !== null &&
+    typeof data.name === "string" &&
+    typeof data.displayName === "string" &&
+    typeof data.description === "string" &&
+    typeof data.version === "string" &&
+    typeof data.author === "string" &&
+    typeof data.style === "object" && data.style !== null &&
+    typeof data.style.tone === "string" &&
+    Array.isArray(data.style.patterns) &&
+    Array.isArray(data.examples) &&
+    Array.isArray(data.tags)
+  );
+}
+
+function fetchJson(url: string): Promise<any> {
+  return new Promise((resolve, reject) => {
+    const parsedUrl = new URL(url);
+    const options = {
+      hostname: parsedUrl.hostname,
+      path: parsedUrl.pathname + parsedUrl.search,
+      method: "GET",
+      headers: { "Accept": "application/json", "User-Agent": "pressclaw/1.0" },
+    };
+    const req = https.request(options, (res: any) => {
+      let data = "";
+      res.on("data", (chunk: string) => (data += chunk));
+      res.on("end", () => {
+        if (res.statusCode !== 200) {
+          reject(new Error(`HTTP ${res.statusCode}: ${data.slice(0, 200)}`));
+          return;
+        }
+        try {
+          resolve(JSON.parse(data));
+        } catch {
+          reject(new Error(`Invalid JSON response from ${url}`));
+        }
+      });
+    });
+    req.on("error", reject);
+    req.setTimeout(10000, () => { req.destroy(); reject(new Error("Request timed out")); });
+    req.end();
+  });
+}
+
+function slugifyPersonaName(input: string): string {
+  return input
+    .toLowerCase()
+    .replace(/[^a-z0-9\s-]/g, "")
+    .trim()
+    .replace(/\s+/g, "-")
+    .replace(/-+/g, "-");
+}
+
+function updatePerformanceWeights(notesDir: string): void {
+  const profilePath = path.join(notesDir, ".style-profile.json");
+  if (!fs.existsSync(profilePath)) return;
+
+  const allFeedback = loadAllFeedback(notesDir);
+  if (allFeedback.length < 2) return;
+
+  // Gather note data with scores
+  const noteScores: { slug: string; score: number; tone: string | null; structure: string | null; markers: Record<string, any> | null }[] = [];
+  for (const fb of allFeedback) {
+    if (fb.aggregate.entries === 0) continue;
+    const noteFile = path.join(notesDir, `${fb.slug}.md`);
+    if (!fs.existsSync(noteFile)) continue;
+    const { meta, body } = parseFrontMatter(fs.readFileSync(noteFile, "utf8"));
+    let markers: Record<string, any> | null = null;
+    if (meta.style_markers) {
+      try { markers = typeof meta.style_markers === "string" ? JSON.parse(meta.style_markers) : meta.style_markers; } catch {}
+    }
+    if (!markers) markers = extractStyleMarkers(body);
+    noteScores.push({
+      slug: fb.slug,
+      score: fb.aggregate.avgScore,
+      tone: meta.tone || null,
+      structure: meta.structure || null,
+      markers,
+    });
+  }
+
+  if (noteScores.length < 2) return;
+
+  // Find preferred tone (highest avg score)
+  const toneScores: Record<string, { total: number; count: number }> = {};
+  for (const n of noteScores) {
+    if (!n.tone) continue;
+    if (!toneScores[n.tone]) toneScores[n.tone] = { total: 0, count: 0 };
+    toneScores[n.tone].total += n.score;
+    toneScores[n.tone].count += 1;
+  }
+  const preferredTone = Object.entries(toneScores)
+    .map(([tone, d]) => ({ tone, avg: d.total / d.count }))
+    .sort((a, b) => b.avg - a.avg)[0]?.tone || "casual";
+
+  // Find preferred structure
+  const structScores: Record<string, { total: number; count: number }> = {};
+  for (const n of noteScores) {
+    if (!n.structure) continue;
+    if (!structScores[n.structure]) structScores[n.structure] = { total: 0, count: 0 };
+    structScores[n.structure].total += n.score;
+    structScores[n.structure].count += 1;
+  }
+  const preferredStructure = Object.entries(structScores)
+    .map(([structure, d]) => ({ structure, avg: d.total / d.count }))
+    .sort((a, b) => b.avg - a.avg)[0]?.structure || "chunky";
+
+  // Optimal sentence length & word count from top-scoring notes
+  const sorted = [...noteScores].sort((a, b) => b.score - a.score);
+  const topHalf = sorted.slice(0, Math.max(2, Math.ceil(sorted.length / 2)));
+  const sentLengths = topHalf.filter((n) => n.markers?.avgSentenceLength).map((n) => n.markers!.avgSentenceLength);
+  const wordCounts = topHalf.filter((n) => n.markers?.wordCount).map((n) => n.markers!.wordCount);
+
+  const optimalSentenceLength: [number, number] = sentLengths.length > 0
+    ? [Math.round(Math.min(...sentLengths)), Math.round(Math.max(...sentLengths))]
+    : [7, 15];
+  const optimalWordCount: [number, number] = wordCounts.length > 0
+    ? [Math.round(Math.min(...wordCounts)), Math.round(Math.max(...wordCounts))]
+    : [200, 500];
+
+  // Update style profile
+  let profile: any;
+  try { profile = JSON.parse(fs.readFileSync(profilePath, "utf8")); } catch { return; }
+  profile.performanceWeights = {
+    preferredTone,
+    preferredStructure,
+    optimalSentenceLength,
+    optimalWordCount,
+    sampleSize: noteScores.length,
+  };
+  fs.writeFileSync(profilePath, JSON.stringify(profile, null, 2) + "\n", "utf8");
+}
+
+// ── Topics ──────────────────────────────────────────────────────────
+
+interface Topic {
+  id: string;
+  title: string;
+  source?: string;
+  added: string;
+  status: "idea" | "drafted" | "refined" | "published";
+  slug?: string | null;
+  tags?: string[];
+}
+
+function topicsPath(notesDir: string) {
+  return path.join(notesDir, "topics.json");
+}
+
+function readTopics(notesDir: string): Topic[] {
+  const p = topicsPath(notesDir);
+  if (!fs.existsSync(p)) return [];
+  try {
+    return JSON.parse(fs.readFileSync(p, "utf8"));
+  } catch {
+    return [];
+  }
+}
+
+function writeTopics(notesDir: string, topics: Topic[]) {
+  fs.mkdirSync(notesDir, { recursive: true });
+  fs.writeFileSync(topicsPath(notesDir), JSON.stringify(topics, null, 2) + "\n", "utf8");
+}
+
+function generateId(): string {
+  return Math.random().toString(36).slice(2, 10);
+}
+
+function findTopicByIdOrTitle(topics: Topic[], query: string): Topic | undefined {
+  const byId = topics.find((t) => t.id === query);
+  if (byId) return byId;
+  const lower = query.toLowerCase();
+  return topics.find((t) => t.title.toLowerCase() === lower)
+    || topics.find((t) => t.title.toLowerCase().startsWith(lower));
+}
+
+function syncTopicStatus(notesDir: string, topics: Topic[]): Topic[] {
+  let changed = false;
+  for (const topic of topics) {
+    if (!topic.slug) continue;
+    const noteFile = path.join(notesDir, `${topic.slug}.md`);
+    if (!fs.existsSync(noteFile)) continue;
+    const { meta } = parseFrontMatter(fs.readFileSync(noteFile, "utf8"));
+    let noteStatus: Topic["status"];
+    if (meta.status === "public") noteStatus = "published";
+    else if (meta.status === "refined") noteStatus = "refined";
+    else noteStatus = "drafted";
+    if (topic.status !== noteStatus) {
+      topic.status = noteStatus;
+      changed = true;
+    }
+  }
+  if (changed) writeTopics(notesDir, topics);
+  return topics;
+}
+
+function uniqueSlug(base: string, notesDir: string) {
+  let slug = base;
+  let i = 2;
+  while (fs.existsSync(path.join(notesDir, `${slug}.md`))) {
+    slug = `${base}-${i}`;
+    i += 1;
+  }
+  return slug;
+}
+
+async function confirmPublishPrompt(title: string, excerpt: string) {
+  if (!process.stdin.isTTY) {
+    throw new Error("Publish requires confirmation; use --yes in non-interactive mode.");
+  }
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const answer = await rl.question(`Publish \"${title}\"? (y/N)\n${excerpt}\n> `);
+  if (!(answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes")) {
+    rl.close();
+    return { ok: false } as const;
+  }
+  const reason = await rl.question("Why publish this? (optional)\n> ");
+  rl.close();
+  return { ok: true, reason: reason.trim() } as const;
+}
+
+function buildPublic({ notesDir, outputDir, publicPath, siteTitle, authorName, baseUrl }: any) {
+  ensureDirs(outputDir);
+  const files = listNotes(notesDir);
+  const items: { title: string; slug: string; date: string; excerpt: string; bodyHtml: string }[] = [];
+  for (const file of files) {
+    const full = fs.readFileSync(path.join(notesDir, file), "utf8");
+    const { meta, body } = parseFrontMatter(full);
+    if (meta.status !== "public") continue;
+    const title = meta.title || file.replace(/\.md$/, "");
+    const slug = meta.slug || slugify(title);
+    const date = meta.published_at || new Date().toUTCString();
+    const excerpt = excerptFrom(body);
+    const bodyHtml = renderMarkdown(body);
+    items.push({ title, slug, date, excerpt, bodyHtml });
+
+    const html = renderPostPage(title, bodyHtml, { siteTitle, authorName, date });
+    fs.writeFileSync(path.join(outputDir, "posts", `${slug}.html`), html, "utf8");
+  }
+
+  const indexHtml = renderIndexPage(items, { siteTitle, baseUrl });
+  fs.writeFileSync(path.join(outputDir, "index.html"), indexHtml, "utf8");
+  const rss = renderRss(items, { siteTitle, baseUrl: baseUrl || "" });
+  fs.writeFileSync(path.join(outputDir, "rss.xml"), rss, "utf8");
+}
+
+// ── Note frontmatter helpers ────────────────────────────────────────
+
+function newNoteFrontmatter(opts: { title: string; slug: string; topicId?: string; inputType?: string; tags?: string[] }): string {
+  const tags = opts.tags?.length ? `[${opts.tags.map((t) => `"${t}"`).join(", ")}]` : "[]";
+  let fm = `---\ntitle: "${opts.title}"\nslug: "${opts.slug}"\nstatus: private\npublished_at: null\n`;
+  if (opts.topicId) fm += `topic_id: "${opts.topicId}"\n`;
+  if (opts.inputType) fm += `input_type: "${opts.inputType}"\n`;
+  fm += `tone: null\nstructure: null\nconfidence: null\ntags: ${tags}\n---\n`;
+  return fm;
+}
+
+// ── Agent Feed Helpers ──────────────────────────────────────────────
+
+function parseTags(raw: any): string[] {
+  if (!raw) return [];
+  if (Array.isArray(raw)) return raw;
+  if (typeof raw === "string") {
+    const trimmed = raw.trim();
+    if (trimmed.startsWith("[")) {
+      try { return JSON.parse(trimmed); } catch {}
+    }
+    return trimmed.split(",").map((s) => s.trim()).filter(Boolean);
+  }
+  return [];
+}
+
+function parseStyleMarkers(raw: any): Record<string, any> | null {
+  if (!raw) return null;
+  if (typeof raw === "object" && !Array.isArray(raw)) return raw;
+  if (typeof raw === "string") {
+    try { return JSON.parse(raw); } catch {}
+  }
+  return null;
+}
+
+function generateSummary(body: string): string {
+  const plain = body
+    .replace(/^#+\s+.*/gm, "")
+    .replace(/\*\*([^*]+)\*\*/g, "$1")
+    .replace(/\*([^*]+)\*/g, "$1")
+    .replace(/`[^`]+`/g, "")
+    .replace(/```[\s\S]*?```/g, "")
+    .replace(/\[([^\]]+)\]\([^)]+\)/g, "$1")
+    .replace(/^>\s+/gm, "")
+    .replace(/^[-*]\s+/gm, "")
+    .replace(/^\d+\.\s+/gm, "")
+    .replace(/\n+/g, " ")
+    .trim();
+  // First 2 sentences or 200 chars
+  const sentences = plain.match(/[^.!?]*[.!?]/g);
+  if (sentences && sentences.length >= 2) {
+    const twoSentences = sentences.slice(0, 2).join("").trim();
+    if (twoSentences.length <= 300) return twoSentences;
+  }
+  return plain.slice(0, 200).trim() + (plain.length > 200 ? "…" : "");
+}
+
+interface AgentFeedPost {
+  slug: string;
+  title: string;
+  published_at: string;
+  url: string;
+  body_markdown: string;
+  summary: string;
+  topics: string[];
+  tags: string[];
+  style_markers: Record<string, any> | null;
+  confidence: number | null;
+  related: string[];
+  reply_to: string | null;
+  conversation_id: string | null;
+}
+
+interface AgentFeed {
+  version: string;
+  protocol: string;
+  source: {
+    name: string;
+    url: string;
+    pressclaw_version: string;
+    feed_url: string;
+  };
+  updated_at: string;
+  posts: AgentFeedPost[];
+}
+
+interface WellKnown {
+  version: string;
+  name: string;
+  feed_url: string;
+  human_url: string;
+  rss_url: string;
+  post_count: number;
+  topics: string[];
+  updated_at: string;
+}
+
+function buildAgentFeed(cfg: { notesDir: string; baseUrl: string; siteTitle: string; publicPath: string }): AgentFeed {
+  const files = listNotes(cfg.notesDir);
+  const posts: AgentFeedPost[] = [];
+
+  for (const file of files) {
+    const full = fs.readFileSync(path.join(cfg.notesDir, file), "utf8");
+    const { meta, body } = parseFrontMatter(full);
+    if (meta.status !== "public") continue;
+
+    const slug = meta.slug || file.replace(/\.md$/, "");
+    const title = meta.title || slug;
+    const tags = parseTags(meta.tags);
+    const sm = parseStyleMarkers(meta.style_markers);
+    const conf = meta.confidence ? parseFloat(meta.confidence) : null;
+
+    posts.push({
+      slug,
+      title,
+      published_at: meta.published_at || new Date().toISOString(),
+      url: `${cfg.baseUrl}${cfg.publicPath}/${slug}`,
+      body_markdown: body,
+      summary: generateSummary(body),
+      topics: tags, // derive from tags for now
+      tags,
+      style_markers: sm ? {
+        tone: meta.tone || sm.tone || "authentic",
+        structure: meta.structure || sm.structure || "structured",
+        readability: sm.readabilityScore ?? sm.readability ?? null,
+        wordCount: sm.wordCount ?? null,
+        avgSentenceLength: sm.avgSentenceLength ?? null,
+        perspective: sm.perspective ?? "mixed",
+      } : null,
+      confidence: isNaN(conf as number) ? null : conf,
+      related: [],
+      reply_to: meta.reply_to || null,
+      conversation_id: meta.conversation_id || null,
+    });
+  }
+
+  // Sort by published_at descending
+  posts.sort((a, b) => new Date(b.published_at).getTime() - new Date(a.published_at).getTime());
+
+  const updatedAt = posts.length > 0 ? posts[0].published_at : new Date().toISOString();
+
+  return {
+    version: "0.4",
+    protocol: "pressclaw-agent-feed",
+    source: {
+      name: cfg.siteTitle,
+      url: cfg.baseUrl,
+      pressclaw_version: "0.3.0",
+      feed_url: `${cfg.baseUrl}/feed/agent.json`,
+    },
+    updated_at: updatedAt,
+    posts,
+  };
+}
+
+function buildWellKnown(cfg: { notesDir: string; baseUrl: string; siteTitle: string; publicPath: string }): WellKnown {
+  const feed = buildAgentFeed(cfg);
+  const allTopics = new Set<string>();
+  for (const post of feed.posts) {
+    for (const t of post.topics) allTopics.add(t);
+  }
+
+  return {
+    version: "0.4",
+    name: cfg.siteTitle,
+    feed_url: `${cfg.baseUrl}/feed/agent.json`,
+    human_url: `${cfg.baseUrl}${cfg.publicPath}`,
+    rss_url: `${cfg.baseUrl}${cfg.publicPath}/rss.xml`,
+    post_count: feed.posts.length,
+    topics: Array.from(allTopics),
+    updated_at: feed.updated_at,
+  };
+}
+
+interface Subscription {
+  url: string;
+  name: string;
+  feed_url: string;
+  added: string;
+  last_checked: string | null;
+}
+
+function subscriptionsPath(notesDir: string): string {
+  return path.join(notesDir, ".subscriptions.json");
+}
+
+function readSubscriptions(notesDir: string): Subscription[] {
+  const p = subscriptionsPath(notesDir);
+  if (!fs.existsSync(p)) return [];
+  try {
+    const data = JSON.parse(fs.readFileSync(p, "utf8"));
+    return data.subscriptions || [];
+  } catch {
+    return [];
+  }
+}
+
+function writeSubscriptions(notesDir: string, subs: Subscription[]): void {
+  fs.mkdirSync(notesDir, { recursive: true });
+  fs.writeFileSync(
+    subscriptionsPath(notesDir),
+    JSON.stringify({ subscriptions: subs }, null, 2) + "\n",
+    "utf8"
+  );
+}
+
+// ── Plugin ──────────────────────────────────────────────────────────
+
+export default function register(api: any) {
+  const pluginDir = __dirname;
+
+  api.registerCli(({ program }: any) => {
+    const notes = program.command("notes");
+
+    // ── default (dashboard) ────────────────────────────────────────
+    notes.action(() => {
+      const cfg = resolveConfig(api);
+      const files = listNotes(cfg.notesDir);
+      const topics = syncTopicStatus(cfg.notesDir, readTopics(cfg.notesDir));
+      const styleProfile = loadStyleProfile(cfg.notesDir);
+
+      const ideas = topics.filter((t) => t.status === "idea");
+      const drafted = topics.filter((t) => t.status === "drafted");
+      const refined = topics.filter((t) => t.status === "refined");
+      const published = topics.filter((t) => t.status === "published");
+
+      console.log(`\n📊 Notes Dashboard`);
+      console.log(`   ${ideas.length} ideas · ${drafted.length} drafted · ${refined.length} refined · ${published.length} published · ${files.length} files`);
+      if (styleProfile) {
+        console.log(`   🎨 Style profile: updated ${styleProfile.updated} (${styleProfile.analyzedNotes.length} notes analyzed)`);
+      } else {
+        console.log(`   🎨 No style profile yet — run: openclaw notes style`);
+      }
+      console.log();
+
+      if (published.length > 0) {
+        console.log(`📢 Published:`);
+        for (const t of published) {
+          const conf = _noteConfidence(cfg.notesDir, t.slug);
+          console.log(`   ${t.title}  → ${t.slug}${conf !== null ? `  (confidence: ${conf}/10)` : ""}`);
+        }
+        console.log();
+      }
+
+      if (refined.length > 0) {
+        console.log(`✨ Refined (ready to publish):`);
+        for (const t of refined) {
+          const conf = _noteConfidence(cfg.notesDir, t.slug);
+          console.log(`   ${t.title}  → ${t.slug}.md${conf !== null ? `  (confidence: ${conf}/10)` : ""}`);
+        }
+        console.log();
+      }
+
+      if (drafted.length > 0) {
+        console.log(`📝 Drafted:`);
+        for (const t of drafted) {
+          const varCount = _variationCount(cfg.notesDir, t.slug);
+          console.log(`   ${t.title}  → ${t.slug}.md${varCount > 0 ? `  (${varCount} variations)` : ""}`);
+        }
+        console.log();
+      }
+
+      const trackedSlugs = new Set(topics.map((t) => t.slug).filter(Boolean));
+      const orphans = files.filter((f) => !trackedSlugs.has(f.replace(/\.md$/, "")));
+      if (orphans.length > 0) {
+        console.log(`📄 Untracked notes:`);
+        for (const f of orphans) {
+          const full = fs.readFileSync(path.join(cfg.notesDir, f), "utf8");
+          const { meta } = parseFrontMatter(full);
+          const status = meta.status === "public" ? "📢" : meta.status === "refined" ? "✨" : "🔒";
+          const title = meta.title || f.replace(/\.md$/, "");
+          console.log(`   ${status} ${title}  (${f})`);
+        }
+        console.log();
+      }
+
+      if (ideas.length > 0) {
+        console.log(`💡 Ideas (${ideas.length}):`);
+        for (const t of ideas) {
+          const tags = t.tags?.length ? ` [${t.tags.join(", ")}]` : "";
+          console.log(`   ${t.id}  ${t.title}${tags}`);
+        }
+        console.log();
+      }
+
+      if (files.length === 0 && topics.length === 0) {
+        console.log(`   Empty! Run: openclaw notes init`);
+      }
+    });
+
+    // ── init ───────────────────────────────────────────────────────
+    notes.command("init").action(() => {
+      const cfg = resolveConfig(api);
+      ensureDirs(cfg.outputDir);
+      fs.mkdirSync(cfg.notesDir, { recursive: true });
+
+      const existing = listNotes(cfg.notesDir);
+      if (existing.length === 0) {
+        const templateSrc = path.join(pluginDir, "templates", "default.md");
+        if (fs.existsSync(templateSrc)) {
+          const dest = path.join(cfg.notesDir, "your-first-note.md");
+          fs.copyFileSync(templateSrc, dest);
+          console.log(`  Created example note: ${dest}`);
+        }
+      }
+
+      console.log(`\n✅ Public Thinking initialized!`);
+      console.log(`   Notes directory: ${cfg.notesDir}`);
+      console.log(`   Output directory: ${cfg.outputDir}`);
+      console.log(`\nNext steps:`);
+      console.log(`  1. Create a note:    openclaw notes new "My First Idea"`);
+      console.log(`  2. Edit the .md file in your notes directory`);
+      console.log(`  3. Publish it:       openclaw notes publish my-first-idea`);
+      if (cfg.dailyPrompt.enabled) {
+        console.log(`\n📅 Daily prompt is enabled. Run this to set up the cron job:`);
+        console.log(`     openclaw notes setup`);
+      }
+    });
+
+    // ── setup ──────────────────────────────────────────────────────
+    notes.command("setup").action(async () => {
+      const cfg = resolveConfig(api);
+
+      if (!cfg.dailyPrompt.enabled) {
+        console.log("Daily prompt is disabled in config. Set dailyPrompt.enabled to true to use this.");
+        return;
+      }
+
+      try {
+        const cronList = await api.cron?.list?.();
+        if (cronList && Array.isArray(cronList)) {
+          const existing = cronList.find((j: any) => j.name === "pressclaw-daily");
+          if (existing) {
+            console.log("✅ Cron job 'pressclaw-daily' already exists. Skipping.");
+            console.log(`   Schedule: ${existing.schedule || existing.cron || cfg.dailyPrompt.schedule}`);
+            return;
+          }
+        }
+      } catch { }
+
+      try {
+        await api.cron?.create?.({
+          name: "pressclaw-daily",
+          schedule: cfg.dailyPrompt.schedule,
+          timezone: cfg.dailyPrompt.timezone,
+          prompt: cfg.dailyPrompt.prompt,
+        });
+        console.log(`✅ Daily prompt cron job created!`);
+        console.log(`   Name:     pressclaw-daily`);
+        console.log(`   Schedule: ${cfg.dailyPrompt.schedule}`);
+        console.log(`   Timezone: ${cfg.dailyPrompt.timezone}`);
+      } catch (err: any) {
+        console.error(`Failed to create cron job via API. You can create it manually:\n`);
+        console.log(`  openclaw cron create \\`);
+        console.log(`    --name "pressclaw-daily" \\`);
+        console.log(`    --schedule "${cfg.dailyPrompt.schedule}" \\`);
+        console.log(`    --timezone "${cfg.dailyPrompt.timezone}" \\`);
+        console.log(`    --prompt '${cfg.dailyPrompt.prompt.replace(/'/g, "'\\''")}'`);
+        if (err?.message) console.error(`\nError: ${err.message}`);
+      }
+    });
+
+    // ── new ────────────────────────────────────────────────────────
+    notes.command("new <title>").action((title: string) => {
+      const cfg = resolveConfig(api);
+      fs.mkdirSync(cfg.notesDir, { recursive: true });
+      const base = slugify(title);
+      const slug = uniqueSlug(base, cfg.notesDir);
+      const content = newNoteFrontmatter({ title, slug }) + `\n# ${title}\n\n`;
+      const filename = path.join(cfg.notesDir, `${slug}.md`);
+      fs.writeFileSync(filename, content, "utf8");
+      console.log(`Created ${filename}`);
+    });
+
+    // ── publish ────────────────────────────────────────────────────
+    notes
+      .command("publish <slug>")
+      .option("-y, --yes", "skip confirmation")
+      .option("-r, --reason <text>", "reason for publishing")
+      .action(async (slug: string, options: any) => {
+        const cfg = resolveConfig(api);
+        const file = path.join(cfg.notesDir, `${slug}.md`);
+        const full = fs.readFileSync(file, "utf8");
+        const { meta, body } = parseFrontMatter(full);
+        const title = meta.title || slug;
+        const excerpt = excerptFrom(body);
+        let publishReason = options.reason || "";
+
+        if (!options.yes) {
+          const result = await confirmPublishPrompt(title, excerpt);
+          if (!result.ok) {
+            console.log("Publish canceled.");
+            return;          }
+          if (!publishReason) publishReason = result.reason || "";
+        }
+
+        // Extract style markers before writing
+        const markers = extractStyleMarkers(body);
+        const pubMeta: Record<string, any> = {
+          title,
+          slug: meta.slug || slug,
+          status: "public",
+          published_at: new Date().toUTCString(),
+          publish_reason: publishReason.replace(/"/g, '\\"'),
+          topic_id: meta.topic_id || null,
+          tone: meta.tone || null,
+          structure: meta.structure || null,
+          confidence: meta.confidence || null,
+          tags: meta.tags || "[]",
+        };
+        const updated = writeFrontmatterWithMarkers(pubMeta, body, markers);
+        fs.writeFileSync(file, updated, "utf8");
+        buildPublic(cfg);
+
+        // Auto-update aggregate style profile
+        const profileResult = updateAggregateProfile(cfg.notesDir);
+        if (profileResult.updated) {
+          console.log(`🎨 Style profile auto-updated (${profileResult.noteCount} notes analyzed)`);
+        }
+
+        const topics = readTopics(cfg.notesDir);
+        const linked = topics.find((t) => t.slug === (meta.slug || slug));
+        if (linked && linked.status !== "published") {
+          linked.status = "published";
+          writeTopics(cfg.notesDir, topics);
+        }
+
+        console.log(`Published ${slug}`);
+      });
+
+    // ── unpublish ──────────────────────────────────────────────────
+    notes.command("unpublish <slug>").action((slug: string) => {
+      const cfg = resolveConfig(api);
+      const file = path.join(cfg.notesDir, `${slug}.md`);
+      const full = fs.readFileSync(file, "utf8");
+      const { meta, body } = parseFrontMatter(full);
+      const updated = `---\ntitle: "${meta.title || slug}"\nslug: "${meta.slug || slug}"\nstatus: private\npublished_at: ${meta.published_at || "null"}\ntone: ${meta.tone || "null"}\nstructure: ${meta.structure || "null"}\nconfidence: ${meta.confidence || "null"}\ntags: ${meta.tags || "[]"}\n---\n\n${body}\n`;
+      fs.writeFileSync(file, updated, "utf8");
+      const publicFile = path.join(cfg.outputDir, "posts", `${slug}.html`);
+      if (fs.existsSync(publicFile)) fs.unlinkSync(publicFile);
+      buildPublic(cfg);
+      console.log(`Unpublished ${slug}`);
+    });
+
+    // ── build ──────────────────────────────────────────────────────
+    notes.command("build").action(() => {
+      const cfg = resolveConfig(api);
+      buildPublic(cfg);
+
+      // Generate agent feed
+      if (cfg.baseUrl) {
+        const feedDir = path.join(cfg.outputDir, "feed");
+        fs.mkdirSync(feedDir, { recursive: true });
+        const agentFeed = buildAgentFeed(cfg);
+        fs.writeFileSync(path.join(feedDir, "agent.json"), JSON.stringify(agentFeed, null, 2) + "\n", "utf8");
+
+        const wellKnownDir = path.join(cfg.outputDir, ".well-known");
+        fs.mkdirSync(wellKnownDir, { recursive: true });
+        const wellKnown = buildWellKnown(cfg);
+        fs.writeFileSync(path.join(wellKnownDir, "pressclaw.json"), JSON.stringify(wellKnown, null, 2) + "\n", "utf8");
+
+        console.log("Built public stream + RSS + agent feed");
+      } else {
+        console.log("Built public stream + RSS (set baseUrl in config for agent feed)");
+      }
+    });
+
+    // ── list ───────────────────────────────────────────────────────
+    notes.command("list").action(() => {
+      const cfg = resolveConfig(api);
+      const files = listNotes(cfg.notesDir);
+      const topics = syncTopicStatus(cfg.notesDir, readTopics(cfg.notesDir));
+
+      if (files.length === 0 && topics.length === 0) {
+        console.log("No notes or topics found. Run `openclaw notes init` to get started.");
+        return;
+      }
+
+      if (files.length > 0) {
+        console.log("\n📝 Notes:");
+        for (const f of files) {
+          const full = fs.readFileSync(path.join(cfg.notesDir, f), "utf8");
+          const { meta } = parseFrontMatter(full);
+          const status = meta.status === "public" ? "📢" : meta.status === "refined" ? "✨" : "🔒";
+          const title = meta.title || f.replace(/\.md$/, "");
+          console.log(`  ${status} ${f.padEnd(35)} ${title}`);
+        }
+      }
+
+      const ideas = topics.filter((t) => t.status === "idea");
+      if (ideas.length > 0) {
+        console.log("\n💡 Topics (ideas — no draft yet):");
+        for (const t of ideas) {
+          const src = t.source ? ` (${t.source})` : "";
+          const tags = t.tags?.length ? ` [${t.tags.join(", ")}]` : "";
+          console.log(`  ${t.id}  ${t.title}${src}${tags}`);
+        }
+      }
+    });
+
+    // ── topics ─────────────────────────────────────────────────────
+    const topicsCmd = notes.command("topics").description("Manage topic backlog");
+
+    topicsCmd.action(() => {
+      const cfg = resolveConfig(api);
+      const topics = syncTopicStatus(cfg.notesDir, readTopics(cfg.notesDir));
+      if (topics.length === 0) {
+        console.log("No topics yet. Add one with: openclaw notes topics add \"Title\"");
+        return;
+      }
+
+      const ideas = topics.filter((t) => t.status === "idea");
+      const drafted = topics.filter((t) => t.status === "drafted");
+      const refined = topics.filter((t) => t.status === "refined");
+      const published = topics.filter((t) => t.status === "published");
+
+      if (ideas.length > 0) {
+        console.log("\n💡 Ideas:");
+        for (const t of ideas) {
+          const src = t.source ? ` — ${t.source}` : "";
+          const tags = t.tags?.length ? ` [${t.tags.join(", ")}]` : "";
+          console.log(`  ${t.id}  ${t.title}${src}${tags}  (${t.added})`);
+        }
+      }
+      if (drafted.length > 0) {
+        console.log("\n📝 Drafted:");
+        for (const t of drafted) console.log(`  ${t.id}  ${t.title}  → ${t.slug}.md`);
+      }
+      if (refined.length > 0) {
+        console.log("\n✨ Refined:");
+        for (const t of refined) console.log(`  ${t.id}  ${t.title}  → ${t.slug}.md`);
+      }
+      if (published.length > 0) {
+        console.log("\n📢 Published:");
+        for (const t of published) console.log(`  ${t.id}  ${t.title}  → ${t.slug}.md`);
+      }
+    });
+
+    topicsCmd
+      .command("add <title>")
+      .option("-s, --source <text>", "where the idea came from")
+      .option("-t, --tags <tags>", "comma-separated tags")
+      .action((title: string, options: any) => {
+        const cfg = resolveConfig(api);
+        const topics = readTopics(cfg.notesDir);
+        const topic: Topic = {
+          id: generateId(),
+          title,
+          source: options.source || undefined,
+          added: new Date().toISOString().split("T")[0],
+          status: "idea",
+          slug: null,
+          tags: options.tags ? options.tags.split(",").map((s: string) => s.trim()) : undefined,
+        };
+        topics.push(topic);
+        writeTopics(cfg.notesDir, topics);
+        console.log(`Added topic ${topic.id}: "${title}"`);
+      });
+
+    topicsCmd.command("draft <query>").action((query: string) => {
+      const cfg = resolveConfig(api);
+      const topics = readTopics(cfg.notesDir);
+      const topic = findTopicByIdOrTitle(topics, query);
+      if (!topic) { console.log(`Topic not found: "${query}". Use 'openclaw notes topics' to see available topics.`); return; }
+      if (topic.status !== "idea") { console.log(`Topic "${topic.title}" already has status "${topic.status}" → ${topic.slug}.md`); return; }
+      fs.mkdirSync(cfg.notesDir, { recursive: true });
+      const base = slugify(topic.title);
+      const slug = uniqueSlug(base, cfg.notesDir);
+      const content = newNoteFrontmatter({ title: topic.title, slug, topicId: topic.id, tags: topic.tags }) + `\n# ${topic.title}\n\n`;
+      const filename = path.join(cfg.notesDir, `${slug}.md`);
+      fs.writeFileSync(filename, content, "utf8");
+      topic.status = "drafted";
+      topic.slug = slug;
+      writeTopics(cfg.notesDir, topics);
+      console.log(`Created ${filename} from topic "${topic.title}"`);
+    });
+
+    topicsCmd.command("remove <query>").action((query: string) => {
+      const cfg = resolveConfig(api);
+      const topics = readTopics(cfg.notesDir);
+      const topic = findTopicByIdOrTitle(topics, query);
+      if (!topic) { console.log(`Topic not found: "${query}".`); return; }
+      const filtered = topics.filter((t) => t.id !== topic.id);
+      writeTopics(cfg.notesDir, filtered);
+      console.log(`Removed topic ${topic.id}: "${topic.title}"`);
+    });
+
+    topicsCmd
+      .command("scan")
+      .option("--suggest", "output a prompt for the agent to evaluate and propose topics")
+      .action((options: any) => {
+        const cfg = resolveConfig(api);
+        const workspace = resolveWorkspace(api);
+        const excludeDirs = new Set([path.resolve(cfg.notesDir), path.resolve(cfg.outputDir)]);
+        const excludeDirNames = new Set(["node_modules", ".git", ".cache"]);
+        interface ScannedFile { relPath: string; title: string; excerpt: string; sizeBytes: number; }
+        const scanned: ScannedFile[] = [];
+        const dirsSeen = new Set<string>();
+
+        function walkDir(dir: string) {
+          let entries: string[];
+          try { entries = fs.readdirSync(dir); } catch { return; }
+          for (const entry of entries) {
+            const fullPath = path.join(dir, entry);
+            let stat: fs.Stats;
+            try { stat = fs.statSync(fullPath); } catch { continue; }
+            if (stat.isDirectory()) {
+              if (excludeDirNames.has(entry)) continue;
+              if (excludeDirs.has(path.resolve(fullPath))) continue;
+              walkDir(fullPath);
+            } else if (stat.isFile() && entry.endsWith(".md")) {
+              const relPath = path.relative(workspace, fullPath);
+              dirsSeen.add(path.dirname(relPath));
+              let content: string;
+              try { content = fs.readFileSync(fullPath, "utf8"); } catch { continue; }
+              let title = entry.replace(/\.md$/, "");
+              const headingMatch = content.match(/^#\s+(.+)$/m);
+              if (headingMatch) title = headingMatch[1].trim();
+              else { const { meta } = parseFrontMatter(content); if (meta.title) title = meta.title; }
+              const { body } = parseFrontMatter(content);
+              const plainBody = body.replace(/^#+\s+.*$/gm, "").replace(/[#*_`>\[\]]/g, "").trim();
+              const excerpt = plainBody.slice(0, 200).replace(/\n/g, " ").trim();
+              scanned.push({ relPath, title, excerpt, sizeBytes: stat.size });
+            }
+          }
+        }
+        walkDir(workspace);
+
+        const topics = syncTopicStatus(cfg.notesDir, readTopics(cfg.notesDir));
+        const noteFiles = listNotes(cfg.notesDir);
+        const trackedSources = new Set<string>();
+        for (const topic of topics) {
+          if (topic.source) trackedSources.add(topic.source);
+          if (topic.slug) {
+            trackedSources.add(`${topic.slug}.md`);
+            trackedSources.add(path.relative(workspace, path.join(cfg.notesDir, `${topic.slug}.md`)));
+          }
+        }
+        for (const nf of noteFiles) trackedSources.add(path.relative(workspace, path.join(cfg.notesDir, nf)));
+        const untracked = scanned.filter((f) => !trackedSources.has(f.relPath));
+        const ideas = topics.filter((t) => t.status === "idea").length;
+        const drafted = topics.filter((t) => t.status === "drafted").length;
+        const refined = topics.filter((t) => t.status === "refined").length;
+        const published = topics.filter((t) => t.status === "published").length;
+        function formatSize(bytes: number): string { return bytes < 1024 ? `${bytes}B` : `${(bytes / 1024).toFixed(1)}KB`; }
+
+        if (options.suggest) {
+          console.log(`🤖 Agent review requested. Evaluate these workspace files for publishable topics.`);
+          console.log(`Consider: What insights, lessons, or ideas here would be interesting as standalone blog posts?`);
+          console.log(`Only suggest topics that are atomic (one idea per post) and would be valuable to a general audience.\n`);
+          console.log(`Already tracking ${topics.length} topics (${ideas} ideas, ${drafted} drafted, ${refined} refined, ${published} published).\n`);
+          if (untracked.length === 0) { console.log(`All ${scanned.length} workspace markdown files are already tracked. Nothing new to suggest.`); return; }
+          for (const f of untracked) {
+            console.log(`  ${f.relPath} — "${f.title}" (${formatSize(f.sizeBytes)})`);
+            if (f.excerpt) console.log(`    ${f.excerpt.slice(0, 120)}${f.excerpt.length > 120 ? "…" : ""}`);
+          }
+          console.log(`\nFor each suggestion, run:\n  openclaw notes topics add "Title" --source "file.md" --tags "tag1,tag2"`);
+        } else {
+          console.log(`📂 Workspace scan complete\n`);
+          console.log(`Found ${scanned.length} markdown files across ${dirsSeen.size} directories.`);
+          console.log(`Already tracking ${topics.length} topics (${ideas} ideas, ${drafted} drafted, ${refined} refined, ${published} published).\n`);
+          if (untracked.length === 0) { console.log(`✅ All workspace markdown files are already tracked or part of the notes pipeline.`); return; }
+          console.log(`📄 Untracked files (not linked to any topic):`);
+          for (const f of untracked) console.log(`  ${f.relPath} — "${f.title}" (${formatSize(f.sizeBytes)})`);
+          console.log(`\nTo add a topic from this scan:\n  openclaw notes topics add "Title" --source "path/to/source.md"`);
+        }
+      });
+
+    // ── transform ──────────────────────────────────────────────────
+    notes
+      .command("transform <slug>")
+      .option("--tone <tone>", "target tone: authentic | professional | casual | humorous")
+      .option("--structure <structure>", "target structure: structured | list | chunky | minimal | storytelling | thread | tldr")
+      .action((slug: string, options: any) => {
+        const cfg = resolveConfig(api);
+        const file = path.join(cfg.notesDir, `${slug}.md`);
+        if (!fs.existsSync(file)) { console.log(`Note not found: ${slug}.md`); return; }
+        const full = fs.readFileSync(file, "utf8");
+        const { meta, body } = parseFrontMatter(full);
+        const title = meta.title || slug;
+        const wordCount = body.split(/\s+/).filter((w: string) => w.length > 0).length;
+        const styleProfile = loadStyleProfile(cfg.notesDir);
+        const tone = options.tone || meta.tone || "authentic";
+        const structure = options.structure || meta.structure || "structured";
+        const structureTpl = getStructureTemplate(pluginDir, structure);
+
+        console.log(`✨ Transform: "${title}"`);
+        console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+        console.log(`Tone: ${tone} | Structure: ${structure}`);
+        if (styleProfile) console.log(`Style profile loaded (${styleProfile.analyzedNotes.length} notes analyzed)`);
+        console.log();
+        console.log(`Original (${wordCount} words):`);
+        console.log(body);
+        console.log();
+        console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+        console.log(`Transform this note into a polished blog post.\n`);
+
+        // Style profile injection
+        if (styleProfile) {
+          console.log(`🎨 STYLE PROFILE — Maintain this voice:`);
+          console.log(`   ${styleProfile.voiceDescription}`);
+          if (styleProfile.avoid?.length) console.log(`   Avoid: ${styleProfile.avoid.join(", ")}`);
+          if (styleProfile.examples?.strongOpeners?.length) console.log(`   Example opener: "${styleProfile.examples.strongOpeners[0]}"`);
+          console.log();
+        }
+
+        // Structure template injection
+        if (structureTpl) {
+          console.log(`📋 STRUCTURE — ${structureTpl.name}: ${structureTpl.description}`);
+          console.log(`   ${structureTpl.instructions}`);
+          console.log();
+        }
+
+        // Tone instruction
+        console.log(`🎭 TONE — ${tone}:`);
+        const toneInstructions: Record<string, string> = {
+          authentic: "Preserve the author's natural voice. Mirror their tone whether formal or casual.",
+          professional: "Use formal, business-appropriate language. Be clear, authoritative, and polished.",
+          casual: "Use friendly, conversational language. Be approachable and relatable.",
+          humorous: "Add light humor where appropriate. Be witty but not at the expense of clarity.",
+        };
+        console.log(`   ${toneInstructions[tone] || toneInstructions.authentic}`);
+        console.log();
+
+        console.log(`Content Guidelines:`);
+        console.log(`- Keep it atomic: one clear idea per post`);
+        console.log(`- Strong opener that hooks the reader`);
+        console.log(`- Clear takeaway at the end`);
+        console.log(`- Code examples should be minimal and illustrative`);
+        console.log();
+        console.log(`Personal Branding Guidelines:`);
+        console.log(`- Position as expertise/insight, not company promotion`);
+        console.log(`- Lead with the principle, not the project`);
+        console.log(`- Show earned expertise: "I built this and here's what I learned"`);
+        console.log(`- End with a clear, shareable takeaway`);
+        console.log(`- Avoid: humble brags, buzzwords, vague claims`);
+        console.log();
+        console.log(`After transforming, update the note file (set tone: ${tone}, structure: ${structure} in frontmatter) and run:`);
+        console.log(`  openclaw notes refine ${slug}`);
+      });
+
+    // ── adapt (platform adaptation) ────────────────────────────────
+    notes
+      .command("adapt <slug>")
+      .option("--platform <platform>", "target platform: linkedin | twitter | thread | reddit", "linkedin")
+      .option("--subreddit <subreddit>", "target subreddit for reddit (e.g. r/SaaS)", "r/startups")
+      .action((slug: string, options: any) => {
+        const cfg = resolveConfig(api);
+        const file = path.join(cfg.notesDir, `${slug}.md`);
+        if (!fs.existsSync(file)) { console.log(`Note not found: ${slug}.md`); return; }
+        const full = fs.readFileSync(file, "utf8");
+        const { meta, body } = parseFrontMatter(full);
+        const title = meta.title || slug;
+        const wordCount = body.split(/\s+/).filter((w: string) => w.length > 0).length;
+        const platform = (options.platform || "linkedin").toLowerCase();
+        const styleProfile = loadStyleProfile(cfg.notesDir);
+
+        // Load named persona if tone references one
+        let namedPersona: any = null;
+        if (meta.tone && meta.tone !== "authentic" && meta.tone !== "professional" && meta.tone !== "casual" && meta.tone !== "humorous") {
+          const personaPath = path.join(cfg.notesDir, ".style-profiles", `${meta.tone}.json`);
+          if (fs.existsSync(personaPath)) {
+            try { namedPersona = JSON.parse(fs.readFileSync(personaPath, "utf8")); } catch {}
+          }
+        }
+
+        const platformSpecs: Record<string, {
+          name: string;
+          maxChars: number;
+          format: string;
+          conventions: string[];
+          structure: string;
+          example: string;
+        }> = {
+          linkedin: {
+            name: "LinkedIn",
+            maxChars: 3000,
+            format: "post",
+            conventions: [
+              "Hook in the first 2 lines (before 'see more' fold)",
+              "Short paragraphs (1-2 sentences each) with line breaks between",
+              "Use line breaks generously — walls of text get scrolled past",
+              "No markdown formatting — LinkedIn doesn't render it",
+              "Bold-like emphasis: use CAPS sparingly or ↳ arrows for sub-points",
+              "End with a question or call-to-action to drive comments",
+              "No hashtags in the body — add 3-5 relevant ones at the very end",
+              "No links in the body (kills reach) — put link in first comment instead",
+              "Mention 'link in comments' if referencing external content",
+            ],
+            structure: "Hook (1-2 lines) → Context (2-3 short ¶) → Core insight (2-3 short ¶) → Takeaway or question → Hashtags",
+            example: "Most equity conversations go sideways.\n\nNot because people are greedy.\nBecause they're using different frameworks.\n\nThe founder sees dilution.\nThe operator sees contribution.\nNeither is wrong — they're having two different conversations.\n\n↳ Argue capital, not time\n↳ Reframe dilution as value creation\n↳ Bundle everything into one deal\n↳ Name your number first\n\nThe frame matters more than the math.\n\nWhat's the hardest negotiation you've navigated?\n\n#equity #startups #negotiation #founders #leadership",
+          },
+          twitter: {
+            name: "Twitter/X",
+            maxChars: 280,
+            format: "single tweet",
+            conventions: [
+              "Maximum 280 characters — every word must earn its place",
+              "No hashtags unless absolutely essential (max 1-2)",
+              "Strong opinion or surprising take as the hook",
+              "No links (kills reach) — save for reply",
+              "Use numbers and specifics for credibility",
+              "End with a punchy line, not a question",
+              "No emojis unless they add meaning",
+              "Write like you'd text a smart friend",
+            ],
+            structure: "Hook/take → Supporting evidence or example → Punchline",
+            example: "Most equity talks fail because the operator argues time and the founder argues dilution.\n\nArgue capital instead. Money you invested, revenue you enabled, risk you absorbed.\n\nThe person with the better spreadsheet wins.",
+          },
+          thread: {
+            name: "Twitter/X Thread",
+            maxChars: 280,
+            format: "numbered thread (each tweet ≤280 chars)",
+            conventions: [
+              "First tweet must hook — it carries the thread",
+              "Number each tweet: 1/, 2/, 3/ etc.",
+              "Each tweet should be self-contained AND flow into the next",
+              "5-10 tweets is the sweet spot (more = drop-off)",
+              "Last tweet: recap + CTA (follow, retweet, link in reply)",
+              "No tweet should feel like filler",
+              "Use line breaks within tweets for readability",
+              "Keep transitions minimal — 'Here's the thing:', 'But:', 'The fix:'",
+            ],
+            structure: "1/ Hook → 2-8/ One point per tweet → Final/ Recap + CTA",
+            example: "1/ Most equity conversations between founders and operators go sideways.\n\nHere's a framework that actually works:\n\n2/ Stop arguing time.\n\n\"I've been here 18 months\" doesn't move a founder who's been at it for years.\n\n3/ Argue capital instead.\n\nMoney you invested > Revenue you enabled > Risk you absorbed > Time spent\n\nStart from the top.\n\n4/ Reframe dilution as value creation.\n\n\"What's the company worth WITH what I built vs WITHOUT it?\"\n\nDon't fight their spreadsheet. Build a better one.\n\n5/ Bundle everything.\n\nThe moment you agree to \"close the easy parts first\" — you've lost your leverage.\n\n6/ The frame matters more than the math.\n\nSame contribution, different perception = completely different offer.\n\nYour job isn't to argue percentages. It's to control the frame.",
+          },
+        };
+
+        const spec = platformSpecs[platform];
+        if (!spec && platform !== "reddit") {
+          console.log(`Unknown platform: ${platform}`);
+          console.log(`Available: ${Object.keys(platformSpecs).join(", ")}, reddit`);
+          return;
+        }
+
+        // Save adaptation to .variations/<slug>/
+        const varsPath = path.join(cfg.notesDir, ".variations", slug);
+        fs.mkdirSync(varsPath, { recursive: true });
+
+        // ── Reddit-specific adaptation ──────────────────────────────
+        if (platform === "reddit") {
+          const subreddit = (options.subreddit || "r/startups").replace(/^(?!r\/)/, "r/");
+          const subGuideline = SUBREDDIT_GUIDELINES[subreddit] || DEFAULT_SUBREDDIT_GUIDELINE;
+          const knownSubs = KNOWN_SUBREDDITS;
+          const redditFile = `reddit-${subreddit.replace(/^r\//, "")}.md`;
+
+          console.log(`📱 Adapt for Reddit (${subreddit}): "${title}"`);
+          console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+          console.log(`Platform:   Reddit (${subreddit})`);
+          console.log(`Format:     text post with Title, Body, TL;DR`);
+          console.log(`Source:     ${wordCount} words\n`);
+
+          console.log(`Original blog post:`);
+          console.log(body);
+          console.log();
+          console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+          console.log(`Adapt this blog post into a Reddit text post for ${subreddit}.\n`);
+
+          console.log(`📋 SUBREDDIT GUIDELINES for ${subreddit}:`);
+          console.log(`   ${subGuideline}`);
+          if (!SUBREDDIT_GUIDELINES[subreddit]) {
+            console.log(`   (No specific guidelines found — using defaults. Known subreddits: ${knownSubs.join(", ")})`);
+          }
+          console.log();
+
+          console.log(`🚫 CRITICAL ANTI-PROMOTION RULES — violating these gets the post removed or downvoted:`);
+          console.log(`   • NEVER include a URL or link anywhere in the post`);
+          console.log(`   • NEVER include a call-to-action ("check out", "try", "sign up", "visit")`);
+          console.log(`   • Mention the product/company at most ONCE, as brief context ("I run a small SaaS for X"), never as a pitch`);
+          console.log(`   • The post MUST provide standalone value — if you removed the product mention entirely, the post should still be worth reading`);
+          console.log(`   • Write as a person sharing an experience, NOT a company making an announcement`);
+          console.log(`   • Use "I" not "we" — personal stories perform better on Reddit`);
+          console.log(`   • No marketing language: "excited to announce", "game-changer", "revolutionary", "check this out"`);
+          console.log();
+
+          console.log(`📐 STRUCTURE:`);
+          console.log(`   Title → Body (300-800 words) → TL;DR (1-2 sentences)`);
+          console.log();
+
+          console.log(`📝 TITLE RULES:`);
+          console.log(`   • Conversational, first-person ("I learned X" not "Why X Matters")`);
+          console.log(`   • No emojis in title`);
+          console.log(`   • Curiosity or relatability hook`);
+          console.log(`   • Under 150 characters`);
+          console.log();
+
+          console.log(`📝 BODY RULES:`);
+          console.log(`   • 300-800 words`);
+          console.log(`   • Short paragraphs (2-3 sentences max)`);
+          console.log(`   • Story-first: open with the experience, not the lesson`);
+          console.log(`   • Bold (**) for 2-3 key phrases only`);
+          console.log(`   • No headers (Reddit text posts look weird with markdown headers)`);
+          console.log(`   • TL;DR at the very end (1-2 sentences)`);
+          console.log();
+
+          // Style voice injection
+          if (namedPersona) {
+            console.log(`🎭 VOICE (${namedPersona.name}):`);
+            console.log(`   ${namedPersona.voiceDescription}`);
+            if (namedPersona.avoid?.length) console.log(`   Avoid: ${namedPersona.avoid.slice(0, 5).join(", ")}`);
+            console.log();
+          } else if (styleProfile?.voiceDescription) {
+            console.log(`🎨 VOICE (your style profile):`);
+            console.log(`   ${styleProfile.voiceDescription}`);
+            console.log();
+          }
+
+          console.log(`Output Instructions:`);
+          console.log(`- Distill the core insight — don't try to compress the whole post`);
+          console.log(`- Match Reddit's native feel — it should read like a genuine ${subreddit} post, not a repurposed blog`);
+          console.log(`- Preserve the author's voice and perspective`);
+          console.log(`- The input may mention a specific product. Genericize it to "my SaaS" or "my startup" or "a tool I built" — never use the product name`);
+          console.log();
+          console.log(`After adapting, save the result to: ${varsPath}/${redditFile}`);
+          console.log(`Format the file with clear sections:`);
+          console.log(`  # Title`);
+          console.log(`  <the post title>`);
+          console.log();
+          console.log(`  # Body`);
+          console.log(`  <the post body in Reddit markdown>`);
+          console.log();
+          console.log(`  # TL;DR`);
+          console.log(`  <1-2 sentence summary>`);
+
+          return;
+        }
+
+        // ── Standard platform adaptation (linkedin, twitter, thread) ─
+        console.log(`📱 Adapt for ${spec.name}: "${title}"`);
+        console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+        console.log(`Platform:   ${spec.name} (${spec.format})`);
+        console.log(`Max chars:  ${spec.maxChars}`);
+        console.log(`Source:     ${wordCount} words\n`);
+
+        console.log(`Original blog post:`);
+        console.log(body);
+        console.log();
+        console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+        console.log(`Adapt this blog post into a ${spec.name} ${spec.format}.\n`);
+
+        console.log(`📋 PLATFORM RULES for ${spec.name}:`);
+        for (const c of spec.conventions) console.log(`   • ${c}`);
+        console.log();
+
+        console.log(`📐 STRUCTURE: ${spec.structure}`);
+        console.log();
+
+        console.log(`📝 EXAMPLE of good ${spec.name} ${spec.format} on similar topic:`);
+        console.log(`   ${spec.example.split("\n").join("\n   ")}`);
+        console.log();
+
+        if (spec.maxChars <= 280) {
+          console.log(`⚠️  CHARACTER LIMIT: ${spec.maxChars} chars. Count carefully. Every word must earn its place.`);
+          console.log();
+        }
+
+        // Style voice injection
+        if (namedPersona) {
+          console.log(`🎭 VOICE (${namedPersona.name}):`);
+          console.log(`   ${namedPersona.voiceDescription}`);
+          if (namedPersona.avoid?.length) console.log(`   Avoid: ${namedPersona.avoid.slice(0, 5).join(", ")}`);
+          console.log();
+        } else if (styleProfile?.voiceDescription) {
+          console.log(`🎨 VOICE (your style profile):`);
+          console.log(`   ${styleProfile.voiceDescription}`);
+          console.log();
+        }
+
+        console.log(`Output Instructions:`);
+        console.log(`- Distill the core insight — don't try to compress the whole post`);
+        console.log(`- Match the platform's native feel — it should look like it was written for ${spec.name}, not copy-pasted from a blog`);
+        console.log(`- Preserve the author's voice and perspective`);
+        if (platform === "thread") {
+          console.log(`- Output each tweet on its own line, prefixed with the number (1/, 2/, etc.)`);
+          console.log(`- Separate tweets with a blank line`);
+        }
+        console.log();
+        console.log(`After adapting, save the result to: ${varsPath}/${platform}.md`);
+        console.log(`Format: plain text (no markdown), ready to copy-paste into ${spec.name}.`);
+      });
+
+    // ── tweet (post twitter adaptation to X) ─────────────────────
+    notes
+      .command("tweet <slug>")
+      .option("--dry-run", "preview only, don't post")
+      .option("--yes", "skip confirmation")
+      .action(async (slug: string, options: any) => {
+        const cfg = resolveConfig(api);
+        const twitterPath = path.join(cfg.notesDir, ".variations", slug, "twitter.md");
+        if (!fs.existsSync(twitterPath)) {
+          console.log(`No twitter adaptation found for "${slug}".`);
+          console.log(`Run: openclaw notes adapt ${slug} --platform twitter`);
+          return;
+        }
+        const tweetText = fs.readFileSync(twitterPath, "utf8").trim();
+        if (tweetText.length > 280) {
+          console.log(`⚠️  Tweet is ${tweetText.length} chars (max 280). Edit ${twitterPath} to shorten.`);
+          return;
+        }
+
+        console.log(`\n🐦 Tweet preview (${tweetText.length}/280 chars):\n`);
+        console.log(`  ${tweetText}\n`);
+
+        if (options.dryRun) {
+          console.log("(dry run — not posting)");
+          return;
+        }
+
+        if (!options.yes) {
+          const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+          const answer = await rl.question("Post to @pressclawai? (y/n) ");
+          rl.close();
+          if (answer.toLowerCase() !== "y") { console.log("Cancelled."); return; }
+        }
+
+        try {
+          const result = await postTweet(tweetText);
+          console.log(`✅ Posted! https://x.com/pressclawai/status/${result.id}`);
+
+          // Save tweet record to feedback file
+          let fb = loadFeedback(cfg.notesDir, slug);
+          if (!fb) { fb = { slug, entries: [], tweets: [], aggregate: { avgScore: 0, totalViews: 0, totalLikes: 0, totalShares: 0, totalComments: 0, entries: 0 } }; }
+          if (!fb.tweets) fb.tweets = [];
+          fb.tweets.push({ id: result.id, text: result.text, postedAt: new Date().toISOString(), platform: "twitter" });
+          saveFeedback(cfg.notesDir, fb);
+          console.log(`📎 Tweet ID saved to .feedback/${slug}.json`);
+        } catch (err: any) {
+          console.log(`❌ Failed to post: ${err.message}`);
+        }
+      });
+
+    // ── engagement (fetch tweet metrics) ────────────────────────────
+    notes
+      .command("engagement [slug]")
+      .action(async (slug?: string) => {
+        const cfg = resolveConfig(api);
+        const feedbackFiles: FeedbackFile[] = [];
+        if (slug) {
+          const fb = loadFeedback(cfg.notesDir, slug);
+          if (!fb) { console.log(`No feedback file for ${slug}`); return; }
+          feedbackFiles.push(fb);
+        } else {
+          feedbackFiles.push(...loadAllFeedback(cfg.notesDir));
+        }
+
+        const tweetIdMap: Map<string, FeedbackFile> = new Map();
+        for (const fb of feedbackFiles) {
+          if (fb.tweets?.length) {
+            for (const t of fb.tweets) {
+              tweetIdMap.set(t.id, fb);
+            }
+          }
+        }
+
+        if (tweetIdMap.size === 0) {
+          console.log("No tweets found in feedback files.");
+          return;
+        }
+
+        console.log(`Fetching metrics for ${tweetIdMap.size} tweet(s)…`);
+        let results: { id: string; metrics: { views: number; likes: number; shares: number; comments: number } }[];
+        try {
+          results = await fetchTweetMetrics([...tweetIdMap.keys()]);
+        } catch (err: any) {
+          console.log(`❌ Failed to fetch metrics: ${err.message}`);
+          return;
+        }
+
+        const updatedSlugs = new Set<string>();
+        const rows: { slug: string; views: number; likes: number; shares: number; comments: number }[] = [];
+
+        for (const r of results) {
+          const fb = tweetIdMap.get(r.id);
+          if (!fb) continue;
+
+          const score = r.metrics.likes > 100 ? 9 : r.metrics.likes > 50 ? 8 : r.metrics.likes > 10 ? 7 : r.metrics.likes > 5 ? 6 : 5;
+          const existing = fb.entries.find((e) => e.platform === "twitter" && e.note?.includes(r.id));
+          if (existing) {
+            existing.metrics = r.metrics;
+            existing.score = score;
+            existing.date = new Date().toISOString().slice(0, 10);
+          } else {
+            fb.entries.push({
+              date: new Date().toISOString().slice(0, 10),
+              score,
+              metrics: r.metrics,
+              platform: "twitter",
+              note: `Auto-tracked engagement for tweet ${r.id}`,
+            });
+          }
+          fb.aggregate = recalcAggregate(fb.entries);
+          updatedSlugs.add(fb.slug);
+
+          const prev = rows.find((row) => row.slug === fb.slug);
+          if (prev) {
+            prev.views += r.metrics.views;
+            prev.likes += r.metrics.likes;
+            prev.shares += r.metrics.shares;
+            prev.comments += r.metrics.comments;
+          } else {
+            rows.push({ slug: fb.slug, ...r.metrics });
+          }
+        }
+
+        for (const fb of feedbackFiles) {
+          if (updatedSlugs.has(fb.slug)) {
+            saveFeedback(cfg.notesDir, fb);
+          }
+        }
+
+        console.log("\n📊 Engagement Update\n");
+        const pad = (s: string, n: number) => s + " ".repeat(Math.max(0, n - s.length));
+        console.log(`  ${pad("slug", 30)} ${pad("views", 8)} ${pad("likes", 8)} ${pad("RTs", 8)} replies`);
+        for (const row of rows) {
+          console.log(`  ${pad(row.slug, 30)} ${pad(String(row.views), 8)} ${pad(String(row.likes), 8)} ${pad(String(row.shares), 8)} ${row.comments}`);
+        }
+        console.log(`\n  Updated ${updatedSlugs.size} feedback file(s).`);
+      });
+
+    // ── schedule (scheduled posting) ─────────────────────────────
+    const schedule = notes.command("schedule");
+
+    // `openclaw notes schedule add <slug>` — schedule a post
+    schedule
+      .command("add <slug>")
+      .option("--at <datetime>", "ISO datetime or human-readable time to post")
+      .option("--platform <platform>", "platform to post to", "twitter")
+      .action(async (slug: string, options: any) => {
+        const cfg = resolveConfig(api);
+
+        const platform = options.platform as "twitter" | "linkedin";
+        if (platform !== "twitter" && platform !== "linkedin") {
+          console.log(`❌ Unsupported platform "${platform}". Use: twitter, linkedin`);
+          return;
+        }
+
+        // Validate datetime
+        if (!options.at) {
+          console.log("❌ Missing --at <datetime>. Example: --at '2026-02-08T14:00:00Z'");
+          return;
+        }
+
+        const scheduledAt = new Date(options.at);
+        if (isNaN(scheduledAt.getTime())) {
+          console.log(`❌ Invalid datetime: "${options.at}". Use ISO format, e.g. 2026-02-08T14:00:00Z`);
+          return;
+        }
+
+        if (scheduledAt.getTime() <= Date.now()) {
+          console.log(`❌ Scheduled time must be in the future. Got: ${scheduledAt.toISOString()}`);
+          return;
+        }
+
+        // Validate adaptation exists
+        const platformFile = platform === "twitter" ? "twitter.md" : "linkedin.md";
+        const adaptPath = path.join(cfg.notesDir, ".variations", slug, platformFile);
+        if (!fs.existsSync(adaptPath)) {
+          console.log(`❌ No ${platform} adaptation found for "${slug}".`);
+          console.log(`Run: openclaw notes adapt ${slug} --platform ${platform}`);
+          return;
+        }
+
+        const text = fs.readFileSync(adaptPath, "utf8").trim();
+
+        // Validate length
+        if (platform === "twitter" && text.length > 280) {
+          console.log(`⚠️  Tweet is ${text.length} chars (max 280). Edit ${adaptPath} to shorten.`);
+          return;
+        }
+
+        // Check for duplicate queued entry
+        const queue = loadQueue(cfg.notesDir);
+        const existing = queue.find(
+          (e) => e.slug === slug && e.platform === platform && e.status === "queued"
+        );
+        if (existing) {
+          console.log(`⚠️  "${slug}" is already queued for ${platform} at ${existing.scheduledAt}.`);
+          console.log(`Cancel it first with: openclaw notes schedule cancel ${slug}`);
+          return;
+        }
+
+        const entry: ScheduleEntry = {
+          slug,
+          platform,
+          scheduledAt: scheduledAt.toISOString(),
+          text,
+          status: "queued",
+          createdAt: new Date().toISOString(),
+        };
+
+        queue.push(entry);
+        saveQueue(cfg.notesDir, queue);
+
+        console.log(`\n📅 Scheduled "${slug}" for ${platform}`);
+        console.log(`   Time: ${scheduledAt.toISOString()}`);
+        console.log(`   Text: ${text.length <= 80 ? text : text.slice(0, 77) + "..."}`);
+        console.log(`   Length: ${text.length} chars`);
+        console.log(`\nRun \`openclaw notes schedule process\` at the scheduled time to post.`);
+      });
+
+    // `openclaw notes schedule list` — list all scheduled entries
+    schedule
+      .command("list")
+      .alias("ls")
+      .action(() => {
+        const cfg = resolveConfig(api);
+        const queue = loadQueue(cfg.notesDir);
+
+        if (queue.length === 0) {
+          console.log("📭 No scheduled posts.");
+          return;
+        }
+
+        const statusOrder: Record<string, number> = { queued: 0, posted: 1, failed: 2, cancelled: 3 };
+        const sorted = [...queue].sort(
+          (a, b) => (statusOrder[a.status] ?? 4) - (statusOrder[b.status] ?? 4)
+        );
+
+        const statusIcon: Record<string, string> = {
+          queued: "🟡",
+          posted: "🟢",
+          failed: "🔴",
+          cancelled: "⚪",
+        };
+
+        console.log(`\n📅 Scheduled Posts (${queue.length} total)\n`);
+
+        let lastStatus = "";
+        for (const entry of sorted) {
+          if (entry.status !== lastStatus) {
+            if (lastStatus) console.log("");
+            console.log(`  ${statusIcon[entry.status] || "⚪"} ${entry.status.toUpperCase()}`);
+            lastStatus = entry.status;
+          }
+          const time = new Date(entry.scheduledAt).toLocaleString();
+          const preview = entry.text.length <= 50 ? entry.text : entry.text.slice(0, 47) + "...";
+          console.log(`    ${entry.slug} (${entry.platform}) — ${time}`);
+          console.log(`      "${preview}"`);
+          if (entry.tweetId) {
+            console.log(`      → https://x.com/pressclawai/status/${entry.tweetId}`);
+          }
+          if (entry.error) {
+            console.log(`      ✗ ${entry.error}`);
+          }
+        }
+        console.log("");
+      });
+
+    // `openclaw notes schedule cancel <slug>` — cancel a queued entry
+    schedule
+      .command("cancel <slug>")
+      .option("--platform <platform>", "platform to cancel", "twitter")
+      .action((slug: string, options: any) => {
+        const cfg = resolveConfig(api);
+        const queue = loadQueue(cfg.notesDir);
+        const platform = options.platform || "twitter";
+
+        const idx = queue.findIndex(
+          (e) => e.slug === slug && e.platform === platform && e.status === "queued"
+        );
+
+        if (idx === -1) {
+          console.log(`❌ No queued entry found for "${slug}" on ${platform}.`);
+          return;
+        }
+
+        queue[idx].status = "cancelled";
+        saveQueue(cfg.notesDir, queue);
+
+        console.log(`✅ Cancelled scheduled post for "${slug}" (${platform}).`);
+        console.log(`   Was scheduled for: ${queue[idx].scheduledAt}`);
+      });
+
+    // `openclaw notes schedule process` — post all due entries
+    schedule
+      .command("process")
+      .action(async () => {
+        const cfg = resolveConfig(api);
+        const queue = loadQueue(cfg.notesDir);
+        const now = Date.now();
+
+        const due = queue.filter(
+          (e) => e.status === "queued" && new Date(e.scheduledAt).getTime() <= now
+        );
+
+        if (due.length === 0) {
+          // Show next upcoming if any
+          const nextQueued = queue
+            .filter((e) => e.status === "queued")
+            .sort((a, b) => new Date(a.scheduledAt).getTime() - new Date(b.scheduledAt).getTime());
+          if (nextQueued.length > 0) {
+            const next = nextQueued[0];
+            const diff = new Date(next.scheduledAt).getTime() - now;
+            const mins = Math.ceil(diff / 60000);
+            console.log(`⏳ No posts due yet. Next: "${next.slug}" in ${mins} minute(s) (${next.scheduledAt}).`);
+          } else {
+            console.log("📭 No queued posts to process.");
+          }
+          return;
+        }
+
+        console.log(`\n📤 Processing ${due.length} scheduled post(s)...\n`);
+
+        let posted = 0;
+        let failed = 0;
+
+        for (const entry of due) {
+          process.stdout.write(`  ${entry.slug} (${entry.platform})... `);
+
+          if (entry.platform === "twitter") {
+            try {
+              const result = await postTweet(entry.text);
+              entry.status = "posted";
+              entry.tweetId = result.id;
+
+              // Save to feedback file (same pattern as tweet command)
+              let fb = loadFeedback(cfg.notesDir, entry.slug);
+              if (!fb) {
+                fb = {
+                  slug: entry.slug,
+                  entries: [],
+                  tweets: [],
+                  aggregate: { avgScore: 0, totalViews: 0, totalLikes: 0, totalShares: 0, totalComments: 0, entries: 0 },
+                };
+              }
+              if (!fb.tweets) fb.tweets = [];
+              fb.tweets.push({
+                id: result.id,
+                text: result.text,
+                postedAt: new Date().toISOString(),
+                platform: "twitter",
+              });
+              saveFeedback(cfg.notesDir, fb);
+
+              console.log(`✅ Posted! https://x.com/pressclawai/status/${result.id}`);
+              posted++;
+            } catch (err: any) {
+              entry.status = "failed";
+              entry.error = err.message || String(err);
+              console.log(`❌ Failed: ${entry.error}`);
+              failed++;
+            }
+          } else if (entry.platform === "linkedin") {
+            try {
+              const result = await postLinkedIn(entry.text);
+              entry.status = "posted";
+              entry.tweetId = result.id;
+
+              let fb = loadFeedback(cfg.notesDir, entry.slug);
+              if (!fb) {
+                fb = {
+                  slug: entry.slug,
+                  entries: [],
+                  tweets: [],
+                  aggregate: { avgScore: 0, totalViews: 0, totalLikes: 0, totalShares: 0, totalComments: 0, entries: 0 },
+                };
+              }
+              if (!fb.tweets) fb.tweets = [];
+              fb.tweets.push({
+                id: result.id,
+                text: entry.text.slice(0, 200) + (entry.text.length > 200 ? "…" : ""),
+                postedAt: new Date().toISOString(),
+                platform: "linkedin",
+              });
+              saveFeedback(cfg.notesDir, fb);
+
+              console.log(`✅ Posted to LinkedIn! ${result.id}`);
+              posted++;
+            } catch (err: any) {
+              entry.status = "failed";
+              entry.error = err.message || String(err);
+              console.log(`❌ Failed: ${entry.error}`);
+              failed++;
+            }
+          } else {
+            entry.status = "failed";
+            entry.error = `Unsupported platform: ${entry.platform}`;
+            console.log(`❌ ${entry.error}`);
+            failed++;
+          }
+        }
+
+        saveQueue(cfg.notesDir, queue);
+
+        console.log(`\n📊 Results: ${posted} posted, ${failed} failed`);
+        if (posted > 0) {
+          console.log(`📎 Post IDs saved to .feedback/ files.`);
+        }
+      });
+
+    // `openclaw notes schedule` (no subcommand) — default to list
+    schedule.action(() => {
+      schedule.commands.find((c: any) => c.name() === "list")?.parse(["list"], { from: "user" });
+    });
+
+    // ── linkedin (post linkedin adaptation) ──────────────────────
+    notes
+      .command("linkedin <slug>")
+      .option("--dry-run", "preview only, don't post")
+      .option("--yes", "skip confirmation")
+      .action(async (slug: string, options: any) => {
+        const cfg = resolveConfig(api);
+        const linkedinPath = path.join(cfg.notesDir, ".variations", slug, "linkedin.md");
+        if (!fs.existsSync(linkedinPath)) {
+          console.log(`No LinkedIn adaptation found for "${slug}".`);
+          console.log(`Run: openclaw notes adapt ${slug} --platform linkedin`);
+          return;
+        }
+        const postText = fs.readFileSync(linkedinPath, "utf8").trim();
+        if (postText.length > 3000) {
+          console.log(`⚠️  Post is ${postText.length} chars (LinkedIn max ~3000). Edit ${linkedinPath} to shorten.`);
+          return;
+        }
+
+        console.log(`\n💼 LinkedIn post preview (${postText.length}/3000 chars):\n`);
+        console.log(`  ${postText.split("\n").join("\n  ")}\n`);
+
+        if (options.dryRun) {
+          console.log("(dry run — not posting)");
+          return;
+        }
+
+        if (!options.yes) {
+          const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+          const answer = await rl.question("Post to LinkedIn? (y/n) ");
+          rl.close();
+          if (answer.toLowerCase() !== "y") { console.log("Cancelled."); return; }
+        }
+
+        try {
+          const result = await postLinkedIn(postText);
+          console.log(`✅ Posted to LinkedIn!`);
+          if (result.id) {
+            const numericId = result.id.split(":").pop();
+            console.log(`   Post URN: ${result.id}`);
+            console.log(`   View: https://www.linkedin.com/feed/update/${result.id}`);
+          }
+
+          // Save post record to feedback file
+          let fb = loadFeedback(cfg.notesDir, slug);
+          if (!fb) {
+            fb = {
+              slug,
+              entries: [],
+              tweets: [],
+              aggregate: { avgScore: 0, totalViews: 0, totalLikes: 0, totalShares: 0, totalComments: 0, entries: 0 },
+            };
+          }
+          if (!fb.tweets) fb.tweets = [];
+          fb.tweets.push({
+            id: result.id,
+            text: postText.slice(0, 200) + (postText.length > 200 ? "…" : ""),
+            postedAt: new Date().toISOString(),
+            platform: "linkedin",
+          });
+          saveFeedback(cfg.notesDir, fb);
+          console.log(`📎 LinkedIn post ID saved to .feedback/${slug}.json`);
+        } catch (err: any) {
+          console.log(`❌ Failed to post: ${err.message}`);
+        }
+      });
+
+    // ── linkedin-auth (setup LinkedIn OAuth) ─────────────────────
+    notes
+      .command("linkedin-auth")
+      .action(async () => {
+        console.log(`\n🔗 LinkedIn API Setup`);
+        console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+        console.log();
+        console.log(`Step 1: Create a LinkedIn App`);
+        console.log(`   → Go to https://www.linkedin.com/developers/apps`);
+        console.log(`   → Click "Create app"`);
+        console.log(`   → Fill in: App name, LinkedIn Page (or create one), logo`);
+        console.log(`   → Accept the terms and create`);
+        console.log();
+        console.log(`Step 2: Configure OAuth`);
+        console.log(`   → In your app settings, go to the "Auth" tab`);
+        console.log(`   → Note your Client ID and Client Secret`);
+        console.log(`   → Under "OAuth 2.0 settings", add a redirect URL:`);
+        console.log(`     https://localhost:3000/callback (or any URL you control)`);
+        console.log();
+        console.log(`Step 3: Request the w_member_social product`);
+        console.log(`   → Go to the "Products" tab in your LinkedIn app`);
+        console.log(`   → Request access to "Share on LinkedIn" (grants w_member_social)`);
+        console.log(`   → Wait for approval (usually instant for personal apps)`);
+        console.log();
+        console.log(`Step 4: Get an authorization code`);
+        console.log(`   → Visit this URL in your browser (replace YOUR_CLIENT_ID and YOUR_REDIRECT_URI):\n`);
+        console.log(`     https://www.linkedin.com/oauth/v2/authorization?response_type=code&client_id=YOUR_CLIENT_ID&redirect_uri=YOUR_REDIRECT_URI&scope=openid%20profile%20w_member_social\n`);
+        console.log(`   → Log in and authorize the app`);
+        console.log(`   → You'll be redirected to your redirect URL with ?code=XXXXX in the URL`);
+        console.log(`   → Copy the code value`);
+        console.log();
+        console.log(`Step 5: Enter your credentials below to exchange for an access token\n`);
+
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+        try {
+          const clientId = await rl.question("LinkedIn Client ID: ");
+          if (!clientId.trim()) { console.log("Cancelled."); rl.close(); return; }
+
+          const clientSecret = await rl.question("LinkedIn Client Secret: ");
+          if (!clientSecret.trim()) { console.log("Cancelled."); rl.close(); return; }
+
+          const redirectUri = await rl.question("Redirect URI (same as in your app settings): ");
+          if (!redirectUri.trim()) { console.log("Cancelled."); rl.close(); return; }
+
+          const code = await rl.question("Authorization code (from the redirect URL): ");
+          if (!code.trim()) { console.log("Cancelled."); rl.close(); return; }
+
+          rl.close();
+
+          console.log(`\n⏳ Exchanging authorization code for access token...`);
+
+          const tokenResult = await exchangeLinkedInAuthCode(
+            clientId.trim(),
+            clientSecret.trim(),
+            code.trim(),
+            redirectUri.trim()
+          );
+
+          console.log(`✅ Access token obtained! (expires in ${Math.round(tokenResult.expires_in / 86400)} days)`);
+          console.log(`   Scopes: ${tokenResult.scope}`);
+
+          // Fetch person URN
+          console.log(`\n⏳ Fetching your LinkedIn profile...`);
+          let personUrn: string;
+          try {
+            personUrn = await fetchLinkedInPersonUrn(tokenResult.access_token);
+            console.log(`✅ Person URN: ${personUrn}`);
+          } catch (err: any) {
+            console.log(`⚠️  Could not auto-detect Person URN: ${err.message}`);
+            const manualUrn = await (readline.createInterface({ input: process.stdin, output: process.stdout }))
+              .question("Enter your Person URN manually (urn:li:person:XXXX): ");
+            personUrn = manualUrn.trim();
+            if (!personUrn) {
+              console.log("No Person URN provided. You'll need to set LINKEDIN_PERSON_URN manually.");
+              personUrn = "";
+            }
+          }
+
+          // Save to /etc/openclaw/linkedin.env
+          const envDir = "/etc/openclaw";
+          const envPath = path.join(envDir, "linkedin.env");
+          fs.mkdirSync(envDir, { recursive: true });
+
+          const envContent = [
+            `# LinkedIn OAuth credentials for PressClaw`,
+            `# Generated: ${new Date().toISOString()}`,
+            `# Token expires in ~${Math.round(tokenResult.expires_in / 86400)} days`,
+            `LINKEDIN_ACCESS_TOKEN=${tokenResult.access_token}`,
+            personUrn ? `LINKEDIN_PERSON_URN=${personUrn}` : `# LINKEDIN_PERSON_URN=urn:li:person:YOUR_ID`,
+            `LINKEDIN_CLIENT_ID=${clientId.trim()}`,
+            `LINKEDIN_CLIENT_SECRET=${clientSecret.trim()}`,
+            `LINKEDIN_REDIRECT_URI=${redirectUri.trim()}`,
+            ``,
+          ].join("\n");
+
+          fs.writeFileSync(envPath, envContent, { mode: 0o600 });
+          console.log(`\n💾 Credentials saved to ${envPath}`);
+          console.log();
+          console.log(`To load these in your OpenClaw environment, add to your gateway config:`);
+          console.log(`   envFile: ${envPath}`);
+          console.log();
+          console.log(`Or source it manually:`);
+          console.log(`   source ${envPath}`);
+          console.log();
+          console.log(`You can now post to LinkedIn:`);
+          console.log(`   openclaw notes adapt <slug> --platform linkedin`);
+          console.log(`   openclaw notes linkedin <slug>`);
+        } catch (err: any) {
+          rl.close();
+          console.log(`\n❌ Error: ${err.message}`);
+        }
+      });
+
+    // ── personas (subcommand group) ────────────────────────────────
+    const personasCmd = notes.command("personas").description("Manage writing personas");
+
+    // ── personas (list installed) ──────────────────────────────────
+    personasCmd.action(() => {
+      const cfg = resolveConfig(api);
+      const personas = loadInstalledPersonas(cfg.notesDir);
+
+      if (personas.length === 0) {
+        console.log("\n🎭 No personas installed yet.");
+        console.log("   Browse available:  openclaw notes personas browse");
+        console.log("   Create your own:   openclaw notes personas create");
+        return;
+      }
+
+      console.log(`\n🎭 Installed Personas (${personas.length})`);
+      console.log(`${"━".repeat(72)}`);
+      console.log(`  ${"Name".padEnd(20)} ${"Description".padEnd(32)} ${"Tags".padEnd(24)} Ver`);
+      console.log(`  ${"─".repeat(20)} ${"─".repeat(32)} ${"─".repeat(24)} ${"─".repeat(4)}`);
+
+      for (const p of personas) {
+        const name = p.displayName.slice(0, 19).padEnd(20);
+        const desc = p.description.slice(0, 31).padEnd(32);
+        const tags = p.tags.slice(0, 3).join(", ").slice(0, 23).padEnd(24);
+        const ver = p.version || "—";
+        console.log(`  ${name} ${desc} ${tags} ${ver}`);
+      }
+
+      console.log(`\n  Browse more: openclaw notes personas browse`);
+      console.log(`  Use with:    openclaw notes transform <slug> --voice <persona-name>`);
+    });
+
+    // ── personas browse ────────────────────────────────────────────
+    personasCmd.command("browse").action(async () => {
+      const cfg = resolveConfig(api);
+      const installed = new Set(loadInstalledPersonas(cfg.notesDir).map((p) => p.name));
+
+      console.log("\n🌐 Persona Marketplace");
+      console.log(`${"━".repeat(56)}`);
+      console.log("   Fetching from pressclaw.com...\n");
+
+      try {
+        const index = await fetchJson("https://pressclaw.com/personas/index.json");
+
+        if (!index?.personas || !Array.isArray(index.personas)) {
+          console.log("   ⚠️  Invalid marketplace index format.");
+          return;
+        }
+
+        const available = index.personas.filter((p: any) => !installed.has(p.name));
+
+        if (available.length === 0 && index.personas.length > 0) {
+          console.log("   ✅ You already have all available personas installed!");
+          console.log(`   ${index.personas.length} persona(s) in marketplace, all installed locally.`);
+          return;
+        }
+
+        if (available.length === 0) {
+          console.log("   No personas available in the marketplace yet.");
+          return;
+        }
+
+        console.log(`   ${available.length} persona(s) available:\n`);
+        for (const p of available) {
+          const tags = p.tags?.length ? ` [${p.tags.join(", ")}]` : "";
+          console.log(`   🎭 ${p.displayName || p.name}  (${p.name})  v${p.version || "?"}`);
+          console.log(`      ${p.description || "No description"}${tags}`);
+          console.log();
+        }
+
+        if (installed.size > 0) {
+          console.log(`   Already installed: ${[...installed].join(", ")}`);
+          console.log();
+        }
+
+        console.log(`   Install: openclaw notes personas install <name>`);
+      } catch (err: any) {
+        console.log("   🌐 Marketplace is not available yet.");
+        console.log(`   (${err?.message || "Connection failed"})`);
+        console.log();
+        console.log("   You can still create personas locally:");
+        console.log("     openclaw notes personas create");
+      }
+    });
+
+    // ── personas install <name> ────────────────────────────────────
+    personasCmd.command("install <name>").action(async (name: string) => {
+      const cfg = resolveConfig(api);
+      ensurePersonasDir(cfg.notesDir);
+
+      const existing = loadInstalledPersona(cfg.notesDir, name);
+      if (existing) {
+        console.log(`\n⚠️  Persona "${existing.displayName}" (${name}) is already installed.`);
+        console.log(`   Version: ${existing.version}`);
+        return;
+      }
+
+      console.log(`\n📥 Installing persona: ${name}...`);
+
+      try {
+        const data = await fetchJson(`https://pressclaw.com/personas/${name}.json`);
+
+        if (!validatePersona(data)) {
+          console.log(`\n❌ Invalid persona format — missing required fields.`);
+          console.log(`   Required: name, displayName, description, version, author, style.tone, style.patterns, examples, tags`);
+          return;
+        }
+
+        const dest = path.join(personasDir(cfg.notesDir), `${name}.json`);
+        fs.writeFileSync(dest, JSON.stringify(data, null, 2) + "\n", "utf8");
+
+        console.log(`\n✅ Installed: ${data.displayName}`);
+        console.log(`   ${data.description}`);
+        console.log(`   Tone: ${data.style.tone} · ${data.style.patterns.length} patterns · ${data.examples.length} examples`);
+        console.log(`   Tags: ${data.tags.join(", ")}`);
+        console.log(`\n   Use: openclaw notes transform <slug> --voice ${name}`);
+      } catch (err: any) {
+        console.log(`\n❌ Failed to install persona "${name}".`);
+        console.log(`   ${err?.message || "Download failed"}`);
+        console.log(`\n   Check available personas: openclaw notes personas browse`);
+      }
+    });
+
+    // ── personas export <name> ─────────────────────────────────────
+    personasCmd.command("export <name>").action((name: string) => {
+      const cfg = resolveConfig(api);
+      const persona = loadInstalledPersona(cfg.notesDir, name);
+
+      if (!persona) {
+        console.log(`\n❌ Persona "${name}" not found locally.`);
+        console.log(`   Installed personas: openclaw notes personas`);
+        return;
+      }
+
+      console.log(JSON.stringify(persona, null, 2));
+    });
+
+    // ── personas create ────────────────────────────────────────────
+    personasCmd.command("create").action(async () => {
+      const cfg = resolveConfig(api);
+      ensurePersonasDir(cfg.notesDir);
+
+      if (!process.stdin.isTTY) {
+        console.log("❌ Interactive mode required. Run in a terminal.");
+        return;
+      }
+
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+      try {
+        console.log("\n🎭 Create a New Persona");
+        console.log(`${"━".repeat(40)}\n`);
+
+        const rawName = await rl.question("Name (slug, e.g. 'my-voice'): ");
+        const name = slugifyPersonaName(rawName);
+        if (!name) { console.log("❌ Invalid name."); rl.close(); return; }
+
+        // Check if already exists
+        if (loadInstalledPersona(cfg.notesDir, name)) {
+          console.log(`❌ Persona "${name}" already exists. Delete it first or choose another name.`);
+          rl.close();
+          return;
+        }
+
+        const displayName = await rl.question("Display name (e.g. 'Paul Graham'): ");
+        if (!displayName.trim()) { console.log("❌ Display name is required."); rl.close(); return; }
+
+        const description = await rl.question("Description (one line): ");
+        const tone = await rl.question("Tone (e.g. analytical, conversational, provocative): ");
+
+        console.log("\nEnter 3 writing patterns (one per line):");
+        const pattern1 = await rl.question("  Pattern 1: ");
+        const pattern2 = await rl.question("  Pattern 2: ");
+        const pattern3 = await rl.question("  Pattern 3: ");
+        const patterns = [pattern1, pattern2, pattern3].filter((p) => p.trim());
+
+        if (patterns.length === 0) {
+          console.log("❌ At least one writing pattern is required.");
+          rl.close();
+          return;
+        }
+
+        const tagsRaw = await rl.question("Tags (comma-separated, e.g. tech, essays): ");
+        const tags = tagsRaw.split(",").map((t: string) => t.trim()).filter((t: string) => t);
+
+        rl.close();
+
+        const persona: Persona = {
+          name,
+          displayName: displayName.trim(),
+          description: description.trim() || `Custom persona: ${displayName.trim()}`,
+          version: "1.0",
+          author: "local",
+          style: {
+            tone: tone.trim() || "custom",
+            patterns,
+          },
+          examples: [],
+          tags,
+        };
+
+        const dest = path.join(personasDir(cfg.notesDir), `${name}.json`);
+        fs.writeFileSync(dest, JSON.stringify(persona, null, 2) + "\n", "utf8");
+
+        console.log(`\n✅ Created persona: ${persona.displayName}`);
+        console.log(`   Saved to: ${dest}`);
+        console.log(`   Use: openclaw notes transform <slug> --voice ${name}`);
+        console.log(`   Export: openclaw notes personas export ${name}`);
+      } catch (err: any) {
+        rl.close();
+        console.log(`\n❌ Error creating persona: ${err?.message || "unknown"}`);
+      }
+    });
+
+    // ── personas delete <name> ─────────────────────────────────────
+    personasCmd.command("delete <name>").action(async (name: string) => {
+      const cfg = resolveConfig(api);
+      const persona = loadInstalledPersona(cfg.notesDir, name);
+
+      if (!persona) {
+        console.log(`\n❌ Persona "${name}" not found locally.`);
+        console.log(`   Installed personas: openclaw notes personas`);
+        return;
+      }
+
+      if (process.stdin.isTTY) {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        const answer = await rl.question(`Delete persona "${persona.displayName}" (${name})? (y/N) `);
+        rl.close();
+        if (!(answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes")) {
+          console.log("Cancelled.");
+          return;
+        }
+      }
+
+      const file = path.join(personasDir(cfg.notesDir), `${name}.json`);
+      fs.unlinkSync(file);
+      console.log(`\n🗑️  Deleted persona: ${persona.displayName} (${name})`);
+    });
+
+    // ── analyze ───────────────────────────────────────────────────
+    notes.command("analyze <slug>").action((slug: string) => {
+      const cfg = resolveConfig(api);
+      const file = path.join(cfg.notesDir, `${slug}.md`);
+      if (!fs.existsSync(file)) { console.log(`Note not found: ${slug}.md`); return; }
+      const full = fs.readFileSync(file, "utf8");
+      const { meta, body } = parseFrontMatter(full);
+      const title = meta.title || slug;
+
+      const markers = extractStyleMarkers(body);
+
+      // Write markers to frontmatter
+      const updatedMeta = { ...meta, status: meta.status || "private" };
+      const updated = writeFrontmatterWithMarkers(updatedMeta, body, markers);
+      fs.writeFileSync(file, updated, "utf8");
+
+      console.log(`📊 Style Markers: "${title}" (${slug}.md)`);
+      console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+      console.log(`  Sentences:          ${markers.sentences}`);
+      console.log(`  Paragraphs:         ${markers.paragraphs}`);
+      console.log(`  Words:              ${markers.wordCount}`);
+      console.log(`  Avg sentence len:   ${markers.avgSentenceLength} words`);
+      console.log(`  Avg ¶ sentences:    ${markers.avgParagraphSentences}`);
+      console.log(`  Perspective:        ${markers.perspective}`);
+      console.log(`  Emoji usage:        ${markers.emojiUsage}`);
+      console.log(`  Readability (F-K):  ${markers.readabilityScore}/100`);
+      console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+      console.log(`Markers saved to frontmatter.`);
+    });
+
+    // ── refine ────────────────────────────────────────────────────
+    notes.command("refine <slug>").action((slug: string) => {
+      const cfg = resolveConfig(api);
+      const file = path.join(cfg.notesDir, `${slug}.md`);
+      if (!fs.existsSync(file)) { console.log(`Note not found: ${slug}.md`); return; }
+      const full = fs.readFileSync(file, "utf8");
+      const { meta, body } = parseFrontMatter(full);
+      const title = meta.title || slug;
+
+      // Extract style markers on refine
+      const markers = extractStyleMarkers(body);
+      const refinedMeta = { ...meta, status: "refined" };
+      const updated = writeFrontmatterWithMarkers(refinedMeta, body, markers);
+      fs.writeFileSync(file, updated, "utf8");
+
+      // Auto-update aggregate profile
+      const profileResult = updateAggregateProfile(cfg.notesDir);
+      if (profileResult.updated) {
+        console.log(`🎨 Style profile auto-updated (${profileResult.noteCount} notes analyzed)`);
+      }
+
+      const topics = readTopics(cfg.notesDir);
+      const linked = topics.find((t) => t.slug === (meta.slug || slug));
+      if (linked && linked.status !== "refined") {
+        linked.status = "refined";
+        writeTopics(cfg.notesDir, topics);
+      }
+
+      console.log(`✨ Refined: "${title}" (${slug}.md)`);
+      console.log(`   Status: refined — ready for review\n`);
+      console.log(`Next steps:`);
+      console.log(`  Review:  openclaw notes preview ${slug}`);
+      console.log(`  Test:    openclaw notes test ${slug}`);
+      console.log(`  Publish: openclaw notes publish ${slug}`);
+    });
+
+    // ── test ──────────────────────────────────────────────────────
+    notes.command("test <slug>").action((slug: string) => {
+      const cfg = resolveConfig(api);
+      const file = path.join(cfg.notesDir, `${slug}.md`);
+      if (!fs.existsSync(file)) { console.log(`Note not found: ${slug}.md`); return; }
+      const full = fs.readFileSync(file, "utf8");
+      const { meta, body } = parseFrontMatter(full);
+      const title = meta.title || slug;
+      const wordCount = body.split(/\s+/).filter((w: string) => w.length > 0).length;
+
+      // Load custom personas or use defaults
+      const personasConfig = loadPersonas(cfg.notesDir);
+      const defaultPersonas = [
+        { id: "senior-dev", name: "Technical Builder", emoji: "🔧", description: "Senior developer or architect. 10+ years experience. Values depth, correctness, and novel insights. Shares content that teaches them something or validates a hard-won lesson.", evaluates: ["technical accuracy", "novelty", "depth", "shareability"] },
+        { id: "founder", name: "Startup Founder", emoji: "🚀", description: "Building a product, always time-poor. Values actionable advice and hard-won lessons. Shares content that saves them time or money.", evaluates: ["actionability", "time-respect", "real-world applicability"] },
+        { id: "learner", name: "Curious Learner", emoji: "📚", description: "Junior developer or student. Eager but lacks context. Values clear explanations and concrete examples. Shares content that made a concept click.", evaluates: ["accessibility", "teaching quality", "concrete examples"] },
+        { id: "brand-strategist", name: "Personal Brand Strategist", emoji: "👤", description: "Evaluates whether content builds portable personal authority. Checks: Is the insight earned from real experience? Would this survive a job change? Is there a screenshot-worthy takeaway?", evaluates: ["authority building", "portability", "earned insight", "shareability"] },
+      ];
+
+      let personas = defaultPersonas;
+      if (personasConfig?.sets) {
+        const sets = personasConfig.defaultSets || Object.keys(personasConfig.sets);
+        personas = [];
+        for (const setName of sets) {
+          if (personasConfig.sets[setName]?.personas) personas.push(...personasConfig.sets[setName].personas);
+        }
+      }
+
+      console.log(`🧪 Audience Test: "${title}"`);
+      console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+      console.log(`\nContent (${wordCount} words):`);
+      console.log(body);
+      console.log(`\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+      console.log(`Evaluate this content from ${personas.length} perspectives:\n`);
+
+      personas.forEach((p, i) => {
+        console.log(`${i + 1}. ${p.emoji} **${p.name}**`);
+        console.log(`   ${p.description}`);
+        console.log(`   Evaluate: ${p.evaluates.join(", ")}`);
+        console.log(`   Rate: 👍 Would engage | 🤷 Maybe | 👎 Skip`);
+        console.log(`   Score: 1-10`);
+        console.log();
+      });
+
+      console.log(`Then provide:`);
+      console.log(`- Overall confidence score (0-10)`);
+      console.log(`- One specific improvement suggestion\n`);
+
+      // Persistence instructions
+      const varDir = variationsDir(cfg.notesDir, slug);
+      console.log(`📁 After evaluation, save results to:`);
+      console.log(`   ${path.join(varDir, "_test-results.json")}`);
+      console.log(`\n   Schema:`);
+      console.log(`   {`);
+      console.log(`     "slug": "${slug}",`);
+      console.log(`     "tested": "${new Date().toISOString()}",`);
+      console.log(`     "scores": {`);
+      personas.forEach((p) => {
+        console.log(`       "${p.id}": { "sentiment": "positive|negative|neutral", "engagement": "would-share|would-comment|would-read|would-skip", "score": N, "feedback": "...", "suggestion": "..." },`);
+      });
+      console.log(`     },`);
+      console.log(`     "confidence": N,`);
+      console.log(`     "topSuggestion": "..."`);
+      console.log(`   }`);
+      console.log(`\n   Also update the note's frontmatter: confidence: N`);
+      console.log(`   Create directory if needed: mkdir -p ${varDir}`);
+    });
+
+    // ── voice ─────────────────────────────────────────────────────
+    notes.command("voice <title>").action((title: string) => {
+      const cfg = resolveConfig(api);
+      fs.mkdirSync(cfg.notesDir, { recursive: true });
+      const base = slugify(title);
+      const slug = uniqueSlug(base, cfg.notesDir);
+      const now = new Date().toISOString().split("T")[0];
+
+      const topics = readTopics(cfg.notesDir);
+      const topic: Topic = { id: generateId(), title, source: "voice", added: now, status: "drafted", slug, tags: undefined };
+      topics.push(topic);
+      writeTopics(cfg.notesDir, topics);
+
+      const content = newNoteFrontmatter({ title, slug, topicId: topic.id, inputType: "voice" }) + "\n";
+      const filename = path.join(cfg.notesDir, `${slug}.md`);
+      fs.writeFileSync(filename, content, "utf8");
+
+      console.log(`🎤 Voice note created`);
+      console.log(`   Topic: ${topic.id} — "${title}"`);
+      console.log(`   File: ${filename}\n`);
+      console.log(`Write the transcribed content to this file, then run:`);
+      console.log(`  openclaw notes refine ${slug}`);
+    });
+
+    // ── preview ────────────────────────────────────────────────────
+    notes.command("preview <slug>").action((slug: string) => {
+      const cfg = resolveConfig(api);
+      const file = path.join(cfg.notesDir, `${slug}.md`);
+      if (!fs.existsSync(file)) { console.log(`Note not found: ${slug}.md`); return; }
+      const full = fs.readFileSync(file, "utf8");
+      const { meta, body } = parseFrontMatter(full);
+      const title = meta.title || slug;
+      const tags = meta.tags || "[]";
+      const status = meta.status || "private";
+      const excerpt = excerptFrom(body);
+      const wordCount = body.split(/\s+/).filter((w: string) => w.length > 0).length;
+
+      console.log(`📖 Preview: ${title}`);
+      console.log(`${"─".repeat(60)}`);
+      console.log(`Status:     ${status}`);
+      console.log(`Slug:       ${meta.slug || slug}`);
+      console.log(`Tags:       ${tags}`);
+      console.log(`Words:      ${wordCount}`);
+      if (meta.tone) console.log(`Tone:       ${meta.tone}`);
+      if (meta.structure) console.log(`Structure:  ${meta.structure}`);
+      if (meta.confidence) console.log(`Confidence: ${meta.confidence}/10`);
+      console.log(`Excerpt:    ${excerpt}`);
+      console.log(`${"─".repeat(60)}`);
+      console.log();
+      console.log(body);
+      console.log();
+      console.log(`${"─".repeat(60)}`);
+      if (status === "public") console.log(`This note is already published.`);
+      else if (status === "refined") {
+        console.log(`This note is refined and ready for publishing.`);
+        console.log(`To publish: openclaw notes publish ${slug} --yes --reason "your reason"`);
+      } else {
+        console.log(`To refine:  openclaw notes transform ${slug}`);
+        console.log(`To publish: openclaw notes publish ${slug} --yes --reason "your reason"`);
+      }
+    });
+
+    // ── style ─────────────────────────────────────────────────────
+    notes
+      .command("style")
+      .option("--from <slugs>", "comma-separated slugs to analyze (default: all refined/published)")
+      .action((options: any) => {
+        const cfg = resolveConfig(api);
+        const files = listNotes(cfg.notesDir);
+        const profilePath = path.join(cfg.notesDir, ".style-profile.json");
+
+        // Gather notes to analyze
+        let notesToAnalyze: { slug: string; title: string; body: string }[] = [];
+        if (options.from) {
+          const slugs = options.from.split(",").map((s: string) => s.trim());
+          for (const s of slugs) {
+            const f = path.join(cfg.notesDir, `${s}.md`);
+            if (fs.existsSync(f)) {
+              const { meta, body } = parseFrontMatter(fs.readFileSync(f, "utf8"));
+              notesToAnalyze.push({ slug: s, title: meta.title || s, body });
+            }
+          }
+        } else {
+          for (const f of files) {
+            const full = fs.readFileSync(path.join(cfg.notesDir, f), "utf8");
+            const { meta, body } = parseFrontMatter(full);
+            if (meta.status === "refined" || meta.status === "public") {
+              notesToAnalyze.push({ slug: f.replace(/\.md$/, ""), title: meta.title || f, body });
+            }
+          }
+        }
+
+        if (notesToAnalyze.length === 0) {
+          console.log(`No refined or published notes found to analyze.`);
+          console.log(`Refine some notes first, or use --from to specify slugs.`);
+          return;
+        }
+
+        console.log(`🎨 Style Profile Analysis`);
+        console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+        console.log(`Analyzing ${notesToAnalyze.length} notes:\n`);
+        for (const n of notesToAnalyze) console.log(`  - ${n.title} (${n.slug})`);
+
+        console.log(`\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+        console.log(`Analyze the writing style across these ${notesToAnalyze.length} notes and extract a style profile.\n`);
+        console.log(`Sample content from each note:\n`);
+        for (const n of notesToAnalyze) {
+          const preview = n.body.slice(0, 500);
+          console.log(`--- "${n.title}" ---`);
+          console.log(preview);
+          if (n.body.length > 500) console.log(`... (${n.body.length - 500} more chars)`);
+          console.log();
+        }
+
+        console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+        console.log(`Extract and save a style profile to: ${profilePath}\n`);
+        console.log(`Schema:`);
+        console.log(`{`);
+        console.log(`  "updated": "${new Date().toISOString()}",`);
+        console.log(`  "analyzedNotes": [${notesToAnalyze.map((n) => `"${n.slug}"`).join(", ")}],`);
+        console.log(`  "markers": {`);
+        console.log(`    "avgSentenceLength": "short|medium|long",`);
+        console.log(`    "paragraphLength": "short|medium|long",`);
+        console.log(`    "emojiUsage": "none|rare|frequent",`);
+        console.log(`    "toneDefault": "authentic|professional|casual|humorous",`);
+        console.log(`    "vocabulary": "description of vocabulary level",`);
+        console.log(`    "perspective": "first-person|third-person|mixed",`);
+        console.log(`    "openingStyle": "description of how posts typically open",`);
+        console.log(`    "closingStyle": "description of how posts typically close"`);
+        console.log(`  },`);
+        console.log(`  "voiceDescription": "2-3 sentence natural language description of the writing voice",`);
+        console.log(`  "avoid": ["list", "of", "anti-patterns"],`);
+        console.log(`  "examples": {`);
+        console.log(`    "strongOpeners": ["example opener sentences from the analyzed notes"],`);
+        console.log(`    "strongClosers": ["example closer sentences from the analyzed notes"]`);
+        console.log(`  }`);
+        console.log(`}`);
+      });
+
+    // ── vary ──────────────────────────────────────────────────────
+    notes
+      .command("vary <slug>")
+      .option("--tones <tones>", "comma-separated tones (default: authentic,professional,casual,humorous)")
+      .option("--structures <structures>", "comma-separated structures (default: auto-detect best fit)")
+      .action((slug: string, options: any) => {
+        const cfg = resolveConfig(api);
+        const file = path.join(cfg.notesDir, `${slug}.md`);
+        if (!fs.existsSync(file)) { console.log(`Note not found: ${slug}.md`); return; }
+        const full = fs.readFileSync(file, "utf8");
+        const { meta, body } = parseFrontMatter(full);
+        const title = meta.title || slug;
+        const wordCount = body.split(/\s+/).filter((w: string) => w.length > 0).length;
+        const styleProfile = loadStyleProfile(cfg.notesDir);
+        const templates = loadStructureTemplates(pluginDir);
+        const tones = options.tones ? options.tones.split(",").map((s: string) => s.trim()) : ["authentic", "professional", "casual", "humorous"];
+        const structures = options.structures ? options.structures.split(",").map((s: string) => s.trim()) : [meta.structure || "structured"];
+        const varDir = variationsDir(cfg.notesDir, slug);
+
+        console.log(`🔀 Generate Variations: "${title}"`);
+        console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+        console.log(`Tones: ${tones.join(", ")}`);
+        console.log(`Structures: ${structures.join(", ")}`);
+        console.log(`Variations to generate: ${tones.length * structures.length}`);
+        if (styleProfile) console.log(`Style profile loaded (${styleProfile.analyzedNotes.length} notes analyzed)`);
+        console.log();
+
+        console.log(`Source (${wordCount} words):`);
+        console.log(body);
+        console.log();
+        console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+
+        // Style injection
+        if (styleProfile) {
+          console.log(`\n🎨 STYLE PROFILE — Maintain this voice across ALL variations:`);
+          console.log(`   ${styleProfile.voiceDescription}`);
+          if (styleProfile.avoid?.length) console.log(`   Avoid: ${styleProfile.avoid.join(", ")}`);
+          console.log();
+        }
+
+        // Structure templates
+        if (templates.length > 0) {
+          console.log(`📋 STRUCTURE TEMPLATES:`);
+          for (const s of structures) {
+            const tpl = templates.find((t) => t.name === s);
+            if (tpl) console.log(`   ${tpl.name}: ${tpl.instructions}`);
+          }
+          console.log();
+        }
+
+        console.log(`Generate ${tones.length * structures.length} variations of this post.\n`);
+        console.log(`For each variation:`);
+        console.log(`1. Apply the specified tone + structure combination`);
+        console.log(`2. Maintain the core insight and key points`);
+        console.log(`3. Keep it atomic: one clear idea per post`);
+        console.log(`4. Match the target word count for the structure`);
+        console.log();
+
+        const variationList: string[] = [];
+        for (const s of structures) {
+          for (const t of tones) {
+            const varFile = `${t}-${s}.md`;
+            variationList.push(varFile);
+            console.log(`📄 ${varFile} — tone: ${t}, structure: ${s}`);
+          }
+        }
+
+        console.log(`\n📁 Save all variation files to: ${varDir}/`);
+        console.log(`   Create directory: mkdir -p ${varDir}`);
+        console.log(`\n   Each variation is a standalone markdown file (no frontmatter needed).`);
+        console.log(`\n   Also create ${varDir}/_manifest.json:`);
+        console.log(`   {`);
+        console.log(`     "source": "${slug}.md",`);
+        console.log(`     "generated": "${new Date().toISOString()}",`);
+        console.log(`     "variations": [`);
+        for (const v of variationList) {
+          const parts = v.replace(".md", "").split("-");
+          const t = parts[0];
+          const s = parts.slice(1).join("-");
+          console.log(`       { "file": "${v}", "tone": "${t}", "structure": "${s}", "wordCount": N, "tested": false, "confidence": null, "selected": false },`);
+        }
+        console.log(`     ],`);
+        console.log(`     "selectedVariation": null`);
+        console.log(`   }`);
+      });
+
+    // ── variations ───────────────────────────────────────────────
+    notes.command("variations <slug>").action((slug: string) => {
+      const cfg = resolveConfig(api);
+      const manifest = loadManifest(cfg.notesDir, slug);
+      if (!manifest) {
+        console.log(`No variations found for ${slug}. Run: openclaw notes vary ${slug}`);
+        return;
+      }
+
+      const testResults = loadTestResults(cfg.notesDir, slug);
+
+      console.log(`🔀 Variations: "${slug}" (source: ${manifest.source})`);
+      console.log(`   Generated: ${manifest.generated}`);
+      if (manifest.selectedVariation) console.log(`   Selected: ${manifest.selectedVariation}`);
+      console.log();
+
+      for (const v of manifest.variations) {
+        const selected = v.selected ? " ✅ SELECTED" : "";
+        const tested = v.tested ? ` (confidence: ${v.confidence}/10)` : "";
+        const varFile = path.join(variationsDir(cfg.notesDir, slug), v.file);
+        const exists = fs.existsSync(varFile);
+        console.log(`  ${exists ? "📄" : "❌"} ${v.file.padEnd(30)} tone: ${v.tone.padEnd(14)} structure: ${v.structure.padEnd(12)} ${v.wordCount}w${tested}${selected}`);
+      }
+
+      if (testResults) {
+        console.log(`\n   Test results: confidence ${testResults.confidence}/10`);
+        if (testResults.topSuggestion) console.log(`   Top suggestion: ${testResults.topSuggestion}`);
+      }
+
+      console.log(`\nTo pick a variation: openclaw notes pick ${slug} <tone-structure>`);
+      console.log(`To test: openclaw notes test ${slug}`);
+    });
+
+    // ── pick ─────────────────────────────────────────────────────
+    notes.command("pick <slug> <variation>").action((slug: string, variation: string) => {
+      const cfg = resolveConfig(api);
+      const manifest = loadManifest(cfg.notesDir, slug);
+      if (!manifest) { console.log(`No variations found for ${slug}.`); return; }
+
+      // Find the variation (match by filename or tone-structure)
+      const varName = variation.endsWith(".md") ? variation : `${variation}.md`;
+      const entry = manifest.variations.find((v) => v.file === varName || v.file === `${variation}.md`);
+      if (!entry) {
+        console.log(`Variation "${variation}" not found. Available:`);
+        for (const v of manifest.variations) console.log(`  ${v.file}`);
+        return;
+      }
+
+      const varFile = path.join(variationsDir(cfg.notesDir, slug), entry.file);
+      if (!fs.existsSync(varFile)) { console.log(`Variation file not found: ${varFile}`); return; }
+      const varContent = fs.readFileSync(varFile, "utf8");
+
+      // Read current note and replace body
+      const noteFile = path.join(cfg.notesDir, `${slug}.md`);
+      const full = fs.readFileSync(noteFile, "utf8");
+      const { meta } = parseFrontMatter(full);
+
+      // Rebuild note with variation content and updated frontmatter
+      const title = meta.title || slug;
+      const tags = meta.tags || "[]";
+      const updated = `---\ntitle: "${title}"\nslug: "${meta.slug || slug}"\nstatus: ${meta.status || "private"}\npublished_at: ${meta.published_at || "null"}\n${meta.topic_id ? `topic_id: "${meta.topic_id}"\n` : ""}tone: ${entry.tone}\nstructure: ${entry.structure}\nconfidence: ${meta.confidence || "null"}\nvariation_of: "${entry.file}"\ntags: ${tags}\n---\n\n${varContent}\n`;
+      fs.writeFileSync(noteFile, updated, "utf8");
+
+      // Update manifest
+      for (const v of manifest.variations) v.selected = false;
+      entry.selected = true;
+      manifest.selectedVariation = entry.file;
+      const manifestPath = path.join(variationsDir(cfg.notesDir, slug), "_manifest.json");
+      fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + "\n", "utf8");
+
+      console.log(`✅ Picked variation: ${entry.file}`);
+      console.log(`   Tone: ${entry.tone} | Structure: ${entry.structure}`);
+      console.log(`   Content copied to ${slug}.md`);
+      console.log(`\nNext: openclaw notes refine ${slug}`);
+    });
+
+    // ── feedback ─────────────────────────────────────────────────
+    notes
+      .command("feedback <slug>")
+      .description("Record performance feedback for a note")
+      .option("--score <n>", "overall quality rating (1-10)", parseInt)
+      .option("--views <n>", "view count", parseInt)
+      .option("--likes <n>", "likes/hearts", parseInt)
+      .option("--shares <n>", "shares/reposts", parseInt)
+      .option("--comments <n>", "comment count", parseInt)
+      .option("--platform <name>", "platform name (blog, linkedin, twitter)")
+      .option("--note <text>", "free-text note about what worked/didn't")
+      .action((slug: string, options: any) => {
+        const cfg = resolveConfig(api);
+
+        // Verify the note exists
+        const noteFile = path.join(cfg.notesDir, `${slug}.md`);
+        if (!fs.existsSync(noteFile)) {
+          console.log(`❌ Note not found: ${slug}.md`);
+          return;
+        }
+
+        // Validate score
+        if (options.score !== undefined && (options.score < 1 || options.score > 10 || isNaN(options.score))) {
+          console.log("❌ Score must be between 1 and 10");
+          return;
+        }
+
+        if (!options.score && !options.views && !options.likes && !options.shares && !options.comments && !options.note) {
+          console.log("❌ Provide at least --score, a metric (--views/--likes/--shares/--comments), or --note");
+          return;
+        }
+
+        // Build entry
+        const entry: FeedbackEntry = {
+          date: new Date().toISOString(),
+          score: options.score || 0,
+          metrics: {
+            ...(options.views !== undefined ? { views: options.views } : {}),
+            ...(options.likes !== undefined ? { likes: options.likes } : {}),
+            ...(options.shares !== undefined ? { shares: options.shares } : {}),
+            ...(options.comments !== undefined ? { comments: options.comments } : {}),
+          },
+          ...(options.platform ? { platform: options.platform } : {}),
+          ...(options.note ? { note: options.note } : {}),
+        };
+
+        // Load existing or create new
+        let fb = loadFeedback(cfg.notesDir, slug);
+        if (!fb) {
+          fb = { slug, entries: [], aggregate: { avgScore: 0, totalViews: 0, totalLikes: 0, totalShares: 0, totalComments: 0, entries: 0 } };
+        }
+
+        fb.entries.push(entry);
+        fb.aggregate = recalcAggregate(fb.entries);
+        saveFeedback(cfg.notesDir, fb);
+
+        // Update performance weights in style profile
+        updatePerformanceWeights(cfg.notesDir);
+
+        console.log(`\n✅ Feedback recorded for "${slug}"`);
+        console.log(`   Score: ${entry.score || "—"} | Platform: ${entry.platform || "—"}`);
+        if (Object.keys(entry.metrics).length > 0) {
+          const parts: string[] = [];
+          if (entry.metrics.views !== undefined) parts.push(`${entry.metrics.views} views`);
+          if (entry.metrics.likes !== undefined) parts.push(`${entry.metrics.likes} likes`);
+          if (entry.metrics.shares !== undefined) parts.push(`${entry.metrics.shares} shares`);
+          if (entry.metrics.comments !== undefined) parts.push(`${entry.metrics.comments} comments`);
+          console.log(`   Metrics: ${parts.join(", ")}`);
+        }
+        if (entry.note) console.log(`   Note: ${entry.note}`);
+        console.log(`\n   Aggregate (${fb.aggregate.entries} entries): avg score ${fb.aggregate.avgScore} · ${fb.aggregate.totalViews} views · ${fb.aggregate.totalLikes} likes · ${fb.aggregate.totalShares} shares`);
+      });
+
+    // ── insights ─────────────────────────────────────────────────
+    notes
+      .command("insights")
+      .description("Correlate performance feedback with style markers")
+      .action(() => {
+        const cfg = resolveConfig(api);
+        const allFeedback = loadAllFeedback(cfg.notesDir);
+
+        if (allFeedback.length === 0) {
+          console.log("No feedback data yet. Record feedback with: openclaw notes feedback <slug> --score 8 --views 100");
+          return;
+        }
+
+        // Gather enriched data
+        interface NoteInsight {
+          slug: string;
+          score: number;
+          totalViews: number;
+          totalLikes: number;
+          totalShares: number;
+          totalComments: number;
+          entries: number;
+          tone: string | null;
+          structure: string | null;
+          markers: Record<string, any> | null;
+          platforms: string[];
+        }
+
+        const notes: NoteInsight[] = [];
+        for (const fb of allFeedback) {
+          if (fb.aggregate.entries === 0) continue;
+          const noteFile = path.join(cfg.notesDir, `${fb.slug}.md`);
+          if (!fs.existsSync(noteFile)) continue;
+          const { meta, body } = parseFrontMatter(fs.readFileSync(noteFile, "utf8"));
+          let markers: Record<string, any> | null = null;
+          if (meta.style_markers) {
+            try { markers = typeof meta.style_markers === "string" ? JSON.parse(meta.style_markers) : meta.style_markers; } catch {}
+          }
+          if (!markers) markers = extractStyleMarkers(body);
+          const platforms = [...new Set(fb.entries.filter((e) => e.platform).map((e) => e.platform!))];
+          notes.push({
+            slug: fb.slug,
+            score: fb.aggregate.avgScore,
+            totalViews: fb.aggregate.totalViews,
+            totalLikes: fb.aggregate.totalLikes,
+            totalShares: fb.aggregate.totalShares,
+            totalComments: fb.aggregate.totalComments,
+            entries: fb.aggregate.entries,
+            tone: meta.tone || null,
+            structure: meta.structure || null,
+            markers,
+            platforms,
+          });
+        }
+
+        if (notes.length === 0) {
+          console.log("No matched feedback + notes found.");
+          return;
+        }
+
+        console.log(`\n📊 Performance Insights (${notes.length} notes with feedback)\n`);
+
+        // ── Top performers ──
+        const sorted = [...notes].sort((a, b) => b.score - a.score);
+        console.log("🏆 Top Performers:");
+        for (const n of sorted.slice(0, 5)) {
+          console.log(`   ${n.score}/10  ${n.slug}  (${n.totalViews} views, ${n.totalLikes} likes, ${n.totalShares} shares)`);
+        }
+        console.log();
+
+        // ── Sentence length correlation ──
+        const withSentLen = notes.filter((n) => n.markers?.avgSentenceLength);
+        if (withSentLen.length >= 2) {
+          const median = [...withSentLen].sort((a, b) => a.score - b.score);
+          const topHalf = median.slice(Math.floor(median.length / 2));
+          const bottomHalf = median.slice(0, Math.floor(median.length / 2));
+          if (topHalf.length > 0 && bottomHalf.length > 0) {
+            const topAvgSL = Math.round(topHalf.reduce((s, n) => s + n.markers!.avgSentenceLength, 0) / topHalf.length * 10) / 10;
+            const botAvgSL = Math.round(bottomHalf.reduce((s, n) => s + n.markers!.avgSentenceLength, 0) / bottomHalf.length * 10) / 10;
+            console.log(`📏 Sentence Length:`);
+            console.log(`   Your highest-rated posts average ${topAvgSL} words/sentence (vs ${botAvgSL} for lowest)`);
+            console.log();
+          }
+        }
+
+        // ── Structure correlation ──
+        const structGroups: Record<string, { total: number; count: number }> = {};
+        for (const n of notes) {
+          if (!n.structure) continue;
+          if (!structGroups[n.structure]) structGroups[n.structure] = { total: 0, count: 0 };
+          structGroups[n.structure].total += n.score;
+          structGroups[n.structure].count += 1;
+        }
+        const structEntries = Object.entries(structGroups).map(([k, v]) => ({ structure: k, avg: Math.round((v.total / v.count) * 10) / 10, count: v.count }));
+        if (structEntries.length >= 2) {
+          structEntries.sort((a, b) => b.avg - a.avg);
+          const best = structEntries[0];
+          const worst = structEntries[structEntries.length - 1];
+          const delta = Math.round((best.avg - worst.avg) * 10) / 10;
+          console.log(`🏗️  Structure:`);
+          for (const s of structEntries) {
+            console.log(`   "${s.structure}" avg score ${s.avg} (${s.count} notes)`);
+          }
+          if (delta > 0) console.log(`   → Posts with '${best.structure}' structure score ${delta} points higher than '${worst.structure}'`);
+          console.log();
+        }
+
+        // ── Tone correlation ──
+        const toneGroups: Record<string, { total: number; count: number }> = {};
+        for (const n of notes) {
+          if (!n.tone) continue;
+          if (!toneGroups[n.tone]) toneGroups[n.tone] = { total: 0, count: 0 };
+          toneGroups[n.tone].total += n.score;
+          toneGroups[n.tone].count += 1;
+        }
+        const toneEntries = Object.entries(toneGroups).map(([k, v]) => ({ tone: k, avg: Math.round((v.total / v.count) * 10) / 10, count: v.count }));
+        if (toneEntries.length >= 2) {
+          toneEntries.sort((a, b) => b.avg - a.avg);
+          console.log(`🎭 Tone:`);
+          for (const t of toneEntries) {
+            console.log(`   "${t.tone}" avg score ${t.avg} (${t.count} notes)`);
+          }
+          console.log();
+        } else if (toneEntries.length === 1) {
+          console.log(`🎭 Tone: all feedback notes use "${toneEntries[0].tone}" (avg ${toneEntries[0].avg})`);
+          console.log();
+        }
+
+        // ── Platform comparison ──
+        const platformMetrics: Record<string, { views: number; likes: number; shares: number; comments: number; count: number }> = {};
+        for (const fb of allFeedback) {
+          for (const e of fb.entries) {
+            if (!e.platform) continue;
+            if (!platformMetrics[e.platform]) platformMetrics[e.platform] = { views: 0, likes: 0, shares: 0, comments: 0, count: 0 };
+            const pm = platformMetrics[e.platform];
+            pm.views += e.metrics.views || 0;
+            pm.likes += e.metrics.likes || 0;
+            pm.shares += e.metrics.shares || 0;
+            pm.comments += e.metrics.comments || 0;
+            pm.count += 1;
+          }
+        }
+        const platEntries = Object.entries(platformMetrics);
+        if (platEntries.length >= 2) {
+          console.log(`🌐 Platform Comparison:`);
+          for (const [platform, pm] of platEntries) {
+            console.log(`   ${platform}: ${pm.views} views, ${pm.likes} likes, ${pm.shares} shares, ${pm.comments} comments (${pm.count} entries)`);
+          }
+          // Cross-platform share comparison
+          const platShareAvgs = platEntries
+            .filter(([, pm]) => pm.count > 0)
+            .map(([platform, pm]) => ({ platform, avgShares: Math.round(pm.shares / pm.count * 10) / 10 }))
+            .sort((a, b) => b.avgShares - a.avgShares);
+          if (platShareAvgs.length >= 2 && platShareAvgs[platShareAvgs.length - 1].avgShares > 0) {
+            const ratio = Math.round(platShareAvgs[0].avgShares / platShareAvgs[platShareAvgs.length - 1].avgShares * 10) / 10;
+            console.log(`   → ${platShareAvgs[0].platform} gets ${ratio}x more shares than ${platShareAvgs[platShareAvgs.length - 1].platform}`);
+          }
+          console.log();
+        }
+
+        // ── Word count correlation ──
+        const withWordCount = notes.filter((n) => n.markers?.wordCount);
+        if (withWordCount.length >= 2) {
+          const sortedByScore = [...withWordCount].sort((a, b) => a.score - b.score);
+          const topHalf = sortedByScore.slice(Math.floor(sortedByScore.length / 2));
+          const bottomHalf = sortedByScore.slice(0, Math.floor(sortedByScore.length / 2));
+          if (topHalf.length > 0 && bottomHalf.length > 0) {
+            const topAvgWC = Math.round(topHalf.reduce((s, n) => s + n.markers!.wordCount, 0) / topHalf.length);
+            const botAvgWC = Math.round(bottomHalf.reduce((s, n) => s + n.markers!.wordCount, 0) / bottomHalf.length);
+            console.log(`📝 Word Count:`);
+            console.log(`   Top-scoring posts average ${topAvgWC} words (vs ${botAvgWC} for lowest-scoring)`);
+            console.log();
+          }
+        }
+
+        // ── Readability correlation ──
+        const withReadability = notes.filter((n) => n.markers?.readabilityScore);
+        if (withReadability.length >= 2) {
+          const sortedByScore = [...withReadability].sort((a, b) => a.score - b.score);
+          const topHalf = sortedByScore.slice(Math.floor(sortedByScore.length / 2));
+          const bottomHalf = sortedByScore.slice(0, Math.floor(sortedByScore.length / 2));
+          if (topHalf.length > 0 && bottomHalf.length > 0) {
+            const topAvgRd = Math.round(topHalf.reduce((s, n) => s + n.markers!.readabilityScore, 0) / topHalf.length);
+            const botAvgRd = Math.round(bottomHalf.reduce((s, n) => s + n.markers!.readabilityScore, 0) / bottomHalf.length);
+            console.log(`📖 Readability:`);
+            console.log(`   Top-scoring posts: ${topAvgRd}/100 FK score vs ${botAvgRd}/100 for lowest-scoring`);
+            console.log();
+          }
+        }
+
+        console.log(`💡 Tip: Record more feedback to improve correlations. Run: openclaw notes feedback <slug> --score 8 --platform linkedin`);
+      });
+
+    // ── subscribe ─────────────────────────────────────────────────
+    notes
+      .command("subscribe [url]")
+      .description("Subscribe to another PressClaw instance's agent feed")
+      .action(async (url?: string) => {
+        const cfg = resolveConfig(api);
+        const subs = readSubscriptions(cfg.notesDir);
+
+        // No args → list current subscriptions
+        if (!url) {
+          if (subs.length === 0) {
+            console.log("No subscriptions yet.");
+            console.log("Add one: openclaw notes subscribe <url>");
+            return;
+          }
+          console.log(`📡 Subscriptions (${subs.length}):\n`);
+          for (const sub of subs) {
+            const checked = sub.last_checked ? `last checked ${sub.last_checked}` : "never checked";
+            console.log(`  ${sub.name}`);
+            console.log(`    ${sub.url}`);
+            console.log(`    Feed: ${sub.feed_url}`);
+            console.log(`    Added: ${sub.added} · ${checked}\n`);
+          }
+          return;
+        }
+
+        // Normalize URL
+        let baseUrl = url.replace(/\/+$/, "");
+        if (!baseUrl.startsWith("http")) baseUrl = `https://${baseUrl}`;
+
+        // Check if already subscribed
+        if (subs.find((s) => s.url === baseUrl)) {
+          console.log(`Already subscribed to ${baseUrl}`);
+          return;
+        }
+
+        // Fetch well-known to validate
+        console.log(`Fetching ${baseUrl}/.well-known/pressclaw.json ...`);
+        try {
+          const resp = await fetch(`${baseUrl}/.well-known/pressclaw.json`);
+          if (!resp.ok) {
+            console.log(`❌ Could not find PressClaw instance at ${baseUrl}`);
+            console.log(`   HTTP ${resp.status}: ${resp.statusText}`);
+            return;
+          }
+          const wellKnown: any = await resp.json();
+          if (!wellKnown.feed_url) {
+            console.log(`❌ Invalid pressclaw.json — missing feed_url`);
+            return;
+          }
+
+          const sub: Subscription = {
+            url: baseUrl,
+            name: wellKnown.name || baseUrl,
+            feed_url: wellKnown.feed_url,
+            added: new Date().toISOString(),
+            last_checked: null,
+          };
+          subs.push(sub);
+          writeSubscriptions(cfg.notesDir, subs);
+
+          console.log(`✅ Subscribed to "${sub.name}"`);
+          console.log(`   Feed: ${sub.feed_url}`);
+          if (wellKnown.post_count) console.log(`   Posts: ${wellKnown.post_count}`);
+          if (wellKnown.topics?.length) console.log(`   Topics: ${wellKnown.topics.join(", ")}`);
+        } catch (err: any) {
+          console.log(`❌ Failed to connect to ${baseUrl}`);
+          if (err?.message) console.log(`   Error: ${err.message}`);
+        }
+      });
+
+    // ── unsubscribe ───────────────────────────────────────────────
+    notes
+      .command("unsubscribe <url>")
+      .description("Remove a subscription")
+      .action((url: string) => {
+        const cfg = resolveConfig(api);
+        let baseUrl = url.replace(/\/+$/, "");
+        if (!baseUrl.startsWith("http")) baseUrl = `https://${baseUrl}`;
+
+        const subs = readSubscriptions(cfg.notesDir);
+        const before = subs.length;
+        const filtered = subs.filter((s) => s.url !== baseUrl);
+        if (filtered.length === before) {
+          console.log(`Not subscribed to ${baseUrl}`);
+          return;
+        }
+        writeSubscriptions(cfg.notesDir, filtered);
+        console.log(`✅ Unsubscribed from ${baseUrl}`);
+      });
+
+    // ── digest ────────────────────────────────────────────────────
+    notes
+      .command("digest")
+      .description("Fetch new posts from all subscribed feeds")
+      .action(async () => {
+        const cfg = resolveConfig(api);
+        const subs = readSubscriptions(cfg.notesDir);
+
+        if (subs.length === 0) {
+          console.log("No subscriptions. Add one: openclaw notes subscribe <url>");
+          return;
+        }
+
+        console.log(`📡 Checking ${subs.length} feed(s)...\n`);
+
+        let totalNew = 0;
+        let feedsWithNew = 0;
+        const allNewPosts: { source: string; title: string; topics: string[]; summary: string; url: string; published_at: string }[] = [];
+
+        for (const sub of subs) {
+          try {
+            const resp = await fetch(sub.feed_url);
+            if (!resp.ok) {
+              console.log(`  ⚠️  ${sub.name}: HTTP ${resp.status}`);
+              continue;
+            }
+            const feed: any = await resp.json();
+            const posts: any[] = feed.posts || [];
+
+            // Filter to posts since last_checked
+            const since = sub.last_checked ? new Date(sub.last_checked).getTime() : 0;
+            const newPosts = posts.filter((p: any) => {
+              const pubTime = new Date(p.published_at).getTime();
+              return pubTime > since;
+            });
+
+            if (newPosts.length > 0) {
+              feedsWithNew++;
+              totalNew += newPosts.length;
+              for (const p of newPosts) {
+                allNewPosts.push({
+                  source: sub.name,
+                  title: p.title,
+                  topics: p.topics || [],
+                  summary: p.summary || "",
+                  url: p.url || "",
+                  published_at: p.published_at,
+                });
+              }
+            }
+
+            // Update last_checked
+            sub.last_checked = new Date().toISOString();
+          } catch (err: any) {
+            console.log(`  ⚠️  ${sub.name}: ${err?.message || "fetch failed"}`);
+          }
+        }
+
+        // Save updated timestamps
+        writeSubscriptions(cfg.notesDir, subs);
+
+        if (totalNew === 0) {
+          console.log("No new posts since last check.");
+          return;
+        }
+
+        console.log(`📬 ${totalNew} new post(s) from ${feedsWithNew} feed(s):\n`);
+        for (const p of allNewPosts) {
+          const topics = p.topics.length > 0 ? ` [${p.topics.join(", ")}]` : "";
+          console.log(`  📝 "${p.title}" — ${p.source}${topics}`);
+          console.log(`     ${p.summary.slice(0, 120)}${p.summary.length > 120 ? "…" : ""}`);
+          if (p.url) console.log(`     ${p.url}`);
+          console.log();
+        }
+      });
+
+  }, { commands: ["notes"] });
+
+  // ── HTTP handler ────────────────────────────────────────────────
+
+  const sendFile = (res: any, filePath: string, contentType: string) => {
+    if (!fs.existsSync(filePath)) { res.statusCode = 404; res.end("Not found"); return; }
+    res.statusCode = 200;
+    res.setHeader("Content-Type", contentType);
+    fs.createReadStream(filePath).pipe(res);
+  };
+
+  api.registerHttpHandler((req: any, res: any) => {
+    const cfg = resolveConfig(api);
+    const url = new URL(req.url ?? "/", "http://localhost");
+    const pathname = url.pathname;
+
+    // ── Private Dashboard at /dashboard ──────────────────────────
+    if (pathname === "/dashboard" || pathname === "/dashboard/") {
+      const html = renderDashboardHtml(cfg, pluginDir);
+      res.statusCode = 200;
+      res.setHeader("Content-Type", "text/html; charset=utf-8");
+      res.end(html);
+      return true;
+    }
+
+    // ── Agent Feed ────────────────────────────────────────────────
+    if (pathname === "/feed/agent.json") {
+      const feed = buildAgentFeed(cfg);
+      const json = JSON.stringify(feed, null, 2);
+      res.statusCode = 200;
+      res.setHeader("Content-Type", "application/json; charset=utf-8");
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      res.end(json);
+      return true;
+    }
+
+    // ── Well-Known Discovery ───────────────────────────────────────
+    if (pathname === "/.well-known/pressclaw.json") {
+      const wellKnown = buildWellKnown(cfg);
+      const json = JSON.stringify(wellKnown, null, 2);
+      res.statusCode = 200;
+      res.setHeader("Content-Type", "application/json; charset=utf-8");
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      res.end(json);
+      return true;
+    }
+
+    // ── Public blog ──────────────────────────────────────────────
+    if (!pathname.startsWith(cfg.publicPath)) return false;
+
+    if (pathname === cfg.publicPath || pathname === `${cfg.publicPath}/`) {
+      sendFile(res, path.join(cfg.outputDir, "index.html"), "text/html; charset=utf-8");
+      return true;
+    }
+    if (pathname === `${cfg.publicPath}/rss.xml`) {
+      sendFile(res, path.join(cfg.outputDir, "rss.xml"), "application/rss+xml; charset=utf-8");
+      return true;
+    }
+
+    const slug = pathname.replace(`${cfg.publicPath}/`, "");
+    const file = path.join(cfg.outputDir, "posts", `${slug}.html`);
+    sendFile(res, file, "text/html; charset=utf-8");
+    return true;
+  });
+}
+
+// ── Private Dashboard Renderer ────────────────────────────────────
+
+function renderDashboardHtml(cfg: any, pluginDir: string): string {
+  const files = listNotes(cfg.notesDir);
+  const topics = syncTopicStatus(cfg.notesDir, readTopics(cfg.notesDir));
+  const styleProfile = loadStyleProfile(cfg.notesDir);
+
+  const ideas = topics.filter((t: Topic) => t.status === "idea");
+  const drafted = topics.filter((t: Topic) => t.status === "drafted");
+  const refined = topics.filter((t: Topic) => t.status === "refined");
+  const published = topics.filter((t: Topic) => t.status === "published");
+
+  // Load named style profiles
+  const profilesDir = path.join(cfg.notesDir, ".style-profiles");
+  const namedProfiles: { name: string; voice: string; pieces: number; updated: string }[] = [];
+  if (fs.existsSync(profilesDir)) {
+    for (const pf of fs.readdirSync(profilesDir).filter((f: string) => f.endsWith(".json"))) {
+      try {
+        const p = JSON.parse(fs.readFileSync(path.join(profilesDir, pf), "utf8"));
+        namedProfiles.push({
+          name: p.name || pf.replace(/\.json$/, ""),
+          voice: p.voiceDescription || "",
+          pieces: p.analyzedPieces?.length || 0,
+          updated: p.updated || "—",
+        });
+      } catch {}
+    }
+  }
+
+  // Load test results per slug
+  const testResults: Record<string, { confidence: number; tested: string; topSuggestion: string; scores: Record<string, { score: number; sentiment: string }> }> = {};
+  const varsDir = path.join(cfg.notesDir, ".variations");
+  if (fs.existsSync(varsDir)) {
+    for (const d of fs.readdirSync(varsDir)) {
+      const trFile = path.join(varsDir, d, "_test-results.json");
+      if (fs.existsSync(trFile)) {
+        try {
+          const tr = JSON.parse(fs.readFileSync(trFile, "utf8"));
+          testResults[d] = {
+            confidence: tr.confidence,
+            tested: tr.tested,
+            topSuggestion: tr.topSuggestion || "",
+            scores: tr.scores || {},
+          };
+        } catch {}
+      }
+    }
+  }
+
+  // Load all feedback data
+  const allFeedback = loadAllFeedback(cfg.notesDir);
+  const feedbackBySlug: Record<string, FeedbackFile> = {};
+  for (const fb of allFeedback) feedbackBySlug[fb.slug] = fb;
+
+  // Gather note details
+  const noteDetails: { slug: string; title: string; status: string; confidence: number | null; variations: number; wordCount: number; tone: string | null; structure: string | null; topicStatus: string; testResult: typeof testResults[string] | null; styleMarkers: Record<string, any> | null; feedback: FeedbackFile | null }[] = [];
+  for (const f of files) {
+    const full = fs.readFileSync(path.join(cfg.notesDir, f), "utf8");
+    const { meta, body } = parseFrontMatter(full);
+    const slug = f.replace(/\.md$/, "");
+    const wc = body.split(/\s+/).filter((w: string) => w.length > 0).length;
+    const topic = topics.find((t: Topic) => t.slug === slug);
+    let sm: Record<string, any> | null = null;
+    if (meta.style_markers) {
+      try { sm = typeof meta.style_markers === "string" ? JSON.parse(meta.style_markers) : meta.style_markers; } catch {}
+    }
+    noteDetails.push({
+      slug,
+      title: meta.title || slug,
+      status: meta.status || "private",
+      confidence: meta.confidence ? parseFloat(meta.confidence) : null,
+      variations: _variationCount(cfg.notesDir, slug),
+      wordCount: wc,
+      tone: meta.tone || null,
+      structure: meta.structure || null,
+      topicStatus: topic?.status || "untracked",
+      testResult: testResults[slug] || null,
+      styleMarkers: sm,
+      feedback: feedbackBySlug[slug] || null,
+    });
+  }
+
+  const statusIcon = (s: string) => s === "public" ? "📢" : s === "refined" ? "✨" : "🔒";
+  const confBar = (c: number | null) => {
+    if (c === null || isNaN(c)) return '<span style="color:#a1a1aa">—</span>';
+    const pct = Math.round(c * 10);
+    const color = c >= 7 ? "#22c55e" : c >= 5 ? "#eab308" : "#ef4444";
+    return `<div style="display:inline-flex;align-items:center;gap:6px"><div style="width:60px;height:8px;background:#27272a;border-radius:4px;overflow:hidden"><div style="width:${pct}%;height:100%;background:${color};border-radius:4px"></div></div><span style="font-size:0.8em;color:#a1a1aa">${c}/10</span></div>`;
+  };
+
+  const noteRows = noteDetails
+    .sort((a, b) => {
+      const order: Record<string, number> = { public: 0, refined: 1, private: 2 };
+      return (order[a.status] ?? 3) - (order[b.status] ?? 3);
+    })
+    .map((n) => {
+      const testScores = n.testResult ? Object.entries(n.testResult.scores).map(([k, v]: [string, any]) => {
+        const emoji = v.score >= 7 ? "🟢" : v.score >= 5 ? "🟡" : "🔴";
+        return `${emoji}${v.score}`;
+      }).join(" ") : "";
+      const sm = n.styleMarkers;
+      const markersHtml = sm
+        ? `<span style="font-size:0.75em;color:#a1a1aa">${sm.avgSentenceLength}w/sent · ${sm.avgParagraphSentences}s/¶ · ${sm.readabilityScore} FK · ${sm.perspective}</span>`
+        : '<span style="color:#3f3f46;font-size:0.75em">—</span>';
+      const fbHtml = n.feedback
+        ? `<span style="font-size:0.95em;font-weight:600;color:${n.feedback.aggregate.avgScore >= 7 ? "#22c55e" : n.feedback.aggregate.avgScore >= 5 ? "#eab308" : "#ef4444"}">${n.feedback.aggregate.avgScore}/10</span><br><span style="font-size:0.75em;color:#71717a">${n.feedback.aggregate.totalViews}v · ${n.feedback.aggregate.totalLikes}♥ · ${n.feedback.aggregate.totalShares}↗</span>`
+        : '<span style="color:#3f3f46">—</span>';
+      const twitterEntry = n.feedback?.entries?.find((e) => e.platform === "twitter");
+      const engagementHtml = twitterEntry
+        ? `<br><span style="font-size:0.7em;color:#71717a" title="Last fetched engagement">📊 ${twitterEntry.metrics.views || 0}v · ${twitterEntry.metrics.likes || 0}♥ · ${twitterEntry.metrics.shares || 0}↗ · ${twitterEntry.metrics.comments || 0}💬</span>`
+        : "";
+      const twitterPosts = n.feedback?.tweets?.filter((t: any) => !t.platform || t.platform === "twitter") || [];
+      const tweetHtml = twitterPosts.length
+        ? `<a href="https://x.com/pressclawai/status/${twitterPosts[twitterPosts.length - 1].id}" target="_blank" style="text-decoration:none" title="Posted ${twitterPosts.length} tweet(s)">🐦 ${twitterPosts.length}</a>${engagementHtml}`
+        : '<span style="color:#3f3f46">—</span>';
+      const linkedinPosts = n.feedback?.tweets?.filter((t: any) => t.platform === "linkedin") || [];
+      const linkedinHtml = linkedinPosts.length
+        ? `<a href="https://www.linkedin.com/feed/update/${linkedinPosts[linkedinPosts.length - 1].id}" target="_blank" style="text-decoration:none" title="Posted ${linkedinPosts.length} LinkedIn post(s)">💼 ${linkedinPosts.length}</a>`
+        : '<span style="color:#3f3f46">—</span>';
+      return `<tr>
+      <td>${statusIcon(n.status)}</td>
+      <td><strong>${escapeHtml(n.title)}</strong><br><span style="color:#71717a;font-size:0.85em">${n.slug}</span>${n.testResult?.topSuggestion ? `<br><span style="color:#a1a1aa;font-size:0.8em;font-style:italic">💡 ${escapeHtml(n.testResult.topSuggestion.slice(0, 120))}${n.testResult.topSuggestion.length > 120 ? "…" : ""}</span>` : ""}</td>
+      <td>${n.status}</td>
+      <td>${n.wordCount}w</td>
+      <td>${n.tone || "—"}</td>
+      <td>${n.structure || "—"}</td>
+      <td>${markersHtml}</td>
+      <td>${n.variations > 0 ? n.variations + " vars" : "—"}</td>
+      <td>${fbHtml}</td>
+      <td>${tweetHtml}</td>
+      <td>${linkedinHtml}</td>
+      <td>${confBar(n.confidence)}${testScores ? `<br><span style="font-size:0.75em;color:#71717a">${testScores}</span>` : ""}</td>
+    </tr>`;
+    }).join("\n");
+
+  const ideaRows = ideas.map((t: Topic) => {
+    const tags = t.tags?.length ? t.tags.map((tg: string) => `<span style="background:#27272a;color:#a1a1aa;padding:1px 6px;border-radius:3px;font-size:0.8em">${escapeHtml(tg)}</span>`).join(" ") : "";
+    return `<tr><td style="color:#71717a;font-size:0.85em">${t.id}</td><td>${escapeHtml(t.title)}</td><td>${tags}</td><td style="color:#71717a">${t.added}</td></tr>`;
+  }).join("\n");
+
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <title>Dashboard — ${cfg.siteTitle}</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <style>
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', system-ui, sans-serif; background: #0a0a0a; color: #e4e4e7; max-width: 960px; margin: 0 auto; padding: 32px 24px; line-height: 1.6; }
+    h1 { font-size: 1.6em; margin-bottom: 8px; color: #fafafa; }
+    h2 { font-size: 1.2em; margin: 32px 0 12px; color: #a1a1aa; font-weight: 500; border-bottom: 1px solid #27272a; padding-bottom: 6px; }
+    .stats { display: flex; gap: 16px; margin: 16px 0 24px; flex-wrap: wrap; }
+    .stat { background: #18181b; border: 1px solid #27272a; border-radius: 8px; padding: 12px 20px; min-width: 100px; }
+    .stat .num { font-size: 1.8em; font-weight: 700; color: #fafafa; }
+    .stat .label { font-size: 0.8em; color: #71717a; }
+    .style-box { background: #18181b; border: 1px solid #27272a; border-radius: 8px; padding: 16px 20px; margin: 12px 0; }
+    .style-box .voice { font-style: italic; color: #d4d4d8; margin: 8px 0; }
+    .style-box .avoid { color: #f87171; font-size: 0.9em; }
+    table { width: 100%; border-collapse: collapse; margin: 8px 0; }
+    th { text-align: left; color: #71717a; font-size: 0.8em; font-weight: 500; padding: 6px 8px; border-bottom: 1px solid #27272a; }
+    td { padding: 8px; border-bottom: 1px solid #1a1a1e; vertical-align: top; font-size: 0.9em; }
+    tr:hover { background: #18181b; }
+    .footer { margin-top: 48px; padding-top: 16px; border-top: 1px solid #27272a; color: #52525b; font-size: 0.8em; }
+    a { color: #60a5fa; text-decoration: none; }
+    a:hover { text-decoration: underline; }
+  </style>
+</head>
+<body>
+  <h1>📊 ${escapeHtml(cfg.siteTitle)} — Dashboard</h1>
+  <p style="color:#71717a;margin-bottom:8px">Private pipeline view · <a href="${cfg.publicPath}">Public blog →</a></p>
+
+  <div class="stats">
+    <div class="stat"><div class="num">${published.length}</div><div class="label">📢 Published</div></div>
+    <div class="stat"><div class="num">${refined.length}</div><div class="label">✨ Refined</div></div>
+    <div class="stat"><div class="num">${drafted.length}</div><div class="label">📝 Drafted</div></div>
+    <div class="stat"><div class="num">${ideas.length}</div><div class="label">💡 Ideas</div></div>
+    <div class="stat"><div class="num">${files.length}</div><div class="label">📄 Files</div></div>
+  </div>
+
+  ${styleProfile ? `
+  <h2>🎨 Style Profile</h2>
+  <div class="style-box">
+    <div class="voice">"${escapeHtml(styleProfile.voiceDescription)}"</div>
+    <div style="margin-top:8px;font-size:0.85em;color:#a1a1aa">
+      Analyzed ${styleProfile.analyzedNotes.length} notes · Updated ${styleProfile.updated}
+    </div>
+    ${styleProfile.avoid?.length ? `<div class="avoid" style="margin-top:6px">Avoid: ${styleProfile.avoid.map((a: string) => escapeHtml(a)).join(", ")}</div>` : ""}
+  </div>
+  ` : `<h2>🎨 Style Profile</h2><p style="color:#71717a">No style profile yet. Run <code>openclaw notes style</code> to create one.</p>`}
+
+  ${namedProfiles.length > 0 ? `
+  <h2>🎭 Voice Personas (${namedProfiles.length})</h2>
+  <div style="display:flex;gap:12px;flex-wrap:wrap">
+    ${namedProfiles.map((p) => `
+    <div class="style-box" style="flex:1;min-width:280px">
+      <div style="font-weight:600;color:#fafafa;margin-bottom:4px">${escapeHtml(p.name)}</div>
+      <div class="voice" style="font-size:0.85em">"${escapeHtml(p.voice.slice(0, 200))}${p.voice.length > 200 ? "…" : ""}"</div>
+      <div style="font-size:0.8em;color:#52525b;margin-top:6px">${p.pieces} pieces analyzed · ${p.updated}</div>
+    </div>`).join("")}
+  </div>
+  ` : ""}
+
+  <h2>📝 Notes Pipeline</h2>
+  <table>
+    <thead><tr><th></th><th>Title</th><th>Status</th><th>Words</th><th>Tone</th><th>Structure</th><th>Style DNA</th><th>Vars</th><th>Score</th><th>🐦</th><th>💼</th><th>Confidence</th></tr></thead>
+    <tbody>${noteRows}</tbody>
+  </table>
+
+  ${_renderEvolutionHtml(styleProfile)}
+
+  ${_renderPerformanceHtml(cfg.notesDir, allFeedback, noteDetails)}
+
+  ${_renderAgentFeedHtml(cfg)}
+
+  ${ideas.length > 0 ? `
+  <h2>💡 Topic Backlog (${ideas.length})</h2>
+  <table>
+    <thead><tr><th>ID</th><th>Title</th><th>Tags</th><th>Added</th></tr></thead>
+    <tbody>${ideaRows}</tbody>
+  </table>
+  ` : ""}
+
+  <div class="footer">
+    Generated ${new Date().toISOString()} · <a href="${cfg.publicPath}/rss.xml">RSS</a> · <a href="/feed/agent.json">Agent Feed</a>
+  </div>
+</body>
+</html>`;
+}
+
+// ── Dashboard helpers (outside register) ──────────────────────────
+
+function _renderAgentFeedHtml(cfg: any): string {
+  const subs = readSubscriptions(cfg.notesDir);
+  const feedUrl = cfg.baseUrl ? `${cfg.baseUrl}/feed/agent.json` : "/feed/agent.json";
+  const wellKnownUrl = cfg.baseUrl ? `${cfg.baseUrl}/.well-known/pressclaw.json` : "/.well-known/pressclaw.json";
+
+  // Read last digest date from subscriptions
+  let lastDigest = "never";
+  for (const sub of subs) {
+    if (sub.last_checked && (lastDigest === "never" || sub.last_checked > lastDigest)) {
+      lastDigest = sub.last_checked;
+    }
+  }
+
+  const subRows = subs.length > 0 ? subs.map((s) => {
+    const checked = s.last_checked ? new Date(s.last_checked).toISOString().slice(0, 16).replace("T", " ") : "never";
+    return `<tr><td>${escapeHtml(s.name)}</td><td><a href="${escapeHtml(s.url)}">${escapeHtml(s.url)}</a></td><td>${checked}</td></tr>`;
+  }).join("\n") : `<tr><td colspan="3" style="color:#52525b">No subscriptions yet. Run: <code>openclaw notes subscribe &lt;url&gt;</code></td></tr>`;
+
+  return `
+  <h2>📡 Agent Feed</h2>
+  <div class="style-box">
+    <div style="display:flex;gap:24px;flex-wrap:wrap;margin-bottom:12px">
+      <div><span style="color:#71717a;font-size:0.8em">Feed URL</span><br><a href="${escapeHtml(feedUrl)}" style="font-size:0.9em">${escapeHtml(feedUrl)}</a></div>
+      <div><span style="color:#71717a;font-size:0.8em">Discovery</span><br><a href="${escapeHtml(wellKnownUrl)}" style="font-size:0.9em">.well-known/pressclaw.json</a></div>
+      <div><span style="color:#71717a;font-size:0.8em">Subscriptions</span><br><span style="font-size:1.2em;font-weight:600">${subs.length}</span></div>
+      <div><span style="color:#71717a;font-size:0.8em">Last Digest</span><br><span style="font-size:0.9em">${lastDigest === "never" ? "never" : new Date(lastDigest).toISOString().slice(0, 16).replace("T", " ")}</span></div>
+    </div>
+    ${subs.length > 0 ? `
+    <table style="margin-top:8px">
+      <thead><tr><th>Name</th><th>URL</th><th>Last Checked</th></tr></thead>
+      <tbody>${subRows}</tbody>
+    </table>` : ""}
+  </div>`;
+}
+
+function _renderEvolutionHtml(styleProfile: any): string {
+  if (!styleProfile?.evolution?.length || styleProfile.evolution.length < 2) return "";
+
+  const evo = styleProfile.evolution;
+  const latest = evo[evo.length - 1];
+  const first = evo[0];
+  const slDelta = (latest.avgSentenceLength - first.avgSentenceLength).toFixed(1);
+  const wcDelta = Math.round(latest.avgWordCount - first.avgWordCount);
+  const rdDelta = Math.round(latest.avgReadability - first.avgReadability);
+  const slArrow = Number(slDelta) > 0 ? "↑" : Number(slDelta) < 0 ? "↓" : "→";
+  const wcArrow = wcDelta > 0 ? "↑" : wcDelta < 0 ? "↓" : "→";
+  const rdArrow = rdDelta > 0 ? "↑" : rdDelta < 0 ? "↓" : "→";
+  const slColor = Number(slDelta) === 0 ? "#71717a" : "#60a5fa";
+  const wcColor = wcDelta === 0 ? "#71717a" : "#60a5fa";
+  const rdColor = rdDelta === 0 ? "#71717a" : "#60a5fa";
+
+  // Mini sparkline bars
+  const maxWc = Math.max(...evo.map((e: any) => e.avgWordCount || 0));
+  const recentEvo = evo.slice(-10);
+  const sparkBars = recentEvo.map((e: any) => {
+    const pct = maxWc > 0 ? Math.round(((e.avgWordCount || 0) / maxWc) * 100) : 0;
+    const h = Math.max(4, pct * 0.4);
+    return '<div style="width:8px;height:' + h + 'px;background:#60a5fa;border-radius:2px" title="' + e.date + ': ' + Math.round(e.avgWordCount) + 'w"></div>';
+  }).join("");
+
+  return '<h2>📈 Style Evolution</h2>\n<div class="style-box">' +
+    '<div style="display:flex;gap:24px;flex-wrap:wrap;margin-bottom:12px">' +
+    '<div><span style="color:#71717a;font-size:0.8em">Sentence length</span><br><span style="font-size:1.2em;font-weight:600">' + latest.avgSentenceLength + 'w</span> <span style="font-size:0.8em;color:' + slColor + '">' + slArrow + slDelta + '</span></div>' +
+    '<div><span style="color:#71717a;font-size:0.8em">Avg word count</span><br><span style="font-size:1.2em;font-weight:600">' + Math.round(latest.avgWordCount) + '</span> <span style="font-size:0.8em;color:' + wcColor + '">' + wcArrow + wcDelta + '</span></div>' +
+    '<div><span style="color:#71717a;font-size:0.8em">Readability</span><br><span style="font-size:1.2em;font-weight:600">' + latest.avgReadability + '/100</span> <span style="font-size:0.8em;color:' + rdColor + '">' + rdArrow + rdDelta + '</span></div>' +
+    '<div><span style="color:#71717a;font-size:0.8em">Notes analyzed</span><br><span style="font-size:1.2em;font-weight:600">' + latest.noteCount + '</span></div>' +
+    '</div>' +
+    '<div style="display:flex;align-items:end;gap:3px;height:24px">' + sparkBars + '</div>' +
+    '<div style="font-size:0.75em;color:#52525b;margin-top:4px">Word count trend (last ' + recentEvo.length + ' snapshots) · First: ' + first.date + ' · Latest: ' + latest.date + '</div>' +
+    '</div>';
+}
+
+function _renderPerformanceHtml(notesDir: string, allFeedback: FeedbackFile[], noteDetails: { slug: string; title: string; tone: string | null; structure: string | null; feedback: FeedbackFile | null; styleMarkers: Record<string, any> | null }[]): string {
+  if (allFeedback.length === 0) return "";
+
+  // Top performers
+  const withFeedback = noteDetails.filter((n) => n.feedback && n.feedback.aggregate.entries > 0);
+  if (withFeedback.length === 0) return "";
+
+  const topPerformers = [...withFeedback]
+    .sort((a, b) => (b.feedback!.aggregate.avgScore) - (a.feedback!.aggregate.avgScore))
+    .slice(0, 5);
+
+  const topRows = topPerformers.map((n) => {
+    const fb = n.feedback!;
+    const scoreColor = fb.aggregate.avgScore >= 7 ? "#22c55e" : fb.aggregate.avgScore >= 5 ? "#eab308" : "#ef4444";
+    return `<tr>
+      <td style="font-weight:600;color:${scoreColor}">${fb.aggregate.avgScore}/10</td>
+      <td><strong>${escapeHtml(n.title)}</strong><br><span style="color:#71717a;font-size:0.85em">${n.slug}</span></td>
+      <td>${fb.aggregate.totalViews}</td>
+      <td>${fb.aggregate.totalLikes}</td>
+      <td>${fb.aggregate.totalShares}</td>
+      <td>${fb.aggregate.entries}</td>
+    </tr>`;
+  }).join("\n");
+
+  // Style correlation summary
+  const correlations: string[] = [];
+
+  // Tone correlation
+  const toneGroups: Record<string, { total: number; count: number }> = {};
+  for (const n of withFeedback) {
+    if (!n.tone) continue;
+    if (!toneGroups[n.tone]) toneGroups[n.tone] = { total: 0, count: 0 };
+    toneGroups[n.tone].total += n.feedback!.aggregate.avgScore;
+    toneGroups[n.tone].count += 1;
+  }
+  const toneEntries = Object.entries(toneGroups).map(([k, v]) => ({ tone: k, avg: Math.round((v.total / v.count) * 10) / 10 })).sort((a, b) => b.avg - a.avg);
+  if (toneEntries.length >= 2) {
+    correlations.push(`🎭 <strong>${escapeHtml(toneEntries[0].tone)}</strong> tone scores ${toneEntries[0].avg} avg vs <strong>${escapeHtml(toneEntries[toneEntries.length - 1].tone)}</strong> at ${toneEntries[toneEntries.length - 1].avg}`);
+  }
+
+  // Structure correlation
+  const structGroups: Record<string, { total: number; count: number }> = {};
+  for (const n of withFeedback) {
+    if (!n.structure) continue;
+    if (!structGroups[n.structure]) structGroups[n.structure] = { total: 0, count: 0 };
+    structGroups[n.structure].total += n.feedback!.aggregate.avgScore;
+    structGroups[n.structure].count += 1;
+  }
+  const structEntries = Object.entries(structGroups).map(([k, v]) => ({ structure: k, avg: Math.round((v.total / v.count) * 10) / 10 })).sort((a, b) => b.avg - a.avg);
+  if (structEntries.length >= 2) {
+    const delta = Math.round((structEntries[0].avg - structEntries[structEntries.length - 1].avg) * 10) / 10;
+    correlations.push(`🏗️ <strong>${escapeHtml(structEntries[0].structure)}</strong> structure scores ${delta} points higher than <strong>${escapeHtml(structEntries[structEntries.length - 1].structure)}</strong>`);
+  }
+
+  // Sentence length correlation
+  const withMarkers = withFeedback.filter((n) => n.styleMarkers?.avgSentenceLength);
+  if (withMarkers.length >= 2) {
+    const sorted = [...withMarkers].sort((a, b) => a.feedback!.aggregate.avgScore - b.feedback!.aggregate.avgScore);
+    const topHalf = sorted.slice(Math.floor(sorted.length / 2));
+    const bottomHalf = sorted.slice(0, Math.floor(sorted.length / 2));
+    if (topHalf.length > 0 && bottomHalf.length > 0) {
+      const topSL = Math.round(topHalf.reduce((s, n) => s + n.styleMarkers!.avgSentenceLength, 0) / topHalf.length * 10) / 10;
+      const botSL = Math.round(bottomHalf.reduce((s, n) => s + n.styleMarkers!.avgSentenceLength, 0) / bottomHalf.length * 10) / 10;
+      correlations.push(`📏 Top-rated posts avg <strong>${topSL}</strong> words/sentence (vs ${botSL} for lowest)`);
+    }
+  }
+
+  // Platform comparison
+  const platformMetrics: Record<string, { shares: number; count: number }> = {};
+  for (const fb of allFeedback) {
+    for (const e of fb.entries) {
+      if (!e.platform) continue;
+      if (!platformMetrics[e.platform]) platformMetrics[e.platform] = { shares: 0, count: 0 };
+      platformMetrics[e.platform].shares += e.metrics.shares || 0;
+      platformMetrics[e.platform].count += 1;
+    }
+  }
+  const platEntries = Object.entries(platformMetrics).filter(([, pm]) => pm.count > 0).map(([p, pm]) => ({ platform: p, avgShares: Math.round(pm.shares / pm.count * 10) / 10 })).sort((a, b) => b.avgShares - a.avgShares);
+  if (platEntries.length >= 2 && platEntries[platEntries.length - 1].avgShares > 0) {
+    const ratio = Math.round(platEntries[0].avgShares / platEntries[platEntries.length - 1].avgShares * 10) / 10;
+    correlations.push(`🌐 <strong>${escapeHtml(platEntries[0].platform)}</strong> gets ${ratio}x more shares than ${escapeHtml(platEntries[platEntries.length - 1].platform)}`);
+  }
+
+  const corrHtml = correlations.length > 0
+    ? `<div class="style-box" style="margin-top:12px"><div style="font-size:0.85em;color:#a1a1aa;margin-bottom:8px">Style Correlations</div>${correlations.map((c) => `<div style="margin:4px 0;font-size:0.9em">${c}</div>`).join("")}</div>`
+    : "";
+
+  return `<h2>📈 Performance (${withFeedback.length} notes tracked)</h2>
+  <table>
+    <thead><tr><th>Score</th><th>Title</th><th>Views</th><th>Likes</th><th>Shares</th><th>Entries</th></tr></thead>
+    <tbody>${topRows}</tbody>
+  </table>
+  ${corrHtml}`;
+}
+
+function _noteConfidence(notesDir: string, slug: string | null | undefined): number | null {
+  if (!slug) return null;
+  const file = path.join(notesDir, `${slug}.md`);
+  if (!fs.existsSync(file)) return null;
+  const { meta } = parseFrontMatter(fs.readFileSync(file, "utf8"));
+  const c = parseFloat(meta.confidence);
+  return isNaN(c) ? null : c;
+}
+
+function _variationCount(notesDir: string, slug: string | null | undefined): number {
+  if (!slug) return 0;
+  const manifest = loadManifest(notesDir, slug);
+  return manifest?.variations?.length || 0;
+}