autocrew 0.1.0

package/src/modules/learnings/diff-tracker.ts

@@ -0,0 +1,189 @@
+/**
+ * Diff Tracker — records before/after diffs when users edit content
+ *
+ * Stores diffs in ~/.autocrew/learnings/edits/ as JSON files.
+ * Each diff captures: contentId, field changed, before/after text, timestamp.
+ * These diffs feed into the Rule Distiller for pattern recognition.
+ */
+import fs from "node:fs/promises";
+import path from "node:path";
+
+export interface EditDiff {
+  id: string;
+  contentId: string;
+  field: "body" | "title" | "hashtags" | "other";
+  before: string;
+  after: string;
+  /** What specifically changed — short description */
+  changeType?: string;
+  /** Detected patterns in this edit */
+  patterns: string[];
+  createdAt: string;
+}
+
+export interface DiffAnalysis {
+  /** Detected edit patterns */
+  patterns: string[];
+  /** Short human-readable summary */
+  summary: string;
+}
+
+function getDataDir(customDir?: string): string {
+  if (customDir) return customDir;
+  const home = process.env.HOME || process.env.USERPROFILE || "~";
+  return path.join(home, ".autocrew");
+}
+
+async function editsDir(dataDir?: string): Promise<string> {
+  const dir = path.join(getDataDir(dataDir), "learnings", "edits");
+  await fs.mkdir(dir, { recursive: true });
+  return dir;
+}
+
+/**
+ * Record a content edit diff.
+ */
+export async function recordDiff(
+  contentId: string,
+  field: EditDiff["field"],
+  before: string,
+  after: string,
+  dataDir?: string,
+): Promise<EditDiff> {
+  const dir = await editsDir(dataDir);
+  const id = `diff-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const patterns = detectPatterns(before, after);
+
+  const diff: EditDiff = {
+    id,
+    contentId,
+    field,
+    before: before.slice(0, 2000),
+    after: after.slice(0, 2000),
+    patterns,
+    createdAt: new Date().toISOString(),
+  };
+
+  await fs.writeFile(path.join(dir, `${id}.json`), JSON.stringify(diff, null, 2), "utf-8");
+  return diff;
+}
+
+/**
+ * List all recorded diffs, optionally filtered by contentId.
+ */
+export async function listDiffs(
+  opts?: { contentId?: string; limit?: number },
+  dataDir?: string,
+): Promise<EditDiff[]> {
+  const dir = await editsDir(dataDir);
+  let files: string[];
+  try {
+    files = await fs.readdir(dir);
+  } catch {
+    return [];
+  }
+
+  const diffs: EditDiff[] = [];
+  for (const f of files) {
+    if (!f.endsWith(".json")) continue;
+    try {
+      const raw = await fs.readFile(path.join(dir, f), "utf-8");
+      const diff: EditDiff = JSON.parse(raw);
+      if (opts?.contentId && diff.contentId !== opts.contentId) continue;
+      diffs.push(diff);
+    } catch {
+      /* skip corrupted files */
+    }
+  }
+
+  diffs.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+  if (opts?.limit) return diffs.slice(0, opts.limit);
+  return diffs;
+}
+
+/**
+ * Analyze a before/after pair to detect common edit patterns.
+ */
+export function detectPatterns(before: string, after: string): string[] {
+  const patterns: string[] = [];
+
+  // Pattern: removed progression words (首先/其次/最后)
+  const progressionBefore = (before.match(/首先|其次|最后|第一|第二|第三/g) || []).length;
+  const progressionAfter = (after.match(/首先|其次|最后|第一|第二|第三/g) || []).length;
+  if (progressionBefore > progressionAfter && progressionBefore - progressionAfter >= 2) {
+    patterns.push("remove_progression_words");
+  }
+
+  // Pattern: shortened paragraphs
+  const parasBefore = before.split(/\n{2,}/).filter((p) => p.trim());
+  const parasAfter = after.split(/\n{2,}/).filter((p) => p.trim());
+  if (parasAfter.length > parasBefore.length && after.length <= before.length) {
+    patterns.push("break_long_paragraphs");
+  }
+
+  // Pattern: removed AI-style phrases
+  const aiPhrases = /值得一提的是|需要注意的是|综上所述|总而言之|总的来说|可以说|毫不夸张地说|赋能|助力|打通|闭环|深度|全方位|多维度/g;
+  const aiBefore = (before.match(aiPhrases) || []).length;
+  const aiAfter = (after.match(aiPhrases) || []).length;
+  if (aiBefore > aiAfter && aiBefore - aiAfter >= 2) {
+    patterns.push("remove_ai_phrases");
+  }
+
+  // Pattern: added colloquial expressions
+  const colloquial = /说白了|你想啊|问题来了|讲真|说实话|老实说|不瞒你说|坦白讲/g;
+  const collBefore = (before.match(colloquial) || []).length;
+  const collAfter = (after.match(colloquial) || []).length;
+  if (collAfter > collBefore) {
+    patterns.push("add_colloquial_tone");
+  }
+
+  // Pattern: reduced "我们" usage
+  const weBefore = (before.match(/我们/g) || []).length;
+  const weAfter = (after.match(/我们/g) || []).length;
+  if (weBefore > weAfter && weBefore - weAfter >= 2) {
+    patterns.push("reduce_we_pronoun");
+  }
+
+  // Pattern: shortened overall length
+  if (after.length < before.length * 0.8) {
+    patterns.push("shorten_content");
+  }
+
+  // Pattern: added emoji
+  const emojiBefore = (before.match(/[\u{1F300}-\u{1F9FF}]/gu) || []).length;
+  const emojiAfter = (after.match(/[\u{1F300}-\u{1F9FF}]/gu) || []).length;
+  if (emojiAfter > emojiBefore + 2) {
+    patterns.push("add_emoji");
+  }
+
+  // Pattern: replaced formal words with casual
+  const formalWords = /因此|然而|此外|尽管|虽然|但是|不过/g;
+  const formalBefore = (before.match(formalWords) || []).length;
+  const formalAfter = (after.match(formalWords) || []).length;
+  if (formalBefore > formalAfter && formalBefore - formalAfter >= 2) {
+    patterns.push("casualize_tone");
+  }
+
+  return patterns;
+}
+
+/**
+ * Get pattern frequency across all diffs.
+ * Returns patterns sorted by frequency (most common first).
+ */
+export async function getPatternFrequency(
+  dataDir?: string,
+): Promise<Array<{ pattern: string; count: number }>> {
+  const diffs = await listDiffs(undefined, dataDir);
+  const freq = new Map<string, number>();
+
+  for (const diff of diffs) {
+    for (const p of diff.patterns) {
+      freq.set(p, (freq.get(p) || 0) + 1);
+    }
+  }
+
+  return Array.from(freq.entries())
+    .map(([pattern, count]) => ({ pattern, count }))
+    .sort((a, b) => b.count - a.count);
+}

package/src/modules/learnings/rule-distiller.ts

@@ -0,0 +1,141 @@
+/**
+ * Rule Distiller — automatically extracts writing rules from accumulated edit patterns
+ *
+ * When a pattern appears 5+ times in user edits, it gets distilled into a
+ * WritingRule and written to creator-profile.json.
+ *
+ * PRD §7: "累积 5+ 次同类修改后，自动提炼为规则"
+ */
+import { getPatternFrequency } from "./diff-tracker.js";
+import {
+  loadProfile,
+  addWritingRule,
+  type WritingRule,
+} from "../profile/creator-profile.js";
+
+export interface DistillResult {
+  /** Number of new rules distilled this run */
+  newRulesCount: number;
+  /** The new rules that were added */
+  newRules: WritingRule[];
+  /** Patterns that are close to threshold (3-4 occurrences) */
+  emerging: Array<{ pattern: string; count: number; remaining: number }>;
+  /** Summary for display */
+  summary: string;
+}
+
+/** Minimum occurrences before a pattern becomes a rule */
+const DISTILL_THRESHOLD = 5;
+
+/** Map pattern IDs to human-readable rule descriptions */
+const PATTERN_TO_RULE: Record<string, string> = {
+  remove_progression_words: "禁用顺序词（首先/其次/最后/第一/第二/第三）",
+  break_long_paragraphs: "长段落拆分为短段落，每段不超过 3-4 行",
+  remove_ai_phrases: "删除 AI 味套话（值得一提、综上所述、赋能、闭环等）",
+  add_colloquial_tone: "适当加入口语化表达（说白了、讲真、你想啊）",
+  reduce_we_pronoun: '减少"我们"开头，多用"你"拉近距离',
+  shorten_content: "精简内容，删除冗余信息",
+  add_emoji: "适当使用 emoji 增加可读性",
+  casualize_tone: "用口语化词汇替代书面语（因此→所以，然而→但是）",
+};
+
+/**
+ * Run the distillation process:
+ * 1. Get pattern frequencies from diff tracker
+ * 2. Check which patterns have reached the threshold
+ * 3. Skip patterns that already have corresponding rules
+ * 4. Add new rules to creator-profile.json
+ */
+export async function distillRules(dataDir?: string): Promise<DistillResult> {
+  const frequencies = await getPatternFrequency(dataDir);
+  const profile = await loadProfile(dataDir);
+  const existingRules = profile?.writingRules || [];
+
+  const newRules: WritingRule[] = [];
+  const emerging: DistillResult["emerging"] = [];
+
+  for (const { pattern, count } of frequencies) {
+    const ruleText = PATTERN_TO_RULE[pattern];
+    if (!ruleText) continue; // Unknown pattern, skip
+
+    // Check if rule already exists
+    const alreadyExists = existingRules.some(
+      (r) => r.rule === ruleText || r.rule.includes(pattern),
+    );
+    if (alreadyExists) continue;
+
+    if (count >= DISTILL_THRESHOLD) {
+      // Distill into a rule
+      const confidence = Math.min(0.95, 0.5 + count * 0.05);
+      const rule = await addWritingRule(
+        { rule: ruleText, source: "auto_distilled", confidence },
+        dataDir,
+      );
+      const addedRule = rule.writingRules[rule.writingRules.length - 1];
+      newRules.push(addedRule);
+    } else if (count >= 3) {
+      // Emerging pattern — close to threshold
+      emerging.push({
+        pattern,
+        count,
+        remaining: DISTILL_THRESHOLD - count,
+      });
+    }
+  }
+
+  const summary = buildSummary(newRules, emerging);
+  return {
+    newRulesCount: newRules.length,
+    newRules,
+    emerging,
+    summary,
+  };
+}
+
+/**
+ * Check if distillation should run (called after each content edit).
+ * Returns true if there are patterns at or above threshold that haven't been distilled.
+ */
+export async function shouldDistill(dataDir?: string): Promise<boolean> {
+  const frequencies = await getPatternFrequency(dataDir);
+  const profile = await loadProfile(dataDir);
+  const existingRules = profile?.writingRules || [];
+
+  for (const { pattern, count } of frequencies) {
+    if (count < DISTILL_THRESHOLD) continue;
+    const ruleText = PATTERN_TO_RULE[pattern];
+    if (!ruleText) continue;
+    const alreadyExists = existingRules.some(
+      (r) => r.rule === ruleText || r.rule.includes(pattern),
+    );
+    if (!alreadyExists) return true;
+  }
+  return false;
+}
+
+function buildSummary(
+  newRules: WritingRule[],
+  emerging: DistillResult["emerging"],
+): string {
+  const parts: string[] = [];
+
+  if (newRules.length > 0) {
+    parts.push(`🎯 提炼了 ${newRules.length} 条新规则：`);
+    for (const r of newRules) {
+      parts.push(`  - ${r.rule}（置信度 ${r.confidence}）`);
+    }
+  }
+
+  if (emerging.length > 0) {
+    parts.push(`📊 接近提炼阈值的模式：`);
+    for (const e of emerging) {
+      parts.push(`  - ${PATTERN_TO_RULE[e.pattern] || e.pattern}（还差 ${e.remaining} 次）`);
+    }
+  }
+
+  if (parts.length === 0) {
+    return "暂无可提炼的规则";
+  }
+
+  return parts.join("\n");
+}

package/src/modules/memory/distill.ts

@@ -0,0 +1,208 @@
+import path from "node:path";
+import os from "node:os";
+import fs from "node:fs/promises";
+
+export type MemorySignalType =
+  | "approval"
+  | "rejection"
+  | "edit"
+  | "performance"
+  | "general";
+
+export interface DistillMemoryOptions {
+  signalType: MemorySignalType;
+  feedback?: string;
+  originalText?: string;
+  modifiedText?: string;
+  contentTitle?: string;
+  platform?: string;
+  dataDir?: string;
+}
+
+export interface DistillMemoryResult {
+  ok: boolean;
+  section: string;
+  learning: string;
+  memoryPath: string;
+  archivePath: string;
+}
+
+const MEMORY_TEMPLATE = `# AutoCrew Memory
+
+## Brand Context
+
+## Writing Preferences
+
+## Content Edit Preferences
+
+## Performance Insights
+`;
+
+function resolveDataDir(customDir?: string): string {
+  if (customDir) return customDir;
+  return path.join(os.homedir(), ".autocrew");
+}
+
+async function ensureMemoryFiles(dataDir?: string) {
+  const root = resolveDataDir(dataDir);
+  const memoryPath = path.join(root, "MEMORY.md");
+  const archiveDir = path.join(root, "memory");
+  await fs.mkdir(archiveDir, { recursive: true });
+  try {
+    await fs.access(memoryPath);
+  } catch {
+    await fs.writeFile(memoryPath, MEMORY_TEMPLATE, "utf-8");
+  }
+  return { root, memoryPath, archiveDir };
+}
+
+function today(): string {
+  return new Date().toISOString().slice(0, 10);
+}
+
+function inferFromFeedback(feedback: string): { section: string; learning: string } | null {
+  const normalized = feedback.trim();
+  if (!normalized) return null;
+
+  if (/口语|人话|自然|书面腔|太正式/.test(normalized)) {
+    return {
+      section: "Writing Preferences",
+      learning: "写作偏好更口语、更自然，减少书面腔和过度正式表达",
+    };
+  }
+  if (/短一点|精简|短句|更直接|删掉废话/.test(normalized)) {
+    return {
+      section: "Content Edit Preferences",
+      learning: "用户偏好更短句、更直接的表达，减少铺陈和废话",
+    };
+  }
+  if (/emoji|表情/.test(normalized)) {
+    return {
+      section: "Writing Preferences",
+      learning: "用户对 emoji 使用有明确偏好，后续需要按平台控制频率和位置",
+    };
+  }
+  if (/标题|hook|开头|前3秒/.test(normalized)) {
+    return {
+      section: "Content Edit Preferences",
+      learning: "用户对标题和开头钩子更敏感，后续应优先优化停留感和首屏表达",
+    };
+  }
+  if (/爆|点赞|收藏|转化|播放|点击率/.test(normalized)) {
+    return {
+      section: "Performance Insights",
+      learning: normalized,
+    };
+  }
+
+  return {
+    section: "Content Edit Preferences",
+    learning: normalized,
+  };
+}
+
+function inferFromEdit(originalText: string, modifiedText: string): { section: string; learning: string } {
+  const originalLength = originalText.length;
+  const modifiedLength = modifiedText.length;
+  if (modifiedLength < originalLength * 0.8) {
+    return {
+      section: "Content Edit Preferences",
+      learning: "用户修改时明显压缩篇幅，偏好更短、更狠、更直接的表达",
+    };
+  }
+
+  if (/口语|你|我|问题来了|说白了/.test(modifiedText) && !/口语|你|我|问题来了|说白了/.test(originalText)) {
+    return {
+      section: "Writing Preferences",
+      learning: "用户会主动把稿子改得更口语、更像当面说话",
+    };
+  }
+
+  return {
+    section: "Content Edit Preferences",
+    learning: "用户对草稿做了实质修改，后续应优先参考最近一次改稿方向",
+  };
+}
+
+function buildLearning(options: DistillMemoryOptions): { section: string; learning: string } {
+  if (options.signalType === "edit" && options.originalText && options.modifiedText) {
+    return inferFromEdit(options.originalText, options.modifiedText);
+  }
+
+  if (options.feedback) {
+    const inferred = inferFromFeedback(options.feedback);
+    if (inferred) return inferred;
+  }
+
+  switch (options.signalType) {
+    case "approval":
+      return {
+        section: "Performance Insights",
+        learning: `用户确认了${options.platform ? `${options.platform} ` : ""}方向，当前表达方式可继续复用`,
+      };
+    case "rejection":
+      return {
+        section: "Content Edit Preferences",
+        learning: `用户拒绝了当前${options.platform ? `${options.platform} ` : ""}稿件方向，后续需要先重做角度而不是只润色句子`,
+      };
+    case "performance":
+      return {
+        section: "Performance Insights",
+        learning: options.feedback || "记录了一条新的内容表现反馈",
+      };
+    default:
+      return {
+        section: "Content Edit Preferences",
+        learning: options.feedback || "记录了一条新的用户反馈",
+      };
+  }
+}
+
+function appendLearningToSection(memoryContent: string, section: string, learning: string): string {
+  const marker = `## ${section}`;
+  const entry = `- [${today()}] ${learning}`;
+  if (!memoryContent.includes(marker)) {
+    return `${memoryContent.trim()}\n\n${marker}\n\n${entry}\n`;
+  }
+
+  const existingEntryPattern = new RegExp(`^- \\[\\d{4}-\\d{2}-\\d{2}\\] ${learning.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`, "m");
+  if (existingEntryPattern.test(memoryContent)) {
+    return memoryContent;
+  }
+
+  const start = memoryContent.indexOf(marker) + marker.length;
+  const nextSectionIndex = memoryContent.indexOf("\n## ", start);
+  if (nextSectionIndex === -1) {
+    return `${memoryContent.trimEnd()}\n\n${entry}\n`;
+  }
+
+  return `${memoryContent.slice(0, nextSectionIndex).trimEnd()}\n\n${entry}\n${memoryContent.slice(nextSectionIndex)}`;
+}
+
+export async function distillMemory(options: DistillMemoryOptions): Promise<DistillMemoryResult> {
+  const { memoryPath, archiveDir } = await ensureMemoryFiles(options.dataDir);
+  const raw = await fs.readFile(memoryPath, "utf-8");
+  const { section, learning } = buildLearning(options);
+  const nextMemory = appendLearningToSection(raw, section, learning);
+  await fs.writeFile(memoryPath, nextMemory, "utf-8");
+
+  const archivePath = path.join(archiveDir, `${today()}.jsonl`);
+  const archiveEntry = {
+    timestamp: new Date().toISOString(),
+    signalType: options.signalType,
+    feedback: options.feedback || null,
+    contentTitle: options.contentTitle || null,
+    platform: options.platform || null,
+    section,
+    learning,
+  };
+  await fs.appendFile(archivePath, `${JSON.stringify(archiveEntry, null, 0)}\n`, "utf-8");
+
+  return {
+    ok: true,
+    section,
+    learning,
+    memoryPath,
+    archivePath,
+  };
+}

