@openparachute/vault 0.7.0-rc.7 → 0.7.0-rc.8

package/src/tag-scope.ts

@@ -83,6 +83,66 @@ export function filterNotesByTagScope<T extends Note>(
   return notes.filter((n) => noteWithinTagScope(n, allowed, rawRoots));
 }
 
+/**
+ * Is a SINGLE tag name visible to this token? The per-tag core of
+ * `noteWithinTagScope` — exact allowlist membership OR string-form root
+ * match — pulled out so the `validation_status` scrub below (which reasons
+ * about a warning's `schema`/`loser_schema` tag NAMES, not a note's whole
+ * tag set) uses the identical visibility rule. `rawRoots === null` (unscoped)
+ * → always visible.
+ */
+function tagVisibleInScope(
+  tag: string,
+  allowed: Set<string> | null,
+  rawRoots: string[] | null,
+): boolean {
+  if (rawRoots === null) return true;
+  if (allowed && allowed.has(tag)) return true;
+  const root = tag.split("/")[0];
+  return !!root && rawRoots.includes(root);
+}
+
+/**
+ * Scrub a note's `validation_status` so a tag-scoped caller can't learn the
+ * SCHEMA SHAPE (field name, type, enum values) of an OUT-OF-SCOPE tag that
+ * happens to co-tag a note it can otherwise see (vault#555 auth review;
+ * the #560 leak class). Repro: a scoped caller reading a note tagged both
+ * `mine` (in scope) and `project-manhattan` (out of scope) received
+ * `validation_status.warnings: [{ schema: "project-manhattan", message:
+ * "'codeword' must be one of [fizzbuzz] ...", ... }]` and
+ * `schemas: ["project-manhattan"]` — leaking that tag's field/enum.
+ *
+ * Core produces the FULL status (scope-unaware by architecture, same as
+ * every other core surface); this server-layer scrub — mirroring
+ * `scrubTagFieldViolationsByScope` — drops any warning whose declaring
+ * tag (`schema`, and for a `schema_conflict` the overridden `loser_schema`)
+ * is out of scope, and filters the `schemas` array to visible tags. When
+ * nothing in-scope remains (the note's only schema-declaring tag was
+ * out-of-scope), returns `undefined` so the caller omits `validation_status`
+ * entirely — byte-identical to a note with no applicable schema. Unscoped
+ * callers (`rawRoots === null`) get the status untouched.
+ *
+ * Applied at every point a scoped caller receives `validation_status`: the
+ * MCP `query-notes` wrapper and the REST `GET /notes[/{id}]` read paths.
+ */
+export function scrubValidationStatusByScope<
+  S extends { schemas: string[]; warnings: Array<{ schema: string; loser_schema?: string }> },
+>(
+  status: S | null | undefined,
+  allowed: Set<string> | null,
+  rawRoots: string[] | null,
+): S | undefined {
+  if (!status || rawRoots === null) return status ?? undefined;
+  const schemas = status.schemas.filter((s) => tagVisibleInScope(s, allowed, rawRoots));
+  const warnings = status.warnings.filter(
+    (w) =>
+      tagVisibleInScope(w.schema, allowed, rawRoots) &&
+      (w.loser_schema === undefined || tagVisibleInScope(w.loser_schema, allowed, rawRoots)),
+  );
+  if (schemas.length === 0 && warnings.length === 0) return undefined;
+  return { ...status, schemas, warnings };
+}
+
 /**
  * For write paths: a note being created/updated must end up carrying at
  * least one tag inside the allowlist. `tags` is the post-write tag set

package/src/vault.test.ts

@@ -1554,7 +1554,16 @@ describe("scoped MCP wrapper", async () => {
     closeAllStores();
   });
 
-  test("update-note tags.add auto-populate does not bump updatedAt", async () => {
+  // vault#555 fix 2 REVISED this test's contract. Pre-fix-2 a tags-only
+  // `update-note` (here, adding a tag that ALSO triggers a schema-default
+  // backfill) did NOT bump `updated_at` — this test asserted that. Fix 2
+  // makes ANY tag mutation bump `updated_at` (so cursor/sync loops see it);
+  // the separate defaults backfill still rides `skipUpdatedAt: true` and
+  // doesn't itself bump. Net: the tag add bumps updatedAt exactly once, and
+  // the default still lands. (The old assertion passed only by
+  // create+update landing in the same millisecond — a latent flake fix 2
+  // turned into a real contradiction; caught on a review re-run.)
+  test("update-note tags.add bumps updatedAt AND still applies the schema default (vault#555 fix 2)", async () => {
     const { generateScopedMcpTools } = await import("./mcp-tools.ts");
     const { writeVaultConfig } = await import("./config.ts");
     const { getVaultStore, closeAllStores: close } = await import("./vault-store.ts");
@@ -1568,8 +1577,7 @@ describe("scoped MCP wrapper", async () => {
 
     const vaultStore = getVaultStore(vaultName);
     // vault#553 Decision B: backfill is explicit-`default`-only — declare
-    // one so this test still exercises an actual defaults-write (and can
-    // assert it lands without bumping updatedAt).
+    // one so this still exercises an actual defaults-write.
     await vaultStore.upsertTagSchema("person", {
       description: "A person",
       fields: { name: { type: "string", default: "unknown" } },
@@ -1582,9 +1590,13 @@ describe("scoped MCP wrapper", async () => {
 
     const note = await createNote.execute({ content: "Test" }) as any;
     const originalUpdatedAt = note.updatedAt;
+    await new Promise((r) => setTimeout(r, 5)); // deterministic ms gap
     await updateNote.execute({ id: note.id, tags: { add: ["person"] }, force: true });
     const after = await queryNotes.execute({ id: note.id }) as any;
-    expect(after.updatedAt).toBe(originalUpdatedAt);
+    // Fix 2: the tag mutation bumped updatedAt.
+    expect(after.updatedAt).not.toBe(originalUpdatedAt);
+    expect(new Date(after.updatedAt) > new Date(originalUpdatedAt)).toBe(true);
+    // The schema default still backfilled.
     expect(after.metadata.name).toBe("unknown");
 
     close();
@@ -1726,6 +1738,83 @@ describe("scoped MCP wrapper", async () => {
 
     closeAllStores();
   });
+
+  // vault#555 auth review — validation_status must not leak an out-of-scope
+  // co-tag's schema shape (field name / type / enum) to a scoped caller
+  // (the #560 leak class). A note the caller CAN see (in-scope tag) may also
+  // carry an out-of-scope tag whose schema it violates.
+  test("MCP query-notes scrubs out-of-scope tag schema from validation_status; only the in-scope tag's warning survives", async () => {
+    const { generateScopedMcpTools } = await import("./mcp-tools.ts");
+    const { writeVaultConfig } = await import("./config.ts");
+    const { getVaultStore, closeAllStores } = await import("./vault-store.ts");
+
+    const vaultName = `tagscope-vs-${Date.now()}`;
+    writeVaultConfig({ name: vaultName, api_keys: [], created_at: new Date().toISOString() });
+    const store = getVaultStore(vaultName);
+    // In-scope tag "work" declares a field the note violates; out-of-scope
+    // "project-manhattan" declares a SECRET field/enum the note also violates.
+    await store.upsertTagSchema("work", { fields: { priority: { type: "string", enum: ["hi", "lo"] } } });
+    await store.upsertTagSchema("project-manhattan", { fields: { codeword: { type: "string", enum: ["fizzbuzz"] } } });
+    const note = await store.createNote("co-tagged", {
+      path: "CoTagged",
+      tags: ["work", "project-manhattan"],
+      metadata: { priority: "URGENT", codeword: "leaked" },
+    });
+
+    const tools = generateScopedMcpTools(vaultName, authForTags(["work"]) as any);
+    const query = tools.find((t) => t.name === "query-notes")!;
+    const result = await query.execute({ id: note.id }) as any;
+
+    // The out-of-scope tag's SCHEMA SHAPE — the leak fix 3 introduced and
+    // this scrub closes — must appear nowhere in the whole response.
+    // `fizzbuzz` (its enum value) exists ONLY in project-manhattan's schema,
+    // so its total absence proves no schema-shape leak. (`codeword` is also
+    // a key in the note's OWN metadata, visible to anyone who can read the
+    // note, so it's not a schema-shape indicator.)
+    const serialized = JSON.stringify(result);
+    expect(serialized).not.toContain("fizzbuzz");
+    // The tag NAME must be gone from validation_status specifically. NOTE:
+    // it still appears in the note's `.tags` array — that's PRE-EXISTING
+    // scoped-read behavior (noteWithinTagScope has never scrubbed a returned
+    // note's tag set), independent of fix 3, and out of scope for this fix.
+    expect(JSON.stringify(result.validation_status)).not.toContain("project-manhattan");
+
+    // The in-scope tag's own warning DOES survive.
+    const vs = result.validation_status;
+    expect(vs).toBeTruthy();
+    expect(vs.schemas).toEqual(["work"]);
+    expect(vs.warnings).toHaveLength(1);
+    expect(vs.warnings[0].schema).toBe("work");
+    expect(vs.warnings[0].field).toBe("priority");
+
+    closeAllStores();
+  });
+
+  test("UNSCOPED query-notes still surfaces BOTH co-tags' validation_status (regression)", async () => {
+    const { generateScopedMcpTools } = await import("./mcp-tools.ts");
+    const { writeVaultConfig } = await import("./config.ts");
+    const { getVaultStore, closeAllStores } = await import("./vault-store.ts");
+
+    const vaultName = `tagscope-vs-unscoped-${Date.now()}`;
+    writeVaultConfig({ name: vaultName, api_keys: [], created_at: new Date().toISOString() });
+    const store = getVaultStore(vaultName);
+    await store.upsertTagSchema("work", { fields: { priority: { type: "string", enum: ["hi", "lo"] } } });
+    await store.upsertTagSchema("project-manhattan", { fields: { codeword: { type: "string", enum: ["fizzbuzz"] } } });
+    const note = await store.createNote("co-tagged", {
+      path: "CoTagged",
+      tags: ["work", "project-manhattan"],
+      metadata: { priority: "URGENT", codeword: "leaked" },
+    });
+
+    const tools = generateScopedMcpTools(vaultName); // unscoped
+    const query = tools.find((t) => t.name === "query-notes")!;
+    const result = await query.execute({ id: note.id }) as any;
+    const vs = result.validation_status;
+    expect(vs.schemas.sort()).toEqual(["project-manhattan", "work"]);
+    expect(vs.warnings).toHaveLength(2);
+
+    closeAllStores();
+  });
 });
 
 describe("auth permissions", () => {
@@ -4185,6 +4274,34 @@ describe("HTTP PATCH /notes/:idOrPath (update)", async () => {
     expect(body.tags).not.toContain("old");
   });
 
+  // vault#555 fix 2 — a tags-only (or links-only) PATCH with `force: true`
+  // (no `if_updated_at`) used to leave `updated_at` frozen: `updates` had no
+  // core fields, so `store.updateNote` was never called at all.
+  test("PATCH tags-only/links-only with force:true bumps updated_at", async () => {
+    await store.createNote("x", { id: "x", tags: ["old"] });
+    await store.createNote("y", { id: "y" });
+    const before = (await store.getNote("x"))!.updatedAt;
+    await new Promise((r) => setTimeout(r, 5));
+
+    const tagsRes = await handleNotes(
+      mkReq("PATCH", "/notes/x", { tags: { add: ["new"] }, force: true }),
+      store,
+      "/x",
+    );
+    const tagsBody = await tagsRes.json() as any;
+    expect(tagsBody.updatedAt).not.toBe(before);
+    expect(new Date(tagsBody.updatedAt) > new Date(before)).toBe(true);
+
+    await new Promise((r) => setTimeout(r, 5));
+    const linksRes = await handleNotes(
+      mkReq("PATCH", "/notes/x", { links: { add: [{ target: "y", relationship: "mentions" }] }, force: true }),
+      store,
+      "/x",
+    );
+    const linksBody = await linksRes.json() as any;
+    expect(new Date(linksBody.updatedAt) > new Date(tagsBody.updatedAt)).toBe(true);
+  });
+
   test("PATCH adds/removes links", async () => {
     await store.createNote("a", { id: "a" });
     await store.createNote("b", { id: "b" });
@@ -4248,6 +4365,59 @@ describe("HTTP PATCH /notes/:idOrPath (update)", async () => {
     expect(body.links[0].targetId).toBe("c");
   });
 
+  // vault#555 — REST PATCH links.add gets the same basename/title
+  // resolution + lazy forward-ref queueing as the MCP update-note tool
+  // (both surfaces share core/wikilinks.ts's resolveOrQueueLink).
+  test("PATCH links.add resolves by BASENAME and warns+queues when unresolvable", async () => {
+    await store.createNote("a", { id: "a" });
+    await store.createNote("Bob's note", { path: "People/Bob" });
+    const byTitle = await handleNotes(
+      mkReq("PATCH", "/notes/a", { links: { add: [{ target: "Bob", relationship: "knows" }] }, force: true }),
+      store,
+      "/a",
+    );
+    expect(byTitle.status).toBe(200);
+    const byTitleBody = await byTitle.json() as any;
+    expect(byTitleBody.warnings).toBeUndefined();
+    expect(await store.getLinks("a", { direction: "outbound" })).toHaveLength(1);
+
+    const unresolved = await handleNotes(
+      mkReq("PATCH", "/notes/a", { links: { add: [{ target: "Not Yet Real", relationship: "wants" }] }, force: true }),
+      store,
+      "/a",
+    );
+    const unresolvedBody = await unresolved.json() as any;
+    expect(unresolvedBody.warnings).toBeDefined();
+    expect(unresolvedBody.warnings[0].code).toBe("unresolved_link");
+    expect(unresolvedBody.warnings[0].target).toBe("Not Yet Real");
+
+    const target = await store.createNote("arrived", { path: "Not Yet Real" });
+    const links = await store.getLinks("a", { direction: "outbound" });
+    expect(links.some((l) => l.targetId === target.id && l.relationship === "wants")).toBe(true);
+  });
+
+  // vault#555 — POST /notes batch: a link to a note created LATER in the
+  // same batch must resolve (forward-ref), matching MCP create-note.
+  test("POST /notes batch: a link to a note created LATER in the same batch resolves (forward-ref)", async () => {
+    const res = await handleNotes(
+      mkReq("POST", "/notes", {
+        notes: [
+          { path: "RestA", content: "links to RestB", links: [{ target: "RestB", relationship: "knows" }] },
+          { path: "RestB", content: "the target" },
+        ],
+      }),
+      store,
+      "",
+    );
+    expect(res.status).toBe(201);
+    const body = await res.json() as any[];
+    const a = body.find((n: any) => n.path === "RestA");
+    expect(a.warnings).toBeUndefined();
+    const links = await store.getLinks(a.id, { direction: "outbound" });
+    expect(links).toHaveLength(1);
+    expect(links[0]!.relationship).toBe("knows");
+  });
+
   test("PATCH without a link mutation or flag does NOT include links", async () => {
     await store.createNote("a", { id: "a" });
     await store.createNote("b", { id: "b" });
@@ -4436,6 +4606,42 @@ describe("HTTP PATCH /notes/:idOrPath (update)", async () => {
     expect((await store.getNote("x"))!.content).toBe("hi hi");
   });
 
+  // vault#555 fix 7 (INVESTIGATE) — a tester reported "old_text not found"
+  // failing 7/8 for batch/parallel content_edit calls sharing the same
+  // old_text. Not reproducible against DIFFERENT notes (see
+  // core/src/core.test.ts's matching investigation for the full writeup
+  // and the "SAME note" control that DOES reproduce "1 succeeds, 7 fail" —
+  // correct behavior, likely what the original report actually hit). REST
+  // parity check here: N parallel PATCH requests, same old_text, different
+  // notes, all succeed.
+  test("PATCH parallel: N concurrent content_edit calls with the SAME old_text on DIFFERENT notes all succeed", async () => {
+    const N = 8;
+    const notes = [];
+    for (let i = 0; i < N; i++) {
+      notes.push(await store.createNote(`prefix TARGET_TEXT suffix-${i}`, { path: `rest-ce-${i}` }));
+    }
+
+    const results = await Promise.all(
+      notes.map((n) =>
+        handleNotes(
+          mkReq("PATCH", `/notes/${n.id}`, {
+            content_edit: { old_text: "TARGET_TEXT", new_text: "REPLACED" },
+            force: true,
+          }),
+          store,
+          `/${n.id}`,
+        ),
+      ),
+    );
+    for (const res of results) {
+      expect(res.status).toBe(200);
+    }
+    for (let i = 0; i < N; i++) {
+      const fresh = await store.getNote(notes[i]!.id);
+      expect(fresh!.content).toBe(`prefix REPLACED suffix-${i}`);
+    }
+  });
+
   test("PATCH rejects content + append combination with 400", async () => {
     await store.createNote("seed", { id: "x" });
 
@@ -4618,6 +4824,87 @@ describe("HTTP PATCH /notes/:idOrPath (update)", async () => {
   });
 });
 
+// vault#555 fix 3 — validation_status used to be visible ONLY on the
+// one-time create/update WRITE response; a caller reading the note back
+// (GET single note, or the structured-query list) saw nothing at all,
+// contradicting "advisory violations surface as warnings" for an
+// enum_mismatch on a non-strict (even indexed) field.
+describe("HTTP GET /notes — validation_status on reads (vault#555)", async () => {
+  test("GET /notes/:id surfaces validation_status (enum_mismatch on an indexed field)", async () => {
+    const res0 = await handleTags(
+      mkReq("PUT", "/tags/widget555", { fields: { status: { type: "string", enum: ["a", "b"], indexed: true } } }),
+      store,
+      "/widget555",
+    );
+    expect(res0.status).toBe(200);
+    const created = await store.createNote("x", { tags: ["widget555"], metadata: { status: "bogus" } });
+
+    const res = await handleNotes(mkReq("GET", `/notes/${created.id}`), store, `/${created.id}`);
+    expect(res.status).toBe(200);
+    const body = await res.json() as any;
+    expect(body.validation_status?.warnings?.[0]?.reason).toBe("enum_mismatch");
+    expect(body.validation_status.warnings[0].field).toBe("status");
+  });
+
+  test("GET /notes (structured query list) surfaces validation_status per note", async () => {
+    await store.upsertTagSchema("task555list", {
+      fields: { priority: { type: "string", enum: ["high", "low"] } },
+    });
+    await store.createNote("x", { tags: ["task555list"], metadata: { priority: "ULTRA" } });
+
+    const res = await handleNotes(mkReq("GET", "/notes?tag=task555list"), store, "");
+    expect(res.status).toBe(200);
+    const body = await res.json() as any[];
+    expect(body).toHaveLength(1);
+    expect(body[0].validation_status?.warnings?.[0]?.reason).toBe("enum_mismatch");
+  });
+
+  test("GET /notes/:id and list both omit validation_status when no tag declares fields", async () => {
+    const note = await store.createNote("plain", { tags: ["plain555"] });
+    const single = await handleNotes(mkReq("GET", `/notes/${note.id}`), store, `/${note.id}`);
+    const singleBody = await single.json() as any;
+    expect(singleBody.validation_status).toBeUndefined();
+
+    const list = await handleNotes(mkReq("GET", "/notes?tag=plain555"), store, "");
+    const listBody = await list.json() as any[];
+    expect(listBody[0].validation_status).toBeUndefined();
+  });
+
+  // vault#555 auth review — REST parity for the validation_status scope
+  // scrub (the #560 leak class). A scoped caller reading a note co-tagged
+  // with an out-of-scope tag must not learn that tag's schema shape.
+  test("GET /notes/:id and list scrub out-of-scope co-tag schema from validation_status for a scoped caller", async () => {
+    await store.upsertTagSchema("workrs", { fields: { priority: { type: "string", enum: ["hi", "lo"] } } });
+    await store.upsertTagSchema("manhattanrs", { fields: { codeword: { type: "string", enum: ["fizzbuzz"] } } });
+    const note = await store.createNote("co-tagged", {
+      path: "CoTaggedRS",
+      tags: ["workrs", "manhattanrs"],
+      metadata: { priority: "URGENT", codeword: "leaked" },
+    });
+    const scope = { allowed: new Set(["workrs"]), raw: ["workrs"] };
+
+    // Single GET — `fizzbuzz` (the out-of-scope enum value) exists only in
+    // manhattanrs's schema, so its absence proves no schema-shape leak. The
+    // tag name is scrubbed from validation_status (still in `.tags` —
+    // pre-existing, out of scope; see the MCP counterpart test).
+    const single = await handleNotes(mkReq("GET", `/notes/${note.id}`), store, `/${note.id}`, undefined, scope);
+    const singleBody = await single.json() as any;
+    expect(JSON.stringify(singleBody)).not.toContain("fizzbuzz");
+    expect(JSON.stringify(singleBody.validation_status)).not.toContain("manhattanrs");
+    expect(singleBody.validation_status.schemas).toEqual(["workrs"]);
+    expect(singleBody.validation_status.warnings).toHaveLength(1);
+    expect(singleBody.validation_status.warnings[0].field).toBe("priority");
+
+    // List GET
+    const list = await handleNotes(mkReq("GET", "/notes?tag=workrs&include_content=true"), store, "", undefined, scope);
+    const listBody = await list.json() as any[];
+    expect(JSON.stringify(listBody)).not.toContain("fizzbuzz");
+    const target = listBody.find((n) => n.id === note.id);
+    expect(JSON.stringify(target.validation_status)).not.toContain("manhattanrs");
+    expect(target.validation_status.schemas).toEqual(["workrs"]);
+  });
+});
+
 describe("HTTP POST /notes — validation_status attachment (vault#287)", async () => {
   // Mirror of the PATCH cases for create. The MCP create-note path
   // attaches validation_status; HTTP POST must match (vault#287).