autocrew 0.1.0 → 0.2.0

package/src/modules/profile/creator-profile.ts

@@ -63,6 +63,21 @@ export interface ContentPillar {
   exampleAngles: string[];
 }
 
+export interface VideoCrawlerConfig {
+  type: "mediacrawl" | "playwright" | "manual";
+  /** Command to run for mediacrawl mode, e.g. "python3 /path/to/main.py" */
+  command?: string;
+}
+
+export interface OmniConfig {
+  /** API base URL, default "https://api.xiaomimimo.com/v1" */
+  baseUrl: string;
+  /** Model ID, default "mimo-v2-omni" */
+  model: string;
+  /** API key */
+  apiKey: string;
+}
+
 export interface CreatorProfile {
   /** User's content industry/niche */
   industry: string;
@@ -86,6 +101,10 @@ export interface CreatorProfile {
   secondaryPersonas: AudiencePersona[];
   /** Content pillars defining the creator's content strategy */
   contentPillars?: ContentPillar[];
+  /** Video crawler configuration for teardown video acquisition */
+  videoCrawler?: VideoCrawlerConfig;
+  /** Omni model configuration for multimodal video analysis */
+  omniConfig?: OmniConfig;
   /** Whether style calibration has been completed */
   styleCalibrated: boolean;
   /** Profile creation timestamp */
@@ -158,15 +177,26 @@ export async function saveProfile(profile: CreatorProfile, dataDir?: string): Pr
 }
 
 /**
- * Initialize a new empty profile. No-op if one already exists.
+ * Initialize a new empty profile. No-op if the file already exists on disk.
  * Returns the profile (existing or newly created).
+ *
+ * IMPORTANT: We check file existence, not parsability. If the file exists but
+ * can't be parsed, we return an empty in-memory profile but do NOT overwrite
+ * the file — protecting user data from being clobbered by a re-init.
  */
 export async function initProfile(dataDir?: string): Promise<CreatorProfile> {
-  const existing = await loadProfile(dataDir);
-  if (existing) return existing;
-  const profile = emptyProfile();
-  await saveProfile(profile, dataDir);
-  return profile;
+  const filePath = path.join(getDataDir(dataDir), PROFILE_FILE);
+  try {
+    await fs.access(filePath);
+    // File exists — try to load it, but never overwrite
+    const existing = await loadProfile(dataDir);
+    return existing ?? emptyProfile();
+  } catch {
+    // File does not exist — safe to create
+    const profile = emptyProfile();
+    await saveProfile(profile, dataDir);
+    return profile;
+  }
 }
 
 /**

package/src/modules/wiki/wiki.test.ts

@@ -0,0 +1,213 @@
+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 {
+  initPipeline,
+  saveIntel,
+  listIntel,
+  saveWikiPage,
+  getWikiPage,
+  listWikiPages,
+  regenerateWikiIndex,
+  appendWikiLog,
+  stagePath,
+  type IntelItem,
+  type WikiPage,
+} from "../../storage/pipeline-store.js";
+
+let testDir: string;
+
+beforeEach(async () => {
+  testDir = await fs.mkdtemp(path.join(os.tmpdir(), "autocrew-wiki-test-"));
+});
+
+afterEach(async () => {
+  await fs.rm(testDir, { recursive: true, force: true });
+});
+
+describe("Wiki Integration", () => {
+  it("full lifecycle: save intel → create wiki page → regenerate index → log", async () => {
+    await initPipeline(testDir);
+
+    // 1. Save two related intel items about the same entity
+    const intel1: IntelItem = {
+      title: "Cursor reaches 2.6B valuation",
+      domain: "ai-tools",
+      source: "web_search",
+      collectedAt: new Date().toISOString(),
+      relevance: 85,
+      tags: ["cursor", "funding"],
+      expiresAfter: 90,
+      summary: "Anysphere's Cursor editor valued at $2.6B",
+      keyPoints: ["VS Code fork", "$2.6B valuation", "AI-first editor"],
+      topicPotential: "AI tool funding trends",
+    };
+    const intel2: IntelItem = {
+      title: "Cursor Agent Mode launches",
+      domain: "ai-tools",
+      source: "web_search",
+      collectedAt: new Date().toISOString(),
+      relevance: 80,
+      tags: ["cursor", "agent"],
+      expiresAfter: 90,
+      summary: "Cursor launches agent mode for autonomous coding",
+      keyPoints: ["Agent mode", "Autonomous coding", "Background tasks"],
+      topicPotential: "AI coding evolution",
+    };
+    await saveIntel(intel1, testDir);
+    await saveIntel(intel2, testDir);
+
+    // 2. Create a wiki page synthesizing both
+    const today = new Date().toISOString().slice(0, 10);
+    const page: WikiPage = {
+      type: "entity",
+      title: "Cursor",
+      aliases: ["Cursor AI", "Cursor Editor"],
+      related: [],
+      sources: [
+        `ai-tools/${today}-cursor-reaches-2-6b-valuation.md`,
+        `ai-tools/${today}-cursor-agent-mode-launches.md`,
+      ],
+      created: today,
+      updated: today,
+      body: "# Cursor\n\nAI code editor by Anysphere.\n\n## Key Facts\n- VS Code fork with integrated AI\n- $2.6B valuation (2024)\n- Agent Mode for autonomous coding",
+    };
+    await saveWikiPage(page, testDir);
+
+    // 3. Verify page saved correctly
+    const loaded = await getWikiPage("cursor", testDir);
+    expect(loaded).not.toBeNull();
+    expect(loaded!.title).toBe("Cursor");
+    expect(loaded!.sources).toHaveLength(2);
+    expect(loaded!.aliases).toContain("Cursor AI");
+
+    // 4. Regenerate index
+    await regenerateWikiIndex(testDir);
+    const indexContent = await fs.readFile(
+      path.join(stagePath("wiki", testDir), "index.md"),
+      "utf-8",
+    );
+    expect(indexContent).toContain("[Cursor]");
+    expect(indexContent).toContain("## Entities");
+
+    // 5. Log the sync
+    await appendWikiLog("sync", "Created cursor.md from 2 intel sources", testDir);
+    const logContent = await fs.readFile(
+      path.join(stagePath("wiki", testDir), "log.md"),
+      "utf-8",
+    );
+    expect(logContent).toContain("sync");
+    expect(logContent).toContain("cursor.md");
+
+    // 6. Verify flat structure — no subdirectories
+    const wikiFiles = await fs.readdir(stagePath("wiki", testDir));
+    expect(wikiFiles).toContain("cursor.md");
+    expect(wikiFiles).toContain("index.md");
+    expect(wikiFiles).toContain("log.md");
+    for (const f of wikiFiles) {
+      const stat = await fs.stat(path.join(stagePath("wiki", testDir), f));
+      expect(stat.isFile()).toBe(true);
+    }
+  });
+
+  it("multiple pages across types with cross-references", async () => {
+    await initPipeline(testDir);
+    const today = new Date().toISOString().slice(0, 10);
+
+    await saveWikiPage({
+      type: "entity",
+      title: "Cursor",
+      aliases: ["Cursor AI"],
+      related: ["vibe-coding"],
+      sources: [],
+      created: today,
+      updated: today,
+      body: "# Cursor\n\nAI code editor.",
+    }, testDir);
+
+    await saveWikiPage({
+      type: "concept",
+      title: "Vibe Coding",
+      aliases: ["vibe coding"],
+      related: ["cursor"],
+      sources: [],
+      created: today,
+      updated: today,
+      body: "# Vibe Coding\n\nNatural language programming.",
+    }, testDir);
+
+    const pages = await listWikiPages(testDir);
+    expect(pages).toHaveLength(2);
+
+    await regenerateWikiIndex(testDir);
+    const indexContent = await fs.readFile(
+      path.join(stagePath("wiki", testDir), "index.md"),
+      "utf-8",
+    );
+    expect(indexContent).toContain("## Entities");
+    expect(indexContent).toContain("## Concepts");
+    expect(indexContent).toContain("[Cursor]");
+    expect(indexContent).toContain("[Vibe Coding]");
+  });
+});
+
+describe("Teardown → Wiki Integration", () => {
+  it("teardown intel flows into wiki pipeline", async () => {
+    await initPipeline(testDir);
+
+    // Simulate a video teardown result being ingested as intel
+    const teardownIntel: IntelItem = {
+      title: "拆解: vibe-coding教程视频分析",
+      domain: "content-strategy",
+      source: "manual",
+      collectedAt: new Date().toISOString(),
+      relevance: 90,
+      tags: ["teardown", "video", "vibe-coding"],
+      expiresAfter: 365,
+      summary: "对标账号的vibe-coding教程视频拆解。传播学：信息不对称设计精妙。心理学：认知负荷控制好。内容结构：承诺-兑现完美匹配。视听语言：HKRR主导K维度。",
+      keyPoints: [
+        "开场3秒用反常识钩子",
+        "信息密度曲线合理",
+        "HKRR纯粹K维度",
+        "框架效应：frame成能力边界变化",
+      ],
+      topicPotential: "可借鉴：反常识开场+承诺兑现+纯粹K维度",
+    };
+
+    await saveIntel(teardownIntel, testDir);
+
+    // Verify it's in the intel library
+    const items = await listIntel("content-strategy", testDir);
+    expect(items.length).toBe(1);
+    expect(items[0].tags).toContain("teardown");
+    expect(items[0].tags).toContain("video");
+
+    // Simulate wiki page creation from teardown intel
+    const today = new Date().toISOString().slice(0, 10);
+    const wikiPage: WikiPage = {
+      type: "concept",
+      title: "Vibe Coding Teardown Insights",
+      aliases: ["vibe coding analysis"],
+      related: [],
+      sources: [`content-strategy/${today}-chai-jie-vibe-coding-jiao-cheng-shi-pin-fen-xi.md`],
+      created: today,
+      updated: today,
+      body: "# Vibe Coding Teardown Insights\n\n从对标视频拆解中提取：反常识开场+承诺兑现是有效公式。",
+    };
+    await saveWikiPage(wikiPage, testDir);
+
+    // Verify wiki page references the teardown
+    const loaded = await getWikiPage("vibe-coding-teardown-insights", testDir);
+    expect(loaded).not.toBeNull();
+    expect(loaded!.sources[0]).toContain("content-strategy");
+
+    // Verify it shows up in index
+    await regenerateWikiIndex(testDir);
+    const indexContent = await fs.readFile(
+      path.join(stagePath("wiki", testDir), "index.md"),
+      "utf-8",
+    );
+    expect(indexContent).toContain("[Vibe Coding Teardown Insights]");
+  });
+});

package/src/storage/pipeline-store.test.ts

@@ -25,8 +25,14 @@ import {
   restoreProject,
   getProjectMeta,
   listProjects,
+  saveWikiPage,
+  getWikiPage,
+  listWikiPages,
+  regenerateWikiIndex,
+  appendWikiLog,
   type IntelItem,
   type TopicCandidate,
+  type WikiPage,
 } from "../storage/pipeline-store.js";
 
 let testDir: string;
@@ -105,6 +111,12 @@ describe("Pipeline Init", () => {
     expect(archive.isDirectory()).toBe(true);
   });
 
+  it("creates wiki directory", async () => {
+    await initPipeline(testDir);
+    const stat = await fs.stat(stagePath("wiki", testDir));
+    expect(stat.isDirectory()).toBe(true);
+  });
+
   it("initPipeline is idempotent", async () => {
     await initPipeline(testDir);
     await initPipeline(testDir);
@@ -291,12 +303,13 @@ describe("Project Lifecycle", () => {
     const topics = await listTopics(undefined, testDir);
     expect(topics.length).toBe(0);
 
-    // Project dir should contain meta.yaml, draft-v1.md, draft.md, references/
+    // Project dir should contain meta.yaml, draft.md (live), references/.
+    // No draft-v*.md exists yet — snapshots are created only when revisions replace draft.md.
     const files = await fs.readdir(projectDir);
     expect(files).toContain("meta.yaml");
-    expect(files).toContain("draft-v1.md");
     expect(files).toContain("draft.md");
     expect(files).toContain("references");
+    expect(files.filter((f) => f.startsWith("draft-v"))).toHaveLength(0);
   });
 
   it("advances project from drafting to production", async () => {
@@ -318,19 +331,37 @@ describe("Project Lifecycle", () => {
     await startProject("版本测试", testDir);
 
     const projectName = slugify("版本测试");
+    const projectDir = path.join(stagePath("drafting", testDir), projectName);
+
+    // Capture the initial live content before revising
+    const fsp = await import("node:fs/promises");
+    const originalContent = await fsp.readFile(
+      path.join(projectDir, "draft.md"),
+      "utf-8",
+    );
+
     await addDraftVersion(projectName, "# V2 内容", "second draft", testDir);
 
     const meta = await getProjectMeta(projectName, testDir);
-    expect(meta!.versions.length).toBe(2);
-    expect(meta!.current).toBe("draft-v2.md");
-
-    const found = await import("node:fs/promises").then((f) =>
-      f.readFile(
-        path.join(stagePath("drafting", testDir), projectName, "draft.md"),
-        "utf-8",
-      ),
+    // One snapshot should have been created (archiving the original)
+    expect(meta!.versions.length).toBe(1);
+    expect(meta!.versions[0].file).toBe("draft-v1.md");
+    expect(meta!.versions[0].note).toBe("second draft");
+    expect(meta!.current).toBe("draft.md");
+
+    // draft.md is now the new content
+    const liveContent = await fsp.readFile(
+      path.join(projectDir, "draft.md"),
+      "utf-8",
+    );
+    expect(liveContent).toBe("# V2 内容");
+
+    // draft-v1.md holds the frozen original
+    const archivedContent = await fsp.readFile(
+      path.join(projectDir, "draft-v1.md"),
+      "utf-8",
     );
-    expect(found).toBe("# V2 内容");
+    expect(archivedContent).toBe(originalContent);
   });
 
   it("trashes and restores project", async () => {
@@ -361,3 +392,79 @@ describe("Project Lifecycle", () => {
     expect(projects.length).toBeGreaterThan(0);
   });
 });
+
+// ─── Wiki Storage ──────────────────────────────────────────────────────────
+
+function makeWikiPage(overrides: Partial<WikiPage> = {}): WikiPage {
+  return {
+    type: "entity",
+    title: "Claude AI",
+    aliases: ["Claude", "Anthropic Claude"],
+    related: ["anthropic", "llm"],
+    sources: ["intel/2024-01-15-claude.md"],
+    created: "2026-04-05T00:00:00.000Z",
+    updated: "2026-04-05T00:00:00.000Z",
+    body: "Claude is an AI assistant made by Anthropic.",
+    ...overrides,
+  };
+}
+
+describe("Wiki Storage", () => {
+  it("saves and reads a wiki page", async () => {
+    const page = makeWikiPage();
+    const filePath = await saveWikiPage(page, testDir);
+    expect(filePath).toContain("wiki");
+    expect(filePath.endsWith(".md")).toBe(true);
+
+    const slug = "claude-ai";
+    const loaded = await getWikiPage(slug, testDir);
+    expect(loaded).not.toBeNull();
+    expect(loaded!.title).toBe(page.title);
+    expect(loaded!.type).toBe(page.type);
+    expect(loaded!.aliases).toEqual(page.aliases);
+    expect(loaded!.related).toEqual(page.related);
+    expect(loaded!.sources).toEqual(page.sources);
+    expect(loaded!.body).toBe(page.body);
+  });
+
+  it("lists all wiki pages", async () => {
+    await saveWikiPage(makeWikiPage({ title: "Claude AI" }), testDir);
+    await saveWikiPage(
+      makeWikiPage({ title: "GPT-4", type: "comparison" }),
+      testDir,
+    );
+
+    const pages = await listWikiPages(testDir);
+    expect(pages.length).toBe(2);
+  });
+
+  it("generates index.md grouped by type", async () => {
+    await saveWikiPage(makeWikiPage({ title: "Claude AI", type: "entity" }), testDir);
+    await saveWikiPage(makeWikiPage({ title: "LLM Basics", type: "concept" }), testDir);
+    await saveWikiPage(makeWikiPage({ title: "Claude vs GPT", type: "comparison" }), testDir);
+
+    await regenerateWikiIndex(testDir);
+
+    const indexPath = path.join(stagePath("wiki", testDir), "index.md");
+    const content = await fs.readFile(indexPath, "utf-8");
+    expect(content).toContain("# AutoCrew Knowledge Wiki");
+    expect(content).toContain("## Entities");
+    expect(content).toContain("## Concepts");
+    expect(content).toContain("## Comparisons");
+    expect(content).toContain("[Claude AI]");
+    expect(content).toContain("[LLM Basics]");
+    expect(content).toContain("[Claude vs GPT]");
+  });
+
+  it("appends to log.md", async () => {
+    await appendWikiLog("create", "Created page: Claude AI", testDir);
+    await appendWikiLog("update", "Updated page: Claude AI", testDir);
+
+    const logPath = path.join(stagePath("wiki", testDir), "log.md");
+    const content = await fs.readFile(logPath, "utf-8");
+    const lines = content.trim().split("\n");
+    expect(lines.length).toBe(2);
+    expect(lines[0]).toContain("[create]");
+    expect(lines[1]).toContain("[update]");
+  });
+});

package/src/storage/pipeline-store.ts

@@ -8,6 +8,7 @@ import yaml from "js-yaml";
 export const PIPELINE_STAGES = [
   "intel",
   "topics",
+  "wiki",
   "drafting",
   "production",
   "published",
@@ -38,6 +39,17 @@ export interface IntelItem {
   topicPotential: string;
 }
 
+export interface WikiPage {
+  type: "entity" | "concept" | "comparison";
+  title: string;
+  aliases: string[];
+  related: string[];
+  sources: string[];
+  created: string;
+  updated: string;
+  body: string;
+}
+
 export interface TopicScore {
   heat: number;
   differentiation: number;
@@ -330,6 +342,131 @@ export async function archiveExpiredIntel(
   return { archived };
 }
 
+// ─── Wiki Storage ──────────────────────────────────────────────────────────
+
+export function wikiPageToMarkdown(page: WikiPage): string {
+  const frontmatter: Record<string, unknown> = {
+    type: page.type,
+    title: page.title,
+    aliases: page.aliases,
+    related: page.related,
+    sources: page.sources,
+    created: page.created,
+    updated: page.updated,
+  };
+  const yamlStr = yaml.dump(frontmatter, { lineWidth: -1 }).trimEnd();
+  return `---\n${yamlStr}\n---\n\n${page.body}`;
+}
+
+export function parseWikiPage(content: string): WikiPage {
+  const { data, content: body } = matter(content);
+  return {
+    type: data.type,
+    title: data.title,
+    aliases: data.aliases ?? [],
+    related: data.related ?? [],
+    sources: data.sources ?? [],
+    created: data.created,
+    updated: data.updated,
+    body: body.trim(),
+  };
+}
+
+export async function saveWikiPage(
+  page: WikiPage,
+  dataDir?: string,
+): Promise<string> {
+  await initPipeline(dataDir);
+  const wikiDir = stagePath("wiki", dataDir);
+  const slug = slugify(page.title);
+  const filePath = path.join(wikiDir, `${slug}.md`);
+  await fs.writeFile(filePath, wikiPageToMarkdown(page), "utf-8");
+  return filePath;
+}
+
+export async function getWikiPage(
+  slug: string,
+  dataDir?: string,
+): Promise<WikiPage | null> {
+  const wikiDir = stagePath("wiki", dataDir);
+  const filePath = path.join(wikiDir, `${slug}.md`);
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    return parseWikiPage(content);
+  } catch {
+    return null;
+  }
+}
+
+export async function listWikiPages(
+  dataDir?: string,
+): Promise<WikiPage[]> {
+  const wikiDir = stagePath("wiki", dataDir);
+  const pages: WikiPage[] = [];
+  let files: string[];
+  try {
+    files = await fs.readdir(wikiDir);
+  } catch {
+    return [];
+  }
+  for (const f of files) {
+    if (!f.endsWith(".md") || f === "index.md" || f === "log.md") continue;
+    const content = await fs.readFile(path.join(wikiDir, f), "utf-8");
+    pages.push(parseWikiPage(content));
+  }
+  return pages;
+}
+
+export async function regenerateWikiIndex(
+  dataDir?: string,
+): Promise<void> {
+  const pages = await listWikiPages(dataDir);
+  const grouped: Record<string, WikiPage[]> = { entity: [], concept: [], comparison: [] };
+  for (const page of pages) {
+    (grouped[page.type] ??= []).push(page);
+  }
+
+  const headings: Record<string, string> = {
+    entity: "Entities",
+    concept: "Concepts",
+    comparison: "Comparisons",
+  };
+
+  const lines = ["# AutoCrew Knowledge Wiki", ""];
+  for (const [type, heading] of Object.entries(headings)) {
+    const group = grouped[type] ?? [];
+    if (group.length === 0) continue;
+    lines.push(`## ${heading}`);
+    for (const page of group.sort((a, b) => a.title.localeCompare(b.title))) {
+      const slug = slugify(page.title);
+      const bodyLines = page.body.split("\n").filter((l) => !l.startsWith("#") && l.trim());
+      const summary = bodyLines[0]?.slice(0, 60) ?? "";
+      lines.push(`- [${page.title}](${slug}.md) — ${summary}`);
+    }
+    lines.push("");
+  }
+
+  const wikiDir = stagePath("wiki", dataDir);
+  await fs.writeFile(path.join(wikiDir, "index.md"), lines.join("\n"), "utf-8");
+}
+
+export async function appendWikiLog(
+  operation: string,
+  description: string,
+  dataDir?: string,
+): Promise<void> {
+  await initPipeline(dataDir);
+  const wikiDir = stagePath("wiki", dataDir);
+  const logPath = path.join(wikiDir, "log.md");
+  const timestamp = new Date().toISOString();
+  const entry = `- ${timestamp} [${operation}] ${description}\n`;
+  try {
+    await fs.appendFile(logPath, entry, "utf-8");
+  } catch {
+    await fs.writeFile(logPath, entry, "utf-8");
+  }
+}
+
 // ─── Topic Pool ─────────────────────────────────────────────────────────────
 
 export function topicToMarkdown(topic: TopicCandidate): string {
@@ -511,7 +648,7 @@ export async function findProject(
   dataDir?: string,
 ): Promise<{ dir: string; stage: PipelineStage } | null> {
   for (const stage of PIPELINE_STAGES) {
-    if (stage === "intel" || stage === "topics") continue;
+    if (stage === "intel" || stage === "topics" || stage === "wiki") continue;
     const dir = path.join(stagePath(stage, dataDir), name);
     try {
       const stat = await fs.stat(dir);
@@ -550,6 +687,9 @@ export async function startProject(
 
   const now = new Date().toISOString();
 
+  // Semantics: draft.md = live current working file (always latest),
+  // draft-v{N}.md = immutable snapshots of content that has been REPLACED by a revision.
+  // On initial create there are no snapshots yet — only draft.md exists.
   const meta: ProjectMeta = {
     title: topic.title,
     domain: topic.domain,
@@ -557,18 +697,13 @@ export async function startProject(
     createdAt: now,
     sourceTopic: topicFile,
     intelRefs: topic.intelRefs,
-    versions: [{ file: "draft-v1.md", createdAt: now, note: "initial draft" }],
-    current: "draft-v1.md",
+    versions: [],
+    current: "draft.md",
     history: [{ stage: "drafting", entered: now }],
     platforms: [],
   };
 
   await writeMeta(projectDir, meta);
-  await fs.writeFile(
-    path.join(projectDir, "draft-v1.md"),
-    `# ${topic.title}\n\n`,
-    "utf-8",
-  );
   await fs.writeFile(
     path.join(projectDir, "draft.md"),
     `# ${topic.title}\n\n`,
@@ -617,22 +752,42 @@ export async function addDraftVersion(
   if (!found) throw new Error(`Project not found: ${name}`);
 
   const meta = await readMeta(found.dir);
-  const versionNum = meta.versions.length + 1;
-  const filename = `draft-v${versionNum}.md`;
+  const draftPath = path.join(found.dir, "draft.md");
+
+  // Archive the PREVIOUS live draft.md into an immutable snapshot
+  // before overwriting it with the new revision. This is the core invariant:
+  //   draft.md       = always the latest live working file
+  //   draft-v{N}.md  = frozen historical states that have been replaced
+  let oldContent = "";
+  try {
+    oldContent = await fs.readFile(draftPath, "utf-8");
+  } catch {
+    // No previous draft.md — treat as empty. Shouldn't happen in normal flow.
+  }
 
-  await fs.writeFile(path.join(found.dir, filename), content, "utf-8");
-  // Update draft.md to latest content
-  await fs.writeFile(path.join(found.dir, "draft.md"), content, "utf-8");
+  const versionNum = meta.versions.length + 1;
+  const archiveFilename = `draft-v${versionNum}.md`;
+
+  // Snapshot the OLD content (only if there is old content to preserve)
+  if (oldContent.length > 0) {
+    await fs.writeFile(
+      path.join(found.dir, archiveFilename),
+      oldContent,
+      "utf-8",
+    );
+    meta.versions.push({
+      file: archiveFilename,
+      createdAt: new Date().toISOString(),
+      note,
+    });
+  }
 
-  meta.versions.push({
-    file: filename,
-    createdAt: new Date().toISOString(),
-    note,
-  });
-  meta.current = filename;
+  // Write the new content as the live draft
+  await fs.writeFile(draftPath, content, "utf-8");
+  meta.current = "draft.md";
   await writeMeta(found.dir, meta);
 
-  return path.join(found.dir, filename);
+  return draftPath;
 }
 
 export async function trashProject(