chore(skill-memory): rebase onto upstream v0.33.0 (migrations v70/71/72)

Upstream v0.33.0 added migrations v54-v69 (authority identity, mirror
cursors, live-memory resnapshots, mural, message-FTS convergence),
colliding with the skill-memory slots. Renumbered skill P1/P2/P3a to
v70/71/72; LATEST_SUPPORTED_VERSION 69 -> 72.

Also adapts our tests to two upstream contract changes:
- executeStatus is async on this branch; upstream's new #241 clamp tests
  needed await (they were added against the sync signature).
- the historian output contract now requires the tiered paraphrase
  structure, so the skill_observations fixtures emit <p1> instead of a
  flat compartment body (same update upstream made to its e2e fixtures).
- promotion.test.ts: upstream's two new embedding tests used the global
  mock.module('./embedding') this branch removed (CI mock bleed); they
  now use the non-global provider-factory seam.

Author: Tehan

packages/plugin/src/features/magic-context/memory/promotion.test.ts

@@ -4,6 +4,7 @@ import { afterEach, beforeEach, describe, expect, it, mock, spyOn } from "bun:te
 import { Database } from "../../../shared/sqlite";
 import { closeQuietly } from "../../../shared/sqlite-helpers";
 import { CATEGORY_DEFAULT_TTL } from "./constants";
+import type { EmbeddingProvider } from "./embedding-provider";
 import { computeNormalizedHash } from "./normalize-hash";
 
 const mockLog = mock(() => {});
@@ -23,6 +24,13 @@ const {
     insertMemory,
 } = await import("./storage-memory");
 const { embedPromotedFacts, promoteSessionFactsDurable } = await import("./promotion");
+const {
+    _resetProjectEmbeddingRegistryForTests,
+    _setTestProviderFactoryForProject,
+    registerProjectEmbedding,
+} = await import("./embedding");
+const { runMigrations } = await import("../migrations");
+const { initializeDatabase } = await import("../storage-db");
 
 let db: Database | null = null;
 
@@ -99,6 +107,8 @@ afterEach(() => {
             db = null;
         }
     }
