@vellumai/assistant 0.8.10 → 0.8.11-staging.1

package/src/memory/v2/__tests__/consolidation-prompt-flag-gating-guard.test.ts

@@ -0,0 +1,189 @@
+/**
+ * Guard: the DEFAULT consolidation prompt must not leak flag-gated feature
+ * content to installs that don't have the feature enabled.
+ *
+ * Why this exists: the consolidation prompt ships to every assistant with no
+ * `memory.v2.consolidation_prompt_path` override, and it is processed without
+ * any flag check at run time — so flag-gated instructions added to the shared
+ * template reach the entire default population at their next consolidation.
+ * That happened once: the memory-v3 `core-pages.md` curation step landed
+ * inline and instructed v2-only installs to curate a file nothing on their
+ * install reads, under premises ("kept in reach every turn", "the hot set")
+ * that are false without the v3 lanes. This is the same leak class
+ * `workspace-release-notes-feature-flag-guard.test.ts` blocks for UPDATES.md,
+ * via a path that guard doesn't cover.
+ *
+ * The rule this enforces: flag-gated content enters the template only via a
+ * `{{...}}` placeholder substituted by `renderConsolidationPrompt` under a
+ * `ConsolidationPromptOptions` gate. When you add a gated section, register
+ * it in GATED_SECTIONS below so the guard covers it.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, test } from "bun:test";
+
+import {
+  CONSOLIDATION_PROMPT_V3,
+  CORE_PAGES_CONSOLIDATION_SECTION,
+  renderConsolidationPrompt,
+} from "../prompts/consolidation.js";
+
+type Registry = {
+  flags: Array<{
+    key: string;
+    scope: string;
+    defaultEnabled: boolean;
+  }>;
+};
+
+/**
+ * Every flag-gated section of the consolidation prompt, with a short
+ * distinctive marker that would survive light rewording of the section body.
+ * The guard asserts neither appears in the all-gates-off rendering.
+ */
+const GATED_SECTIONS: Array<{
+  name: string;
+  section: string;
+  marker: string;
+}> = [
+  {
+    name: "memory-v3 core-pages curation (gate: memory-v3-shadow|live)",
+    section: CORE_PAGES_CONSOLIDATION_SECTION,
+    marker: "core-pages",
+  },
+];
+
+/** All `ConsolidationPromptOptions` gates forced off — the v2-only rendering. */
+const ALL_GATES_OFF = {
+  includeCorePagesSection: false,
+  articleShape: "v2" as const,
+};
+
+/**
+ * Phrases distinctive to the v3 article-shape template. The all-gates-off
+ * rendering must contain none of them — the v3 shape drops the `summary:`
+ * field that v2 injection depends on, so leaking it to a v2 install corrupts
+ * the corpus the install actually serves prompts from.
+ */
+const V3_SHAPE_MARKERS = [
+  "The lead IS the card",
+  "status: cc-draft",
+  "kind: index",
+];
+
+// Registry helpers mirror workspace-release-notes-feature-flag-guard.test.ts.
+function loadDefaultDisabledAssistantFlagKeys(): string[] {
+  const registryPath = join(
+    process.cwd(),
+    "..",
+    "meta",
+    "feature-flags",
+    "feature-flag-registry.json",
+  );
+  const registry = JSON.parse(readFileSync(registryPath, "utf-8")) as Registry;
+  return registry.flags
+    .filter((flag) => flag.scope === "assistant" && !flag.defaultEnabled)
+    .map((flag) => flag.key)
+    .sort();
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function featureFlagKeyPattern(key: string): RegExp {
+  const escaped = escapeRegExp(key);
+  if (key.includes("-")) {
+    return new RegExp(`(?:^|[^a-z0-9-])${escaped}(?:$|[^a-z0-9-])`, "i");
+  }
+  return new RegExp("[`'\"]" + escaped + "[`'\"]", "i");
+}
+
+describe("default consolidation prompt flag-gating guard", () => {
+  const rendered = renderConsolidationPrompt("Jan 1, 12:00 AM", ALL_GATES_OFF);
+
+  test("leaves no unsubstituted {{...}} placeholders", () => {
+    // A placeholder added to the template but not wired into
+    // renderConsolidationPrompt's substitutions would ship raw braces to
+    // every default-prompt install.
+    const residue = rendered.match(/\{\{[A-Z0-9_]+\}\}/g) ?? [];
+    expect(
+      residue,
+      "Unsubstituted placeholder(s) in the default consolidation prompt — " +
+        "wire them through renderConsolidationPrompt and gate them via " +
+        "ConsolidationPromptOptions.",
+    ).toEqual([]);
+  });
+
+  test("contains no flag-gated section content when all gates are off", () => {
+    const violations: string[] = [];
+    for (const { name, section, marker } of GATED_SECTIONS) {
+      if (rendered.includes(section)) {
+        violations.push(`${name}: full section text present`);
+      }
+      if (rendered.includes(marker)) {
+        violations.push(`${name}: marker "${marker}" present`);
+      }
+    }
+
+    const message = [
+      "The default consolidation prompt reaches every install with no prompt",
+      "override, regardless of feature flags. Flag-gated feature instructions",
+      "must enter via a {{...}} placeholder substituted under a",
+      "ConsolidationPromptOptions gate (see CORE_PAGES_PLACEHOLDER for the",
+      "pattern) — never inline in CONSOLIDATION_PROMPT.",
+      "",
+      "Violations:",
+      ...violations.map((violation) => `  - ${violation}`),
+    ].join("\n");
+    expect(violations, message).toEqual([]);
+  });
+
+  test("references no default-disabled assistant feature flags", () => {
+    const violations: string[] = [];
+    for (const key of loadDefaultDisabledAssistantFlagKeys()) {
+      if (featureFlagKeyPattern(key).test(rendered)) {
+        violations.push(`references default-disabled flag "${key}"`);
+      }
+    }
+    expect(
+      violations,
+      "The default consolidation prompt must not mention default-disabled " +
+        "assistant feature flags by name.\n" +
+        violations.map((violation) => `  - ${violation}`).join("\n"),
+    ).toEqual([]);
+  });
+
+  test("contains no v3 article-shape content when the shape gate is v2", () => {
+    const violations = V3_SHAPE_MARKERS.filter((marker) =>
+      rendered.includes(marker),
+    );
+    expect(
+      violations,
+      "The v2 (all-gates-off) rendering must not teach the v3 article shape — " +
+        "v2 installs depend on `summary:` fragment pages. v3-shape content " +
+        "belongs only in CONSOLIDATION_PROMPT_V3, selected via " +
+        "options.articleShape.\nLeaked markers: " +
+        violations.join(", "),
+    ).toEqual([]);
+  });
+
+  test("the v3 rendering teaches the v3 shape and drops the v2 summary requirement", () => {
+    const v3 = renderConsolidationPrompt("Jan 1, 12:00 AM", {
+      includeCorePagesSection: true,
+      articleShape: "v3",
+    });
+    for (const marker of V3_SHAPE_MARKERS) {
+      expect(v3).toContain(marker);
+    }
+    // The v3 shape must not instruct a required `summary:` field — its absence
+    // is the wiki↔v2 coupling the deploy sequence is built around.
+    expect(v3).not.toContain("The `summary` field is required");
+    // §10 rides along under the live flag.
+    expect(v3).toContain(CORE_PAGES_CONSOLIDATION_SECTION);
+    // The raw template keeps both placeholders wired.
+    expect(CONSOLIDATION_PROMPT_V3).toContain("{{CUTOFF}}");
+    expect(CONSOLIDATION_PROMPT_V3).toContain("{{CORE_PAGES_SECTION}}");
+    expect(v3.match(/\{\{[A-Z0-9_]+\}\}/g) ?? []).toEqual([]);
+  });
+});

package/src/memory/v2/__tests__/injected-block-slugs.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  extractInjectedConceptSlugs,
+  injectedConceptHeader,
+  readInjectedBlock,
+} from "../injected-block-slugs.js";
+
+describe("extractInjectedConceptSlugs", () => {
+  test("extracts nested concept slugs from page headers", () => {
+    const block = [
+      'Use `file_read("memory/concepts/path/to/file.md")` to read the full pages for any of the injected memory summaries you want more information on.',
+      "",
+      "# memory/concepts/topics/page-a.md",
+      "Summary of page a.",
+      "",
+      "# memory/concepts/arcs/deep/nested/page-b.md",
+      "Summary of page b.",
+    ].join("\n");
+
+    expect(extractInjectedConceptSlugs(block)).toEqual([
+      "topics/page-a",
+      "arcs/deep/nested/page-b",
+    ]);
+  });
+
+  test("handles a <memory>-wrapped block the same as an unwrapped one", () => {
+    const wrapped =
+      "<memory>\n# memory/concepts/topics/page-a.md\nSummary.\n</memory>";
+    expect(extractInjectedConceptSlugs(wrapped)).toEqual(["topics/page-a"]);
+  });
+
+  test("ignores skill and CLI sections and non-header lines", () => {
+    const block = [
+      "# memory/concepts/topics/page-a.md",
+      "Summary mentioning memory/concepts/topics/page-x.md inline.",
+      "",
+      "### Skills You Can Use",
+      "- Meeting joiner skill → use skill_load to activate",
+      "",
+      "### CLI Commands You Can Use",
+      "Run `assistant <command> --help` for full usage.",
+      "- `assistant export`: export a conversation",
+    ].join("\n");
+
+    expect(extractInjectedConceptSlugs(block)).toEqual(["topics/page-a"]);
+  });
+
+  test("dedupes repeated headers and returns [] when none match", () => {
+    const block =
+      "# memory/concepts/topics/page-a.md\nA.\n\n# memory/concepts/topics/page-a.md\nA again.";
+    expect(extractInjectedConceptSlugs(block)).toEqual(["topics/page-a"]);
+    expect(extractInjectedConceptSlugs("no headers here")).toEqual([]);
+  });
+});
+
+describe("injectedConceptHeader", () => {
+  test("builds the header the extractor recovers (builder/parser round-trip)", () => {
+    const header = injectedConceptHeader("topics/page-a");
+    expect(header).toBe("# memory/concepts/topics/page-a.md");
+    expect(extractInjectedConceptSlugs(`${header}\nBody.`)).toEqual([
+      "topics/page-a",
+    ]);
+  });
+});
+
+describe("readInjectedBlock", () => {
+  test("reads the requested key off valid metadata JSON", () => {
+    const metadata = JSON.stringify({
+      memoryInjectedBlock: "v2 block",
+      memoryV3InjectedBlock: "v3 block",
+    });
+    expect(readInjectedBlock(metadata, "memoryInjectedBlock")).toBe("v2 block");
+    expect(readInjectedBlock(metadata, "memoryV3InjectedBlock")).toBe(
+      "v3 block",
+    );
+  });
+
+  test("returns null for absent, non-string, malformed, or non-object metadata", () => {
+    expect(readInjectedBlock(null, "memoryInjectedBlock")).toBeNull();
+    expect(readInjectedBlock(undefined, "memoryInjectedBlock")).toBeNull();
+    expect(readInjectedBlock("", "memoryInjectedBlock")).toBeNull();
+    expect(readInjectedBlock("not json", "memoryInjectedBlock")).toBeNull();
+    expect(readInjectedBlock('["array"]', "memoryInjectedBlock")).toBeNull();
+    expect(
+      readInjectedBlock('{"memoryInjectedBlock": 42}', "memoryInjectedBlock"),
+    ).toBeNull();
+    expect(readInjectedBlock("{}", "memoryInjectedBlock")).toBeNull();
+  });
+});

