@openparachute/vault 0.7.0-rc.4 → 0.7.0-rc.6

package/core/src/attribution.test.ts

@@ -42,8 +42,12 @@ function rawRow(id: string) {
 }
 
 describe("write-attribution — schema", () => {
-  it("bumped SCHEMA_VERSION to 23", () => {
-    expect(SCHEMA_VERSION).toBe(23);
+  it("bumped SCHEMA_VERSION to at least 23 (write-attribution columns landed)", () => {
+    // Was a literal `toBe(23)` pin — that goes stale every time a later PR
+    // bumps SCHEMA_VERSION further (vault#553 bumped it to 24). This test's
+    // actual claim is "the write-attribution migration landed at/after v23",
+    // not "v23 is still current."
+    expect(SCHEMA_VERSION).toBeGreaterThanOrEqual(23);
   });
 
   it("the four columns exist and are indexed", () => {
@@ -230,7 +234,11 @@ describe("write-attribution — legacy backfill (v23 migration)", () => {
     const ver = (legacy.prepare("SELECT MAX(version) AS v FROM schema_version").get() as {
       v: number;
     }).v;
-    expect(ver).toBe(23);
+    // A v22 vault runs the WHOLE migration chain (v23 write-attribution +
+    // whatever landed after — v24's typed-index poison scan, vault#553),
+    // ending at the current SCHEMA_VERSION rather than a hardcoded literal
+    // that goes stale on every later bump.
+    expect(ver).toBe(SCHEMA_VERSION);
 
     // Legacy row: attribution columns exist now but are NULL (not fabricated).
     const old = legacy

package/core/src/contract-taxonomy.test.ts

@@ -9,9 +9,12 @@
  * flipped to real assertions in a later wave. See #552 for the full write-up.
  */
 
-import { describe, it, test, expect, beforeEach } from "bun:test";
+import { describe, it, expect, beforeEach } from "bun:test";
 import { Database } from "bun:sqlite";
 import { SqliteStore } from "./store.js";
+import { generateMcpTools } from "./mcp.js";
+import { ParentCycleError } from "./tag-schemas.js";
+import { declareField } from "./indexed-fields.js";
 
 let store: SqliteStore;
 let db: Database;
@@ -100,20 +103,193 @@ describe("contract: taxonomy — passing (lock in current behavior)", () => {
   });
 });
 
-describe("contract: taxonomy — todo (#552)", () => {
-  test.todo(
-    "#552: deleting a tag still referenced in another tag's parent_names errors unless cascade/detach is passed (today: store.deleteTag succeeds unconditionally and leaves the referencing tag's parent_names pointing at a now-nonexistent tag name — verified with a fresh parent/child fixture)",
-  );
-  test.todo(
-    "#552: a parent_names cycle (A declares parent B, then B declares parent A) is rejected at write time (today: store.upsertTagRecord accepts both writes with no cycle check — traversal elsewhere is cycle-safe, but the write itself is not honest about creating one)",
-  );
-  test.todo(
-    "#552: rename-tag is exposed as an MCP tool, not just a REST endpoint (today: POST /api/tags/:name/rename exists and store.renameTag is wired, but generateMcpTools has no rename-tag tool — an MCP-only agent cannot rename a tag)",
-  );
-  test.todo(
-    "#552: merge-tags is exposed as an MCP tool, not just a REST endpoint (today: POST /api/tags/merge exists and store.mergeTags is wired, but generateMcpTools has no merge-tags tool)",
-  );
-  test.todo(
-    "#552: a `vault doctor` integrity scan reports dangling parent_names references (today: no doctor/scan surface inspects parent_names for referential integrity — the delete-tag gap above goes undetected)",
-  );
+describe("contract: taxonomy — #552 (flipped from test.todo)", () => {
+  it("rename-tag is exposed as an MCP tool and cascades parent_names — the gardener's exact bug no longer happens", async () => {
+    // Root tag, a child that declares it as a parent (the parent_names
+    // surface the gardener's rename left orphaned), and a note tagged with
+    // the CHILD only (proves subtype expansion still finds it post-rename).
+    await store.upsertTagRecord("proj", { description: "root project tag" });
+    await store.upsertTagRecord("special", { parent_names: ["proj"] });
+    const childTagged = await store.createNote("filed under the child tag", { tags: ["special"] });
+
+    const tools = generateMcpTools(store);
+    const renameTag = tools.find((t) => t.name === "rename-tag");
+    expect(renameTag).toBeDefined();
+    expect(renameTag!.requiredVerb).toBe("write");
+
+    const result = await renameTag!.execute({ old_name: "proj", new_name: "initiative" }) as any;
+    expect("error" in result).toBe(false);
+    expect(result.parent_refs_updated).toBeGreaterThanOrEqual(1);
+
+    // The exact gardener's bug: "special"'s parent_names must follow the
+    // rename, not keep pointing at the now-dead "proj".
+    const special = await store.getTagRecord("special");
+    expect(special?.parent_names).toEqual(["initiative"]);
+
+    // The renamed-away tag is NOT a live query surface anymore.
+    const projRecord = await store.getTagRecord("proj");
+    expect(projRecord).toBeNull();
+
+    // The NEW tag doesn't silently miss child-tagged notes (the gardener's
+    // second symptom): subtype expansion of "initiative" still reaches the
+    // note tagged only with the child "special".
+    const viaExpansion = await store.queryNotes({ tags: ["initiative"] });
+    expect(viaExpansion.map((n) => n.id)).toContain(childTagged.id);
+  });
+
+  it("rename-tag MCP tool reports target_exists (not a silent overwrite) and tag_not_found for a missing source", async () => {
+    await store.upsertTagRecord("a", {});
+    await store.upsertTagRecord("b", {});
+    const tools = generateMcpTools(store);
+    const renameTag = tools.find((t) => t.name === "rename-tag")!;
+
+    let caught: any;
+    try {
+      await renameTag.execute({ old_name: "a", new_name: "b" });
+    } catch (e) { caught = e; }
+    expect(caught?.error_type).toBe("target_exists");
+    expect(caught?.conflicting).toContain("b");
+
+    caught = undefined;
+    try {
+      await renameTag.execute({ old_name: "nonexistent", new_name: "whatever" });
+    } catch (e) { caught = e; }
+    expect(caught?.error_type).toBe("tag_not_found");
+  });
+
+  it("merge-tags is exposed as an MCP tool and merges N sources into one target", async () => {
+    await store.upsertTagRecord("draft", {});
+    await store.upsertTagRecord("wip", {});
+    const draftNote = await store.createNote("draft note", { tags: ["draft"] });
+    const wipNote = await store.createNote("wip note", { tags: ["wip"] });
+
+    const tools = generateMcpTools(store);
+    const mergeTags = tools.find((t) => t.name === "merge-tags");
+    expect(mergeTags).toBeDefined();
+    expect(mergeTags!.requiredVerb).toBe("write");
+
+    const result = await mergeTags!.execute({ sources: ["draft", "wip"], target: "active" }) as any;
+    expect(result.target).toBe("active");
+    expect(result.merged.draft).toBe(1);
+    expect(result.merged.wip).toBe(1);
+
+    const draftAfter = await store.getNote(draftNote.id);
+    const wipAfter = await store.getNote(wipNote.id);
+    expect(draftAfter!.tags).toEqual(["active"]);
+    expect(wipAfter!.tags).toEqual(["active"]);
+    expect(await store.getTagRecord("draft")).toBeNull();
+    expect(await store.getTagRecord("wip")).toBeNull();
+  });
+
+  it("delete-tag refuses a tag still referenced in another tag's parent_names, then cascade/detach both proceed and strip the reference", async () => {
+    await store.upsertTagRecord("proj", { description: "root" });
+    await store.upsertTagRecord("child", { parent_names: ["proj"] });
+
+    const tools = generateMcpTools(store);
+    const deleteTag = tools.find((t) => t.name === "delete-tag")!;
+
+    // Default (no flag): refused, nothing mutated.
+    const refused = await deleteTag.execute({ tag: "proj" }) as any;
+    expect(refused.error).toBe("tag_referenced_as_parent");
+    expect(refused.referencing_tags).toEqual(["child"]);
+    expect(await store.getTagRecord("proj")).not.toBeNull();
+    expect((await store.getTagRecord("child"))?.parent_names).toEqual(["proj"]);
+
+    // cascade: true proceeds and strips the stale reference.
+    const cascaded = await deleteTag.execute({ tag: "proj", cascade: true }) as any;
+    expect(cascaded.deleted).toBe(true);
+    expect(cascaded.parent_refs_detached).toBe(1);
+    expect(await store.getTagRecord("proj")).toBeNull();
+    expect((await store.getTagRecord("child"))?.parent_names ?? null).toBeFalsy();
+
+    // detach is a synonym — same repair, exercised on a second fixture.
+    await store.upsertTagRecord("proj2", { description: "root2" });
+    await store.upsertTagRecord("child2", { parent_names: ["proj2"] });
+    const detached = await deleteTag.execute({ tag: "proj2", detach: true }) as any;
+    expect(detached.deleted).toBe(true);
+    expect(detached.parent_refs_detached).toBe(1);
+    expect((await store.getTagRecord("child2"))?.parent_names ?? null).toBeFalsy();
+  });
+
+  it("a parent_names cycle (direct A→B→A, and bare self-parent) is rejected at write time with error_type parent_cycle", async () => {
+    await store.upsertTagRecord("B", {});
+    await store.upsertTagRecord("A", { parent_names: ["B"] });
+
+    let caught: unknown;
+    try {
+      await store.upsertTagRecord("B", { parent_names: ["A"] });
+    } catch (e) { caught = e; }
+    expect(caught).toBeInstanceOf(ParentCycleError);
+    const cycleErr = caught as ParentCycleError;
+    expect(cycleErr.error_type).toBe("parent_cycle");
+    expect(cycleErr.tag).toBe("B");
+    expect(cycleErr.cycle).toContain("A");
+    expect(cycleErr.cycle).toContain("B");
+    // Nothing persisted — B's parent_names is untouched by the rejected write.
+    expect((await store.getTagRecord("B"))?.parent_names ?? null).toBeFalsy();
+
+    // Bare self-parent: also caught (getTagDescendants always includes the
+    // tag itself).
+    let selfCaught: unknown;
+    try {
+      await store.upsertTagRecord("C", { parent_names: ["C"] });
+    } catch (e) { selfCaught = e; }
+    expect(selfCaught).toBeInstanceOf(ParentCycleError);
+    expect((selfCaught as ParentCycleError).cycle).toEqual(["C", "C"]);
+  });
+
+  it("doctor reports each finding type on a seeded-broken fixture, and stays clean on a healthy one", async () => {
+    // 1. dangling_parent_name — "ghost-parent" is never created as a tag row.
+    await store.upsertTagRecord("orphan-child", { parent_names: ["ghost-parent"] });
+
+    // 2. parent_names_cycle — the write-time guard blocks NEW cycles, so
+    // simulate pre-existing/pre-guard cyclic data with a direct DB write
+    // (same technique core.test.ts's cycle-tolerance tests use).
+    await store.upsertTagRecord("cyc-a", {});
+    await store.upsertTagRecord("cyc-b", { parent_names: ["cyc-a"] });
+    db.prepare("UPDATE tags SET parent_names = ? WHERE name = ?").run(JSON.stringify(["cyc-b"]), "cyc-a");
+
+    // 3. mixed_type_indexed_field — "n" is indexed INTEGER, but this note's
+    // metadata.n is a JSON string. Not `strict`, so the write succeeds with
+    // just an advisory warning — landing exactly the mismatched value.
+    await store.upsertTagRecord("metric", { fields: { n: { type: "integer", indexed: true } } });
+    await store.createNote("bad metric", { tags: ["metric"], metadata: { n: "not-a-number" } });
+
+    // 4. orphaned_indexed_field_declarer — declare directly via the
+    // indexed-fields API, then drop the tag row WITHOUT releasing (the
+    // pre-fix gitcoin state prune-schema's own tests seed identically).
+    declareField(db, "legacy_status", "TEXT", "ghost-declarer");
+
+    // 5. dead_tag_metadata_reference (heuristic) — "epic" holds tag-shaped
+    // values elsewhere (a live tag), so a value that ISN'T a live tag is
+    // the drift signal.
+    await store.upsertTagRecord("launch-v2", {});
+    await store.createNote("current epic", { tags: ["launch-v2"], metadata: { epic: "launch-v2" } });
+    await store.createNote("stale epic reference", { tags: ["launch-v2"], metadata: { epic: "launch-v1" } });
+
+    const report = await store.doctor();
+    const byType = new Map(report.findings.map((f) => [f.type, f]));
+
+    expect(byType.get("dangling_parent_name")?.subject).toBe("orphan-child");
+    expect(byType.get("parent_names_cycle")).toBeDefined();
+    expect(byType.get("mixed_type_indexed_field")?.subject).toBe("n");
+    expect(byType.get("mixed_type_indexed_field")?.severity).toBe("error");
+    expect(byType.get("orphaned_indexed_field_declarer")?.subject).toBe("legacy_status");
+    const driftFinding = byType.get("dead_tag_metadata_reference");
+    expect(driftFinding?.subject).toBe("metadata.epic");
+    expect(driftFinding?.heuristic).toBe(true);
+    expect(driftFinding?.detail).toContain("launch-v1");
+
+    // Every finding type from the fixture is present — five distinct types.
+    expect(byType.size).toBe(5);
+
+    // A fresh, healthy vault reports clean.
+    const cleanDb = new Database(":memory:");
+    const cleanStore = new SqliteStore(cleanDb);
+    await cleanStore.upsertTagRecord("healthy", { description: "nothing wrong here" });
+    await cleanStore.createNote("fine", { tags: ["healthy"] });
+    const cleanReport = await cleanStore.doctor();
+    expect(cleanReport.findings).toEqual([]);
+    expect(cleanReport.summary).toContain("clean");
+  });
 });

package/core/src/contract-typed-index.test.ts

@@ -20,9 +20,11 @@
 import { describe, it, test, expect, beforeEach } from "bun:test";
 import { Database } from "bun:sqlite";
 import { SqliteStore } from "./store.js";
-import { generateMcpTools } from "./mcp.js";
+import { generateMcpTools, SchemaValidationError } from "./mcp.js";
 import { TransitionConflictError } from "./notes.js";
+import * as noteOps from "./notes.js";
 import { TagFieldConflictError } from "./tag-schemas.js";
+import { initSchema, SCHEMA_VERSION } from "./schema.js";
 
 let store: SqliteStore;
 let db: Database;
@@ -91,16 +93,231 @@ describe("contract: typed indexes — passing (lock in current behavior)", () =>
   });
 });
 
-describe("contract: typed indexes — todo (#553)", () => {
-  test.todo(
-    `#553: a write of a TEXT value to an indexed integer field is REJECTED (today: it is accepted with only an advisory type_mismatch warning, and the poisoned row then silently matches {gt: 100}-style range queries via SQLite's TEXT-sorts-above-INTEGER type-affinity ordering — reproduced live: metadata.n = "four" on an indexed integer field succeeds, and query {n: {gt: 100}} incorrectly returns it)`,
-  );
-  test.todo(
-    `#553: an unset enum field stays ABSENT — no first-value backfill — so exists:false correctly matches a note that never set the field (today: applySchemaDefaults in core/src/mcp.ts backfills the schema's first enum value onto every note that gains the tag, so "never set" is indistinguishable from "explicitly set to the default" and exists:false never matches)`,
-  );
-  test.todo(
-    `#553: the indexed-field type list is honest about what's actually indexable (core/src/mcp.ts's update-tag field-type description advertises "string, boolean, integer, number, array, object" but indexed-fields.ts's TYPE_MAP only supports string/integer/boolean — "number" and the container types are accepted as declared but silently un-indexable)`,
-  );
+describe("contract: typed indexes — Decision A: indexed ⇒ strict writes (#553, flipped from todo)", () => {
+  it("a write of a TEXT value to an indexed integer field is REJECTED, not just warned", async () => {
+    await store.upsertTagRecord("metric", { fields: { n: { type: "integer", indexed: true } } });
+    const create = generateMcpTools(store).find((t) => t.name === "create-note")!;
+
+    let err: any;
+    try {
+      await create.execute({ content: "x", tags: ["metric"], metadata: { n: "four" } });
+    } catch (e) {
+      err = e;
+    }
+    expect(err).toBeInstanceOf(SchemaValidationError);
+    expect(err.violations).toHaveLength(1);
+    expect(err.violations[0].field).toBe("n");
+    expect(err.violations[0].reason).toBe("type_mismatch");
+    expect(err.violations[0].strict).toBe(true);
+    // Message names field + expected type + got type.
+    expect(err.violations[0].message).toContain("n");
+    expect(err.violations[0].message).toContain("integer");
+    expect(err.violations[0].message).toContain("string");
+
+    // Nothing was written — the poisoned row never lands, so it can never
+    // sort above a real integer under {gt: 100}-style range queries.
+    const all = await store.queryNotes({ tags: ["metric"] });
+    expect(all).toHaveLength(0);
+  });
+
+  it("rejects the same indexed-type violation on update-note", async () => {
+    await store.upsertTagRecord("metric", { fields: { n: { type: "integer", indexed: true } } });
+    const create = generateMcpTools(store).find((t) => t.name === "create-note")!;
+    const update = generateMcpTools(store).find((t) => t.name === "update-note")!;
+    const note = (await create.execute({ content: "x", tags: ["metric"], metadata: { n: 5 } })) as any;
+
+    await expect(
+      update.execute({ id: note.id, metadata: { n: "four" }, if_updated_at: note.updatedAt }),
+    ).rejects.toThrow(SchemaValidationError);
+
+    // Untouched — still the original, well-typed value.
+    const fresh = await store.getNote(note.id);
+    expect((fresh!.metadata as any).n).toBe(5);
+  });
+
+  it("a range query never matches a TEXT value on an indexed integer field (the poisoning is now unreachable)", async () => {
+    await store.upsertTagRecord("metric", { fields: { n: { type: "integer", indexed: true } } });
+    const create = generateMcpTools(store).find((t) => t.name === "create-note")!;
+    await create.execute({ content: "n=5", tags: ["metric"], metadata: { n: 5 } });
+    await expect(
+      create.execute({ content: "poison", tags: ["metric"], metadata: { n: "four" } }),
+    ).rejects.toThrow(SchemaValidationError);
+
+    const gt100 = await store.queryNotes({ tags: ["metric"], metadata: { n: { gt: 100 } } });
+    expect(gt100).toHaveLength(0);
+  });
+
+  it("a type_mismatch on a NON-indexed field stays advisory (unchanged behavior — the escalation is scoped to indexed:true)", async () => {
+    await store.upsertTagRecord("metric", { fields: { n: { type: "integer" } } });
+    const create = generateMcpTools(store).find((t) => t.name === "create-note")!;
+    const note = (await create.execute({ content: "x", tags: ["metric"], metadata: { n: "four" } })) as any;
+    // Write succeeded — advisory only.
+    expect(note.metadata.n).toBe("four");
+    expect(note.validation_status.warnings[0].reason).toBe("type_mismatch");
+    expect(note.validation_status.warnings[0].strict).toBeUndefined();
+  });
+});
+
+describe("contract: typed indexes — Decision B: explicit-default-only enum backfill (#553, flipped from todo)", () => {
+  it("an unset enum field stays ABSENT — no first-value backfill — so exists:false correctly matches", async () => {
+    await store.upsertTagRecord("task", {
+      fields: { status: { type: "string", enum: ["queued", "done"], indexed: true } }, // no `default`
+    });
+    const create = generateMcpTools(store).find((t) => t.name === "create-note")!;
+    const query = generateMcpTools(store).find((t) => t.name === "query-notes")!;
+
+    const note = (await create.execute({ content: "x", tags: ["task"] })) as any;
+    expect(note.metadata?.status).toBeUndefined();
+    const onDisk = await store.getNote(note.id);
+    expect((onDisk!.metadata as any)?.status).toBeUndefined();
+
+    const unset = (await query.execute({
+      tag: "task",
+      metadata: { status: { exists: false } },
+    })) as any[];
+    expect(unset.map((n) => n.id)).toContain(note.id);
+
+    const set = (await query.execute({
+      tag: "task",
+      metadata: { status: { exists: true } },
+    })) as any[];
+    expect(set.map((n) => n.id)).not.toContain(note.id);
+  });
+
+  it("an EXPLICIT `default:` backfills as before — exists:true matches it", async () => {
+    await store.upsertTagRecord("task", {
+      fields: { status: { type: "string", enum: ["queued", "done"], default: "queued", indexed: true } },
+    });
+    const create = generateMcpTools(store).find((t) => t.name === "create-note")!;
+    const query = generateMcpTools(store).find((t) => t.name === "query-notes")!;
+
+    const note = (await create.execute({ content: "x", tags: ["task"] })) as any;
+    expect(note.metadata.status).toBe("queued");
+
+    const set = (await query.execute({
+      tag: "task",
+      metadata: { status: { exists: true } },
+    })) as any[];
+    expect(set.map((n) => n.id)).toContain(note.id);
+  });
+
+  it("a non-conforming `default` is rejected as a tag-schema error, not silently stored", async () => {
+    const updateTag = generateMcpTools(store).find((t) => t.name === "update-tag")!;
+    let err: any;
+    try {
+      await updateTag.execute({
+        tag: "task",
+        fields: { status: { type: "string", enum: ["queued", "done"], default: "bogus" } },
+      });
+    } catch (e) {
+      err = e;
+    }
+    expect(err).toBeInstanceOf(TagFieldConflictError);
+    expect(err.violations.some((v: any) => v.reason === "invalid_default" && v.field === "status")).toBe(true);
+    // Nothing persisted.
+    expect((await store.getTagRecord("task"))?.fields ?? null).toBeFalsy();
+  });
+});
+
+describe("contract: typed indexes — Decision C: honest type list (#553, flipped from todo)", () => {
+  it("the update-tag field-type description clarifies only string/integer/boolean are indexable", () => {
+    const updateTag = generateMcpTools(store).find((t) => t.name === "update-tag")!;
+    const typeDesc = (updateTag.inputSchema as any).properties.fields.additionalProperties.properties.type.description as string;
+    // Honest about the full storage/advisory vocabulary AND the indexable subset.
+    expect(typeDesc).toContain("number");
+    expect(typeDesc).toContain("Only string/integer/boolean are INDEXABLE");
+  });
+
+  it("declaring indexed:true with an unindexable type (number) is rejected", async () => {
+    const updateTag = generateMcpTools(store).find((t) => t.name === "update-tag")!;
+    let err: any;
+    try {
+      await updateTag.execute({ tag: "metric", fields: { score: { type: "number", indexed: true } } });
+    } catch (e) {
+      err = e;
+    }
+    expect(err).toBeInstanceOf(TagFieldConflictError);
+    expect(err.violations[0].reason).toBe("unsupported_indexed_type");
+  });
+
+  it("declaring a number field WITHOUT indexed:true is accepted (storage/advisory only)", async () => {
+    const updateTag = generateMcpTools(store).find((t) => t.name === "update-tag")!;
+    const result = await updateTag.execute({ tag: "metric", fields: { score: { type: "number" } } }) as any;
+    expect(result.fields.score.type).toBe("number");
+  });
+});
+
+describe("contract: typed indexes — Decision D: migrateToV24 poison coercion (#553, new)", () => {
+  it("coerces a lossless numeric string, leaves a genuinely non-coercible string, and is idempotent on re-run", async () => {
+    // Declare the field indexed AFTER notes already exist (real-data-like:
+    // a field indexed retroactively on a vault with pre-existing rows).
+    const clean = noteOps.createNote(db, "clean", { metadata: { n: 42 } });
+    const coercible = noteOps.createNote(db, "coercible", { metadata: { n: "5" } }); // clean numeric string
+    const nonCoercible = noteOps.createNote(db, "non-coercible", { metadata: { n: "hello" } });
+    const boolish = noteOps.createNote(db, "boolish", { metadata: { flag: "true" } });
+
+    await store.upsertTagRecord("metric", {
+      fields: {
+        n: { type: "integer", indexed: true },
+        flag: { type: "boolean", indexed: true },
+      },
+    });
+    noteOps.tagNote(db, clean.id, ["metric"]);
+    noteOps.tagNote(db, coercible.id, ["metric"]);
+    noteOps.tagNote(db, nonCoercible.id, ["metric"]);
+    noteOps.tagNote(db, boolish.id, ["metric"]);
+
+    // Re-running initSchema (idempotent by construction for every migration
+    // step) exercises migrateToV24's coercion pass over the poison just
+    // planted via the raw noteOps layer (bypassing the strict write gate —
+    // simulating data that predates it, or an operator-side bulk import).
+    initSchema(db);
+
+    const after = (id: string) => (noteOps.getNote(db, id)!.metadata as any);
+    expect(after(clean.id).n).toBe(42); // untouched — was already clean
+    expect(after(coercible.id).n).toBe(5); // coerced: "5" (string) → 5 (number)
+    expect(after(nonCoercible.id).n).toBe("hello"); // LEFT IN PLACE — never deleted or nulled
+    expect(after(boolish.id).flag).toBe(true); // coerced: "true" (string) → true (boolean)
+
+    // Doctor still surfaces the genuinely non-coercible one for operator cleanup.
+    const report = await store.doctor();
+    const finding = report.findings.find(
+      (f) => f.type === "mixed_type_indexed_field" && f.subject === "n",
+    );
+    expect(finding).toBeDefined();
+    expect(finding!.detail).toContain(nonCoercible.id);
+
+    // Idempotency: a second re-run coerces nothing further and doesn't
+    // touch the already-clean/already-coerced/already-left values.
+    initSchema(db);
+    expect(after(clean.id).n).toBe(42);
+    expect(after(coercible.id).n).toBe(5);
+    expect(after(nonCoercible.id).n).toBe("hello");
+    expect(after(boolish.id).flag).toBe(true);
+  });
+
+  it("coerces a number into a TEXT-indexed field losslessly", async () => {
+    const note = noteOps.createNote(db, "x", { metadata: { code: 12345 } });
+    await store.upsertTagRecord("item", { fields: { code: { type: "string", indexed: true } } });
+    noteOps.tagNote(db, note.id, ["item"]);
+
+    initSchema(db);
+    expect((noteOps.getNote(db, note.id)!.metadata as any).code).toBe("12345");
+  });
+
+  it("leaves array/object values in an indexed field untouched (never coercible, never deleted)", async () => {
+    const note = noteOps.createNote(db, "x", { metadata: { n: [1, 2, 3] } });
+    await store.upsertTagRecord("metric", { fields: { n: { type: "integer", indexed: true } } });
+    noteOps.tagNote(db, note.id, ["metric"]);
+
+    initSchema(db);
+    expect((noteOps.getNote(db, note.id)!.metadata as any).n).toEqual([1, 2, 3]);
+  });
+
+  it("is a no-op on a vault with zero indexed fields (schema_version still advances)", async () => {
+    const row = db.prepare("SELECT version FROM schema_version ORDER BY version DESC LIMIT 1").get() as { version: number };
+    expect(row.version).toBe(SCHEMA_VERSION);
+  });
 });
 
 describe("contract: update-tag messaging — #553/#554 (flipped from todo)", () => {