package/src/modules/migrate/legacy-migrate.test.ts

@@ -0,0 +1,169 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import yaml from "js-yaml";
+import { migrateLegacyData } from "./legacy-migrate.js";
+import {
+  stagePath,
+  listTopics,
+  type ProjectMeta,
+} from "../../storage/pipeline-store.js";
+
+let testDir: string;
+
+beforeEach(async () => {
+  testDir = await fs.mkdtemp(
+    path.join(os.tmpdir(), "autocrew-migrate-test-"),
+  );
+});
+
+afterEach(async () => {
+  await fs.rm(testDir, { recursive: true, force: true });
+});
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+async function writeLegacyTopic(filename: string, data: Record<string, unknown>): Promise<void> {
+  const dir = path.join(testDir, "topics");
+  await fs.mkdir(dir, { recursive: true });
+  await fs.writeFile(path.join(dir, filename), JSON.stringify(data), "utf-8");
+}
+
+async function writeLegacyContent(
+  id: string,
+  meta: Record<string, unknown>,
+  draftContent?: string,
+): Promise<void> {
+  const dir = path.join(testDir, "contents", `content-${id}`);
+  await fs.mkdir(dir, { recursive: true });
+  await fs.writeFile(path.join(dir, "meta.json"), JSON.stringify(meta), "utf-8");
+  if (draftContent) {
+    await fs.writeFile(path.join(dir, "draft.md"), draftContent, "utf-8");
+  }
+}
+
+// ─── Tests ──────────────────────────────────────────────────────────────────
+
+describe("Legacy Migration", () => {
+  it("migrates legacy topic JSON to markdown", async () => {
+    await writeLegacyTopic("topic-1.json", {
+      title: "AI写作工具评测",
+      domain: "ai-content",
+      score: { heat: 80, differentiation: 70, audienceFit: 90, overall: 80 },
+      formats: ["video"],
+      suggested_platforms: ["小红书"],
+      created_at: "2024-01-15T00:00:00.000Z",
+      intel_refs: [],
+      angles: ["横向对比"],
+      audience_resonance: "强烈兴趣",
+      references: [],
+    });
+
+    const result = await migrateLegacyData(testDir);
+
+    expect(result.topicsMigrated).toBe(1);
+    expect(result.errors).toHaveLength(0);
+
+    const topics = await listTopics(undefined, testDir);
+    expect(topics.length).toBe(1);
+    expect(topics[0].title).toBe("AI写作工具评测");
+    expect(topics[0].score.overall).toBe(80);
+    expect(topics[0].angles).toEqual(["横向对比"]);
+  });
+
+  it("migrates legacy content to correct pipeline stage", async () => {
+    await writeLegacyContent("001", {
+      title: "测试内容",
+      domain: "tech",
+      status: "drafting",
+      format: "article",
+      created_at: "2024-02-01T00:00:00.000Z",
+    }, "# 测试内容\n\n草稿正文");
+
+    await writeLegacyContent("002", {
+      title: "已发布内容",
+      domain: "tech",
+      status: "published",
+      format: "video",
+      created_at: "2024-01-01T00:00:00.000Z",
+    }, "# 已发布\n\n正文");
+
+    await writeLegacyContent("003", {
+      title: "审核通过",
+      domain: "lifestyle",
+      status: "approved",
+      format: "article",
+    });
+
+    const result = await migrateLegacyData(testDir);
+
+    expect(result.contentsMigrated).toBe(3);
+    expect(result.errors).toHaveLength(0);
+
+    // Check drafting stage
+    const draftingDir = stagePath("drafting", testDir);
+    const draftingEntries = await fs.readdir(draftingDir);
+    expect(draftingEntries.some((e) => e.includes("测试内容"))).toBe(true);
+
+    // Check published stage
+    const publishedDir = stagePath("published", testDir);
+    const publishedEntries = await fs.readdir(publishedDir);
+    expect(publishedEntries.some((e) => e.includes("已发布内容"))).toBe(true);
+
+    // Check production stage
+    const productionDir = stagePath("production", testDir);
+    const productionEntries = await fs.readdir(productionDir);
+    expect(productionEntries.some((e) => e.includes("审核通过"))).toBe(true);
+
+    // Verify meta.yaml was created with correct data
+    const draftProject = draftingEntries.find((e) => e.includes("测试内容"))!;
+    const metaContent = await fs.readFile(
+      path.join(draftingDir, draftProject, "meta.yaml"),
+      "utf-8",
+    );
+    const meta = yaml.load(metaContent) as ProjectMeta;
+    expect(meta.title).toBe("测试内容");
+    expect(meta.domain).toBe("tech");
+    expect(meta.history[0].stage).toBe("drafting");
+
+    // Verify draft-v1.md was created from draft.md
+    const draftV1 = await fs.readFile(
+      path.join(draftingDir, draftProject, "draft-v1.md"),
+      "utf-8",
+    );
+    expect(draftV1).toBe("# 测试内容\n\n草稿正文");
+  });
+
+  it("is idempotent — running twice does not duplicate", async () => {
+    await writeLegacyTopic("topic-1.json", {
+      title: "重复测试",
+      domain: "test",
+      score: { heat: 50, differentiation: 50, audienceFit: 50, overall: 50 },
+      formats: [],
+      created_at: "2024-01-01T00:00:00.000Z",
+      angles: [],
+      audience_resonance: "",
+      references: [],
+    });
+
+    await writeLegacyContent("100", {
+      title: "重复内容",
+      domain: "test",
+      status: "drafting",
+      format: "article",
+    });
+
+    const first = await migrateLegacyData(testDir);
+    expect(first.topicsMigrated).toBe(1);
+    expect(first.contentsMigrated).toBe(1);
+
+    const second = await migrateLegacyData(testDir);
+    expect(second.topicsMigrated).toBe(0);
+    expect(second.contentsMigrated).toBe(0);
+
+    // Still only one of each
+    const topics = await listTopics(undefined, testDir);
+    expect(topics.length).toBe(1);
+  });
+});