package/src/memory/v2/__tests__/page-store.test.ts

@@ -208,6 +208,39 @@ describe("writePage + readPage round-trip", () => {
     ]);
   });
 
+  test("accepts and round-trips the v3 wiki-article frontmatter fields", async () => {
+    // The full shape CONSOLIDATION_PROMPT_V3 teaches and migrated corpora
+    // arrive in. readPage() throws on schema failure and one invalid page in
+    // a turn's top-K no-ops the whole v2 injection block, so rejecting these
+    // fields would break every article of a migrated corpus at once.
+    const page = makePage({
+      slug: "wiki-shaped",
+      frontmatter: {
+        edges: [],
+        ref_files: [],
+        ref_urls: [],
+        title: "Wiki Shaped — A Display Title",
+        slug: "wiki-shaped",
+        tags: ["topic-area", "index"],
+        main: "parent-hub",
+        kind: "index",
+        status: "cc-draft",
+        links: ["child-slug — why this link exists"],
+      },
+    });
+    await writePage(workspaceDir, page);
+
+    const read = await readPage(workspaceDir, "wiki-shaped");
+    expect(read).not.toBeNull();
+    expect(read!.frontmatter.title).toBe("Wiki Shaped — A Display Title");
+    expect(read!.frontmatter.tags).toEqual(["topic-area", "index"]);
+    expect(read!.frontmatter.main).toBe("parent-hub");
+    expect(read!.frontmatter.kind).toBe("index");
+    // The draft marker must survive a programmatic write → read round-trip:
+    // stripping it would silently un-draft a page mid-voice-pass.
+    expect(read!.frontmatter.status).toBe("cc-draft");
+  });
+
   test("renders frontmatter at the top with --- delimiters", async () => {
     const page = makePage();
     await writePage(workspaceDir, page);

package/src/memory/v2/__tests__/prompts-consolidation.test.ts

@@ -60,13 +60,32 @@ afterAll(() => {
   rmSync(tmpWorkspace, { recursive: true, force: true });
 });
 
-const { CONSOLIDATION_PROMPT, CUTOFF_PLACEHOLDER, resolveConsolidationPrompt } =
-  await import("../prompts/consolidation.js");
+const {
+  CONSOLIDATION_PROMPT,
+  CORE_PAGES_CONSOLIDATION_SECTION,
+  CORE_PAGES_PLACEHOLDER,
+  CUTOFF_PLACEHOLDER,
+  resolveConsolidationPrompt,
+} = await import("../prompts/consolidation.js");
 
 const CUTOFF = "2026-05-01T12:00:00.000Z";
 
-const bundledPrompt = (): string =>
-  (CONSOLIDATION_PROMPT as string).replaceAll(CUTOFF_PLACEHOLDER, CUTOFF);
+/** Options for tests not exercising the v3 core-pages gate. */
+const NO_CORE = { includeCorePagesSection: false, articleShape: "v2" as const };
+const WITH_CORE = {
+  includeCorePagesSection: true,
+  articleShape: "v2" as const,
+};
+
+const bundledPrompt = (includeCorePagesSection = false): string =>
+  (CONSOLIDATION_PROMPT as string)
+    .replaceAll(CUTOFF_PLACEHOLDER, CUTOFF)
+    .replaceAll(
+      CORE_PAGES_PLACEHOLDER,
+      includeCorePagesSection
+        ? (CORE_PAGES_CONSOLIDATION_SECTION as string)
+        : "",
+    );
 
 beforeEach(() => {
   warnCalls.length = 0;
@@ -88,7 +107,7 @@ afterEach(() => {
 
 describe("resolveConsolidationPrompt — no override", () => {
   test("returns the bundled prompt with {{CUTOFF}} substituted when overridePath is null", () => {
-    const result = resolveConsolidationPrompt(null, CUTOFF);
+    const result = resolveConsolidationPrompt(null, CUTOFF, NO_CORE);
     expect(result).toContain("You are running memory consolidation");
     expect(result).toContain(CUTOFF);
     expect(result).not.toContain(CUTOFF_PLACEHOLDER);
@@ -96,12 +115,49 @@ describe("resolveConsolidationPrompt — no override", () => {
   });
 });
 
+describe("resolveConsolidationPrompt — core-pages gate", () => {
+  test("omits the core-pages section (and any placeholder residue) when the v3 gate is off", () => {
+    // v2-only installs must not be told to curate a file nothing reads.
+    const result = resolveConsolidationPrompt(null, CUTOFF, NO_CORE);
+    expect(result).not.toContain("core-pages");
+    expect(result).not.toContain(CORE_PAGES_PLACEHOLDER);
+    // The section's slot collapses cleanly: §9 flows straight into the
+    // separator with no stray blank lines.
+    expect(result).toContain(
+      "never wholesale-clear.\n\n---\n\n# What NOT to do",
+    );
+  });
+
+  test("includes the core-pages section exactly once, in place, when the v3 gate is on", () => {
+    const result = resolveConsolidationPrompt(null, CUTOFF, WITH_CORE);
+    expect(result).toContain("## 10. Review `memory/core-pages.md`");
+    expect(result.split("## 10. Review").length - 1).toBe(1);
+    expect(result).not.toContain(CORE_PAGES_PLACEHOLDER);
+    // Positioned between §9 and the don'ts, as authored.
+    const sectionAt = result.indexOf("## 10. Review");
+    expect(sectionAt).toBeGreaterThan(result.indexOf("## 9. Trim"));
+    expect(sectionAt).toBeLessThan(result.indexOf("# What NOT to do"));
+  });
+
+  test("substitutes the placeholder in override files per the same gate", () => {
+    const path = join(tmpWorkspace, "custom-prompt.md");
+    writeFileSync(path, "Before\n{{CORE_PAGES_SECTION}}After {{CUTOFF}}\n");
+
+    const withCore = resolveConsolidationPrompt(path, CUTOFF, WITH_CORE);
+    expect(withCore).toContain("## 10. Review `memory/core-pages.md`");
+    expect(withCore).not.toContain(CORE_PAGES_PLACEHOLDER);
+
+    const withoutCore = resolveConsolidationPrompt(path, CUTOFF, NO_CORE);
+    expect(withoutCore).toBe(`Before\nAfter ${CUTOFF}\n`);
+  });
+});
+
 describe("resolveConsolidationPrompt — with override", () => {
   test("loads an absolute path verbatim and substitutes {{CUTOFF}}", () => {
     const path = join(tmpWorkspace, "custom-prompt.md");
     writeFileSync(path, "Custom prompt at {{CUTOFF}}\n");
 
-    const result = resolveConsolidationPrompt(path, CUTOFF);
+    const result = resolveConsolidationPrompt(path, CUTOFF, NO_CORE);
 
     expect(result).toBe(`Custom prompt at ${CUTOFF}\n`);
     expect(warnCalls).toHaveLength(0);
@@ -113,7 +169,11 @@ describe("resolveConsolidationPrompt — with override", () => {
       "Workspace-relative {{CUTOFF}}\n",
     );
 
-    const result = resolveConsolidationPrompt("custom-prompt.md", CUTOFF);
+    const result = resolveConsolidationPrompt(
+      "custom-prompt.md",
+      CUTOFF,
+      NO_CORE,
+    );
 
     expect(result).toBe(`Workspace-relative ${CUTOFF}\n`);
     expect(warnCalls).toHaveLength(0);
@@ -124,7 +184,11 @@ describe("resolveConsolidationPrompt — with override", () => {
     const path = join(homedir(), filename);
     writeFileSync(path, "Home dir {{CUTOFF}}\n");
     try {
-      const result = resolveConsolidationPrompt(`~/${filename}`, CUTOFF);
+      const result = resolveConsolidationPrompt(
+        `~/${filename}`,
+        CUTOFF,
+        NO_CORE,
+      );
       expect(result).toBe(`Home dir ${CUTOFF}\n`);
       expect(warnCalls).toHaveLength(0);
     } finally {
@@ -136,7 +200,11 @@ describe("resolveConsolidationPrompt — with override", () => {
     const body = "No placeholder here. Just a plain prompt.\n";
     writeFileSync(join(tmpWorkspace, "no-placeholder.md"), body);
 
-    const result = resolveConsolidationPrompt("no-placeholder.md", CUTOFF);
+    const result = resolveConsolidationPrompt(
+      "no-placeholder.md",
+      CUTOFF,
+      NO_CORE,
+    );
 
     expect(result).toBe(body);
     expect(warnCalls).toHaveLength(0);
@@ -148,7 +216,11 @@ describe("resolveConsolidationPrompt — with override", () => {
       "{{CUTOFF}} ... {{CUTOFF}} ... {{CUTOFF}}",
     );
 
-    const result = resolveConsolidationPrompt("custom-prompt.md", CUTOFF);
+    const result = resolveConsolidationPrompt(
+      "custom-prompt.md",
+      CUTOFF,
+      NO_CORE,
+    );
 
     expect(result).toBe(`${CUTOFF} ... ${CUTOFF} ... ${CUTOFF}`);
     expect(result).not.toContain(CUTOFF_PLACEHOLDER);
@@ -160,6 +232,7 @@ describe("resolveConsolidationPrompt — failure modes", () => {
     const result = resolveConsolidationPrompt(
       "/this/path/does/not/exist.md",
       CUTOFF,
+      NO_CORE,
     );
 
     expect(result).toBe(bundledPrompt());
@@ -173,7 +246,7 @@ describe("resolveConsolidationPrompt — failure modes", () => {
     const path = join(tmpWorkspace, "empty.md");
     writeFileSync(path, "");
 
-    const result = resolveConsolidationPrompt(path, CUTOFF);
+    const result = resolveConsolidationPrompt(path, CUTOFF, NO_CORE);
 
     expect(result).toBe(bundledPrompt());
     expect(warnCalls).toHaveLength(1);
@@ -185,7 +258,7 @@ describe("resolveConsolidationPrompt — failure modes", () => {
     const path = join(tmpWorkspace, "empty.md");
     writeFileSync(path, "   \n\n\t\n");
 
-    const result = resolveConsolidationPrompt(path, CUTOFF);
+    const result = resolveConsolidationPrompt(path, CUTOFF, NO_CORE);
 
     expect(result).toBe(bundledPrompt());
     expect(warnCalls).toHaveLength(1);
@@ -198,7 +271,7 @@ describe("resolveConsolidationPrompt — failure modes", () => {
     // 1 MiB + 1 byte — just over the cap so we don't waste test memory.
     writeFileSync(path, Buffer.alloc(1 * 1024 * 1024 + 1, 0x61));
 
-    const result = resolveConsolidationPrompt(path, CUTOFF);
+    const result = resolveConsolidationPrompt(path, CUTOFF, NO_CORE);
 
     expect(result).toBe(bundledPrompt());
     expect(warnCalls).toHaveLength(1);
@@ -213,7 +286,7 @@ describe("resolveConsolidationPrompt — failure modes", () => {
     const link = join(tmpWorkspace, "link.md");
     symlinkSync(target, link);
 
-    const result = resolveConsolidationPrompt(link, CUTOFF);
+    const result = resolveConsolidationPrompt(link, CUTOFF, NO_CORE);
 
     expect(result).toBe(bundledPrompt());
     expect(warnCalls).toHaveLength(1);
@@ -230,7 +303,7 @@ describe("resolveConsolidationPrompt — failure modes", () => {
       return;
     }
 
-    const result = resolveConsolidationPrompt(fifoPath, CUTOFF);
+    const result = resolveConsolidationPrompt(fifoPath, CUTOFF, NO_CORE);
 
     expect(result).toBe(bundledPrompt());
     expect(warnCalls).toHaveLength(1);

package/src/memory/v2/activation-store.ts

@@ -11,7 +11,11 @@ import { eq } from "drizzle-orm";
 
 import type { DrizzleDb } from "../db-connection.js";
 import { activationState } from "../schema.js";
-import { type ActivationState, ActivationStateSchema } from "./types.js";
+import {
+  type ActivationState,
+  ActivationStateSchema,
+  type EverInjectedEntry,
+} from "./types.js";
 
 /**
  * Load the activation state for a conversation, or `null` if no row exists.
@@ -118,6 +122,51 @@ export function forkActivationState(
     .run();
 }
 
+/**
+ * Seed a truncated fork's activation row from the concept slugs whose
+ * `<memory>` attachments the child actually inherited.
+ *
+ * Truncated forks cannot take the wholesale `forkActivationState` copy: the
+ * parent row marks slugs injected on turns the child does not contain, so
+ * copying it would suppress those pages in the child forever (silent recall
+ * holes). Seeding nothing has the opposite failure — every attachment already
+ * present in the copied history gets re-selected and re-attached on the
+ * child's next turns as a duplicate. Deriving `everInjected` from the
+ * inherited attachments themselves is exact by construction.
+ *
+ * Activation scores and the turn counter intentionally start fresh: the turn
+ * counter is supplied by the graph tracker, which is also not copied for
+ * truncated forks, so both counters restart together. Inherited entries are
+ * stamped `turn: 0` — dedup is slug-set membership (`turn` is bookkeeping
+ * only) and compaction clears the list wholesale.
+ *
+ * No-op when the child inherited no memory attachments. Synchronous so it can
+ * run inside the transaction that wraps `forkConversation()`.
+ */
+export function seedForkActivationState(
+  database: DrizzleDb,
+  newConversationId: string,
+  inheritedSlugs: string[],
+): void {
+  if (inheritedSlugs.length === 0) return;
+
+  const everInjected: EverInjectedEntry[] = inheritedSlugs.map((slug) => ({
+    slug,
+    turn: 0,
+  }));
+  database
+    .insert(activationState)
+    .values({
+      conversationId: newConversationId,
+      messageId: `${newConversationId}:turn:0`,
+      stateJson: "{}",
+      everInjectedJson: JSON.stringify(everInjected),
+      currentTurn: 0,
+      updatedAt: Date.now(),
+    })
+    .run();
+}
+
 /**
  * Clear all `everInjected` entries. Used after compaction: the cached
  * `<memory>` attachments those slugs lived on are gone, so future turns