+    _resetProjectEmbeddingRegistryForTests();
+    _setTestProviderFactoryForProject(null);
 });
 
 describe("promotion", () => {
@@ -385,18 +395,35 @@ describe("promotion", () => {
 
     describe("#given best-effort embedding of promoted facts", () => {
         it("stores the vector under the registered model when the memory is unchanged", async () => {
-            db = makeMemoryDatabase();
+            _resetProjectEmbeddingRegistryForTests();
+
+            db = new Database(":memory:");
+            initializeDatabase(db);
+            runMigrations(db);
+            const snapshot = registerProjectEmbedding(
+                db,
+                "/repo/project",
+                { provider: "local", model: "mock-model" },
+                { memoryEnabled: true, gitCommitEnabled: false },
+                "/repo/project",
+            );
+            _setTestProviderFactoryForProject(
+                (): EmbeddingProvider => ({
+                    modelId: "mock:model",
+                    initialize: async () => true,
+                    embed: async (_text: string) => new Float32Array([1, 2]),
+                    embedBatch: async (texts: string[]) =>
+                        texts.map(() => new Float32Array([1, 2])),
+                    dispose: async () => {},
+                    isLoaded: () => true,
+                }),
+            );
+
             const memory = insertMemory(db, {
                 projectPath: "/repo/project",
                 category: "ARCHITECTURE_DECISIONS",
                 content: "Embed promoted facts eagerly",
             });
-            mockEmbedText.mockImplementation(async () => ({
-                vector: new Float32Array([1, 2]),
-                modelId: "mock:model",
-                chunkModelId: "mock:chunk",
-                generation: 1,
-            }));
 
             await embedPromotedFacts(db, "ses-1", "/repo/project", [
                 { memoryId: memory.id, content: memory.content },
@@ -406,31 +433,52 @@ describe("promotion", () => {
                 model_id: string;
             }>;
             expect(rows).toHaveLength(1);
-            expect(rows[0].model_id).toBe("mock:model");
+            expect(rows[0].model_id).toBe(snapshot.modelId);
         });
 
         it("discards the stale vector when the memory is edited while embedding is in flight", async () => {
-            db = makeMemoryDatabase();
+            _resetProjectEmbeddingRegistryForTests();
+
+            db = new Database(":memory:");
+            initializeDatabase(db);
+            runMigrations(db);
+            registerProjectEmbedding(
+                db,
+                "/repo/project",
+                { provider: "local", model: "mock-model" },
+                { memoryEnabled: true, gitCommitEnabled: false },
+                "/repo/project",
+            );
+
+            let resolveStarted: (() => void) | undefined;
+            const started = new Promise<void>((resolve) => {
+                resolveStarted = resolve;
+            });
+            let releaseBlocker: (() => void) | undefined;
+            const blocker = new Promise<void>((resolve) => {
+                releaseBlocker = resolve;
+            });
+            _setTestProviderFactoryForProject(
+                (): EmbeddingProvider => ({
+                    modelId: "mock:model",
+                    initialize: async () => true,
+                    embed: async (_text: string): Promise<Float32Array> => {
+                        resolveStarted?.();
+                        await blocker;
+                        return new Float32Array([1, 2]);
+                    },
+                    embedBatch: async (texts: string[]) =>
+                        texts.map(() => new Float32Array([1, 2])),
+                    dispose: async () => {},
+                    isLoaded: () => true,
+                }),
+            );
+
             const memory = insertMemory(db, {
                 projectPath: "/repo/project",
                 category: "ARCHITECTURE_DECISIONS",
                 content: "Original promoted content",
             });
-            let release: (() => void) | undefined;
-            const started = new Promise<void>((resolve) => {
-                mockEmbedText.mockImplementation(async () => {
-                    resolve();
-                    await new Promise<void>((done) => {
-                        release = done;
-                    });
-                    return {
-                        vector: new Float32Array([1, 2]),
-                        modelId: "mock:model",
-                        chunkModelId: "mock:chunk",
-                        generation: 1,
-                    };
-                });
-            });
 
             const inFlight = embedPromotedFacts(db, "ses-1", "/repo/project", [
                 { memoryId: memory.id, content: memory.content },
@@ -441,7 +489,7 @@ describe("promotion", () => {
             db.prepare(
                 "UPDATE memories SET content = ?, normalized_hash = ?, updated_at = ? WHERE id = ?",
             ).run("Edited promoted content", "edited-hash", Date.now(), memory.id);
-            release?.();
+            releaseBlocker?.();
             await inFlight;
 
             const count = (

packages/plugin/src/features/magic-context/migrations-v70.test.ts

@@ -0,0 +1,126 @@
+import { describe, expect, test } from "bun:test";
+import { Database } from "../../shared/sqlite";
+import { closeQuietly } from "../../shared/sqlite-helpers";
+import { LATEST_MIGRATION_VERSION, runMigrations } from "./migrations";
+import { initializeDatabase, LATEST_SUPPORTED_VERSION } from "./storage-db"; // ESM import (not require) — matches codebase pattern
+
+function columnNames(db: Database, table: string): string[] {
+    return (db.prepare(`PRAGMA table_info(${table})`).all() as Array<{ name: string }>).map(
+        (c) => c.name,
+    );
+}
+
+function tableExists(db: Database, name: string): boolean {
+    return Boolean(
+        db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name = ?").get(name),
+    );
+}
+
+describe("migration v70 — skill_memory table", () => {
+    test("creates skill_memory table with correct columns on fresh DB, idempotently", () => {
+        const db = new Database(":memory:");
+        try {
+            initializeDatabase(db);
+            runMigrations(db);
+            runMigrations(db); // idempotency check
+
+            expect(tableExists(db, "skill_memory")).toBe(true);
+
+            const cols = columnNames(db, "skill_memory");
+            expect(cols).toContain("id");
+            expect(cols).toContain("skill_id");
+            expect(cols).toContain("resolved_path");
+            expect(cols).toContain("tier");
+            expect(cols).toContain("skill_source");
+            expect(cols).toContain("project_identity");
+            expect(cols).toContain("intent");
+            expect(cols).toContain("intent_embedding");
+            expect(cols).toContain("embedding_model_version");
+            expect(cols).toContain("kind");
+            expect(cols).toContain("delta");
+            expect(cols).toContain("tags");
+            expect(cols).toContain("hit_count");
+            expect(cols).toContain("pinned");
+            expect(cols).toContain("normalized_hash");
+            expect(cols).toContain("created_at");
+            expect(cols).toContain("last_used_at");
+
+            expect(
+                db
+                    .prepare("SELECT version FROM schema_migrations ORDER BY version DESC LIMIT 1")
+                    .get(),
+            ).toEqual({ version: LATEST_MIGRATION_VERSION });
+        } finally {
+            closeQuietly(db);
+        }
+    });
+
+    test("skill_memory CHECK constraints reject invalid tier and kind values", () => {
+        const db = new Database(":memory:");
+        try {
+            initializeDatabase(db);
+            runMigrations(db);
+
+            const insert = db.prepare(`
+                INSERT INTO skill_memory
+                  (skill_id, resolved_path, tier, project_identity, intent, kind, delta, normalized_hash, hit_count, pinned, created_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, 0, 0, ?)
+            `);
+
+            // Valid row
+            expect(() =>
+                insert.run(
+                    "test-skill",
+                    "/path/SKILL.md",
+                    "project",
+                    "git:abc123",
+                    "test intent",
+                    "gotcha",
+                    "test delta",
+                    "hash1",
+                    Date.now(),
+                ),
+            ).not.toThrow();
+
+            // Invalid tier
+            expect(() =>
+                insert.run(
+                    "test-skill",
+                    "/path/SKILL.md",
+                    "invalid-tier",
+                    "git:abc123",
+                    "test intent",
+                    "gotcha",
+                    "test delta",
+                    "hash2",
+                    Date.now(),
+                ),
+            ).toThrow();
+
+            // Invalid kind
+            expect(() =>
+                insert.run(
+                    "test-skill",
+                    "/path/SKILL.md",
+                    "project",
+                    "git:abc123",
+                    "test intent",
+                    "general",
+                    "test delta",
+                    "hash3",
+                    Date.now(),
+                ),
+            ).toThrow();
+        } finally {
+            closeQuietly(db);
+        }
+    });
+
+    test("LATEST_SUPPORTED_VERSION equals LATEST_MIGRATION_VERSION after v70", () => {
+        // This test will fail until storage-db.ts is bumped to 39.
+        // Belt-and-braces: mirrors schema-version-fence.test.ts but is co-located with the migration.
+        // If this feels redundant, keep it with this comment — co-location aids discoverability.
+        // NOTE: use ESM import at the top of the file (not require()) to match codebase pattern.
+        expect(LATEST_SUPPORTED_VERSION).toBe(LATEST_MIGRATION_VERSION);
+    });
+});

…res/magic-context/migrations-v55.test.ts …res/magic-context/migrations-v71.test.tspackages/plugin/src/features/magic-context/migrations-v55.test.ts renamed to packages/plugin/src/features/magic-context/migrations-v71.test.ts packages/plugin/src/features/magic-context/migrations-v55.test.ts renamed to packages/plugin/src/features/magic-context/migrations-v71.test.ts

@@ -15,7 +15,7 @@ function tableExists(db: Database, name: string): boolean {
     );
 }
 
-describe("migration v55 — skill_memory embeddings + FTS", () => {
+describe("migration v71 — skill_memory embeddings + FTS", () => {
     test("fresh DB: delta_embedding column and skill_memory_fts exist, no throw", () => {
         const db = new Database(":memory:");
         try {
@@ -64,7 +64,7 @@ describe("migration v55 — skill_memory embeddings + FTS", () => {
     });
 
     // requires `import { MIGRATIONS } from "./migrations";` (added above)
-    test("v55 migration backfills FTS for rows that pre-existed v40", () => {
+    test("v71 migration backfills FTS for rows that pre-existed v40", () => {
         const db = new Database(":memory:");
         try {
             initializeDatabase(db);
@@ -75,7 +75,7 @@ describe("migration v55 — skill_memory embeddings + FTS", () => {
             )) {
                 m.up(db);
             }
-            // Insert a row under the pre-v55 schema — no FTS table yet, so no AFTER-INSERT trigger indexes it.
+            // Insert a row under the pre-v71 schema — no FTS table yet, so no AFTER-INSERT trigger indexes it.
             db.prepare(
                 `INSERT INTO skill_memory
                    (skill_id, resolved_path, tier, project_identity, intent, kind, delta, normalized_hash, hit_count, pinned, created_at)
@@ -92,9 +92,9 @@ describe("migration v55 — skill_memory embeddings + FTS", () => {
                 Date.now(),
             );
             // Apply ONLY v40's up() — its body must ALTER + create the FTS table + BACKFILL the pre-existing row.
-            const v55 = MIGRATIONS.find((m) => m.version === 55);
-            if (!v55) throw new Error("v40 migration not found");
-            v55.up(db);
+            const v71 = MIGRATIONS.find((m) => m.version === 71);
+            if (!v71) throw new Error("v40 migration not found");
+            v71.up(db);
             const hit = db
                 .prepare(
                     `SELECT m.id FROM skill_memory_fts f JOIN skill_memory m ON m.id = f.rowid WHERE skill_memory_fts MATCH ?`,
@@ -106,8 +106,8 @@ describe("migration v55 — skill_memory embeddings + FTS", () => {
         }
     });
 
-    test("LATEST_SUPPORTED_VERSION equals LATEST_MIGRATION_VERSION after v55", () => {
+    test("LATEST_SUPPORTED_VERSION equals LATEST_MIGRATION_VERSION after v71", () => {
         expect(LATEST_SUPPORTED_VERSION).toBe(LATEST_MIGRATION_VERSION);
-        expect(LATEST_SUPPORTED_VERSION).toBe(56);
+        expect(LATEST_SUPPORTED_VERSION).toBe(72);
     });
 });