@openparachute/vault 0.6.4-rc.1 → 0.6.4-rc.3

package/README.md

@@ -273,6 +273,31 @@ description: |
 
 Sent as the MCP server instruction at session start.
 
+### Schema enforcement & state machines (vault#299)
+
+Tag-field schemas (`update-tag`'s `fields`) are **advisory by default** — a violating write succeeds and the response carries `validation_status` warnings the agent can self-correct on. That's right for organic single-vault use. Once a vault has multiple writers (humans + agents), opt individual fields into **strict** enforcement:
+
+```yaml
+tag: concept-seed
+fields:
+  state:    { type: string, enum: [idea, drafted, scripted, produced, published, killed], strict: true }
+  title:    { type: string, required: true, strict: true }
+  owners:   { type: array,  cardinality: many, strict: true }
+  priority: { type: number }   # advisory (default)
+  notes:    { type: string }   # advisory — free-form stays free-form
+```
+
+`strict: true` flips **all** of that field's declared constraints together — `type` + `enum` + `required` + `cardinality` — from warnings to hard write rejections (all-or-nothing per field). A violating create/update is rejected with a single `schema_validation` error carrying **every** per-field violation (MCP `data.error_type: "schema_validation"` / HTTP 422), and nothing is written. Strictness is **per-field**, so a free-form `notes` field stays advisory on an otherwise-strict tag. Declared strict fields surface in `vault-info` and the connect-time brief so an agent knows the contract before writing.
+
+**Migration bypass.** A token holding the `vault:migrate` scope (broad) or `vault:<name>:migrate` (narrowed) skips strict enforcement — for backfilling/migrating existing non-conforming notes. It's an orthogonal capability (an `admin` token does **not** bypass unless it also holds `migrate`), and every bypassed write is logged to the daemon's structured log (`[schema-bypass] {...}` with the actor/via and waived violations) for later audit.
+
+**Compare-and-set state transitions.** Advance a state machine race-safely in one round trip instead of read → check → conditional update. `update-note`'s `state_transition: { field, from, to }` atomically sets `field` to `to` **only if** it currently equals `from`; otherwise it's rejected with a distinct `transition_conflict` error. A **missing field** counts as a conflict; pass `from: null` to match a field that is absent or explicitly null. A **transition-only** update needs no `if_updated_at`/`force` — the compare-and-set IS the precondition. Combinable with other field updates in the same call (they land in the same atomic UPDATE), but a combined call still needs `if_updated_at`/`force` for the *other* fields — the CAS only guards the transitioned field, not the rest of the merge.
+
+```jsonc
+// advance a seed from idea → drafted, race-safely
+update-note { "id": "Seeds/my-idea", "state_transition": { "field": "state", "from": "idea", "to": "drafted" } }
+```
+
 ## Features
 
 ### Wikilink auto-linking
@@ -321,7 +346,19 @@ triggers:
       send: content
 ```
 
-**Predicate fields**: `tags` (all must match), `has_content` (true/false), `missing_metadata` (keys that must be absent), `has_metadata` (keys that must be present).
+**Predicate fields**: `tags` (all must match), `has_content` (true/false), `missing_metadata` (keys that must be absent), `has_metadata` (keys that must be present), and `metadata` (value-matched — a field → operator-object map using the same operators as `query-notes`: `eq/ne/gt/gte/lt/lte/in/not_in/exists`). All predicate fields are ANDed. Value-matching lets a trigger fire on a specific transition rather than every edit (vault#299):
+
+```yaml
+  - name: announce-published
+    events: [updated]
+    when:
+      tags: [piece]
+      metadata:
+        state: { eq: published }     # fire only when state reaches "published"
+      missing_metadata: [announced_at]
+    action:
+      webhook: https://example.com/announce
+```
 
 **Two-phase markers**: On match, the trigger sets `<name>_pending_at` metadata before calling the webhook, then replaces it with `<name>_rendered_at` on success. This prevents re-entry and concurrent runs.
 

package/core/src/attribution.test.ts

@@ -0,0 +1,273 @@
+/**
+ * Write-attribution (vault#298) — per-identity (`*_by`) + per-interface
+ * (`*_via`) provenance at the store layer.
+ *
+ * Covers the core contract:
+ *   - create stamps BOTH axes onto created_* AND mirrors into last_updated_*
+ *   - update bumps ONLY last_updated_* (created_* is set-once)
+ *   - a `skipUpdatedAt` machine write does NOT claim authorship
+ *   - no-attribution writes leave the columns NULL (never "")
+ *   - the four query-notes filters (created_by / last_updated_by /
+ *     created_via / last_updated_via)
+ *   - legacy rows written before the v23 migration stay NULL and don't crash
+ *   - the cursor binds the attribution filters (changing them invalidates it)
+ *
+ * The auth → AuthResult → MCP/REST threading is exercised separately in
+ * src/attribution-threading.test.ts (it needs the server-side auth context).
+ */
+import { describe, it, expect, beforeEach } from "bun:test";
+import { Database } from "bun:sqlite";
+import { SqliteStore } from "./store.js";
+import { initSchema, SCHEMA_VERSION } from "./schema.js";
+
+let store: SqliteStore;
+let db: Database;
+
+beforeEach(() => {
+  db = new Database(":memory:");
+  store = new SqliteStore(db);
+});
+
+function rawRow(id: string) {
+  return db
+    .prepare(
+      "SELECT created_by, created_via, last_updated_by, last_updated_via FROM notes WHERE id = ?",
+    )
+    .get(id) as {
+    created_by: string | null;
+    created_via: string | null;
+    last_updated_by: string | null;
+    last_updated_via: string | null;
+  };
+}
+
+describe("write-attribution — schema", () => {
+  it("bumped SCHEMA_VERSION to 23", () => {
+    expect(SCHEMA_VERSION).toBe(23);
+  });
+
+  it("the four columns exist and are indexed", () => {
+    const cols = (db.prepare("PRAGMA table_info(notes)").all() as { name: string }[]).map(
+      (r) => r.name,
+    );
+    expect(cols).toContain("created_by");
+    expect(cols).toContain("created_via");
+    expect(cols).toContain("last_updated_by");
+    expect(cols).toContain("last_updated_via");
+
+    const idx = (
+      db
+        .prepare("SELECT name FROM sqlite_master WHERE type='index' AND tbl_name='notes'")
+        .all() as { name: string }[]
+    ).map((r) => r.name);
+    expect(idx).toContain("idx_notes_created_by");
+    expect(idx).toContain("idx_notes_created_via");
+    expect(idx).toContain("idx_notes_last_updated_by");
+    expect(idx).toContain("idx_notes_last_updated_via");
+  });
+});
+
+describe("write-attribution — per-identity (WHO) + per-interface (VIA)", () => {
+  it("create captures actor + via on BOTH the created_* and last_updated_* pairs", async () => {
+    const note = await store.createNote("hi", { actor: "aaron", via: "mcp" });
+    // Read-model surfaces both axes.
+    expect(note.createdBy).toBe("aaron");
+    expect(note.createdVia).toBe("mcp");
+    // First write IS the most-recent write — mirrored.
+    expect(note.lastUpdatedBy).toBe("aaron");
+    expect(note.lastUpdatedVia).toBe("mcp");
+
+    const row = rawRow(note.id);
+    expect(row.created_by).toBe("aaron");
+    expect(row.created_via).toBe("mcp");
+    expect(row.last_updated_by).toBe("aaron");
+    expect(row.last_updated_via).toBe("mcp");
+  });
+
+  it("update bumps last_updated_* but leaves created_* untouched (set-once)", async () => {
+    const note = await store.createNote("v1", { actor: "aaron", via: "mcp" });
+    const updated = await store.updateNote(note.id, {
+      content: "v2",
+      actor: "mathilda",
+      via: "surface:meeting-ingest",
+    });
+
+    // created_* pins the ORIGINAL author/channel forever.
+    expect(updated.createdBy).toBe("aaron");
+    expect(updated.createdVia).toBe("mcp");
+    // last_updated_* reflects the most recent writer.
+    expect(updated.lastUpdatedBy).toBe("mathilda");
+    expect(updated.lastUpdatedVia).toBe("surface:meeting-ingest");
+
+    const row = rawRow(note.id);
+    expect(row.created_by).toBe("aaron");
+    expect(row.last_updated_by).toBe("mathilda");
+    expect(row.last_updated_via).toBe("surface:meeting-ingest");
+  });
+
+  it("append/prepend updates also record the most-recent author", async () => {
+    const note = await store.createNote("base", { actor: "aaron", via: "mcp" });
+    const after = await store.updateNote(note.id, {
+      append: " +more",
+      actor: "agent:nightly",
+      via: "agent:nightly",
+    });
+    expect(after.content).toBe("base +more");
+    expect(after.createdBy).toBe("aaron");
+    expect(after.lastUpdatedBy).toBe("agent:nightly");
+    expect(after.lastUpdatedVia).toBe("agent:nightly");
+  });
+
+  it("a skipUpdatedAt machine write does NOT claim authorship", async () => {
+    const note = await store.createNote("x", { actor: "aaron", via: "mcp" });
+    const before = rawRow(note.id);
+    // A hook-style marker write: passes actor/via but skipUpdatedAt — should
+    // not bump updated_at NOR rewrite last_updated_*.
+    await store.updateNote(note.id, {
+      metadata: { marker: true },
+      skipUpdatedAt: true,
+      actor: "some-hook",
+      via: "operator",
+    });
+    const after = rawRow(note.id);
+    expect(after.last_updated_by).toBe(before.last_updated_by); // still "aaron"
+    expect(after.last_updated_by).toBe("aaron");
+    expect(after.last_updated_via).toBe("mcp");
+  });
+
+  it("an attribution-less update honestly clears the most-recent author (NULL, not stale)", async () => {
+    const note = await store.createNote("x", { actor: "aaron", via: "mcp" });
+    // A real edit arriving with no attribution context — the latest writer is
+    // unknown; we must NOT leave "aaron" as the apparent last editor.
+    const after = await store.updateNote(note.id, { content: "y" });
+    expect(after.createdBy).toBe("aaron"); // original author preserved
+    expect(after.lastUpdatedBy).toBeNull();
+    expect(after.lastUpdatedVia).toBeNull();
+  });
+});
+
+describe("write-attribution — no context → NULL (never empty string)", () => {
+  it("create without actor/via leaves all four columns NULL", async () => {
+    const note = await store.createNote("anon");
+    const row = rawRow(note.id);
+    expect(row.created_by).toBeNull();
+    expect(row.created_via).toBeNull();
+    expect(row.last_updated_by).toBeNull();
+    expect(row.last_updated_via).toBeNull();
+    expect(note.createdBy).toBeNull();
+    expect(note.createdVia).toBeNull();
+  });
+
+  it("empty / whitespace-only actor/via normalize to NULL", async () => {
+    const note = await store.createNote("e", { actor: "   ", via: "" });
+    const row = rawRow(note.id);
+    expect(row.created_by).toBeNull();
+    expect(row.created_via).toBeNull();
+  });
+});
+
+describe("write-attribution — query filters", () => {
+  beforeEach(async () => {
+    await store.createNote("a", { actor: "aaron", via: "mcp" });
+    await store.createNote("b", { actor: "mathilda", via: "surface:meeting-ingest" });
+    const c = await store.createNote("c", { actor: "aaron", via: "api" });
+    // c's most-recent write is by the nightly agent via mcp.
+    await store.updateNote(c.id, { content: "c2", actor: "agent:nightly", via: "mcp" });
+    await store.createNote("legacy"); // no attribution
+  });
+
+  it("created_by selects only that principal's CREATED notes", async () => {
+    const aaron = await store.queryNotes({ createdBy: "aaron" });
+    expect(aaron.map((n) => n.content).sort()).toEqual(["a", "c2"]);
+  });
+
+  it("last_updated_by selects by MOST-RECENT author (agent's edit on c)", async () => {
+    const byAgent = await store.queryNotes({ lastUpdatedBy: "agent:nightly" });
+    expect(byAgent.map((n) => n.content)).toEqual(["c2"]);
+    // aaron created c but is no longer its last editor.
+    const aaronLatest = await store.queryNotes({ lastUpdatedBy: "aaron" });
+    expect(aaronLatest.map((n) => n.content)).toEqual(["a"]);
+  });
+
+  it("created_via / last_updated_via filter on the interface axis", async () => {
+    const viaSurface = await store.queryNotes({ createdVia: "surface:meeting-ingest" });
+    expect(viaSurface.map((n) => n.content)).toEqual(["b"]);
+    const lastViaMcp = await store.queryNotes({ lastUpdatedVia: "mcp" });
+    // "a" (created via mcp, never updated) + "c2" (last updated via mcp).
+    expect(lastViaMcp.map((n) => n.content).sort()).toEqual(["a", "c2"]);
+  });
+
+  it("an attribution filter never matches legacy/unattributed (NULL) rows", async () => {
+    const any = await store.queryNotes({ createdBy: "aaron" });
+    expect(any.some((n) => n.content === "legacy")).toBe(false);
+  });
+});
+
+describe("write-attribution — legacy backfill (v23 migration)", () => {
+  it("a pre-v23 vault: existing rows stay NULL, new rows attribute, no crash", () => {
+    // Build a v22-shaped notes table by hand (no attribution columns) +
+    // schema_version row, then run initSchema to drive the v23 migration.
+    const legacy = new Database(":memory:");
+    legacy.exec(`
+      CREATE TABLE notes (
+        id TEXT PRIMARY KEY,
+        content TEXT DEFAULT '',
+        path TEXT,
+        metadata TEXT DEFAULT '{}',
+        created_at TEXT NOT NULL,
+        updated_at TEXT,
+        extension TEXT NOT NULL DEFAULT 'md'
+      );
+      CREATE TABLE schema_version (version INTEGER PRIMARY KEY, applied_at TEXT);
+      INSERT INTO schema_version (version, applied_at) VALUES (22, '2026-01-01T00:00:00.000Z');
+      INSERT INTO notes (id, content, created_at, updated_at)
+        VALUES ('old-1', 'pre-existing', '2026-01-01T00:00:00.000Z', '2026-01-01T00:00:00.000Z');
+    `);
+
+    // Should migrate without throwing.
+    initSchema(legacy);
+
+    const ver = (legacy.prepare("SELECT MAX(version) AS v FROM schema_version").get() as {
+      v: number;
+    }).v;
+    expect(ver).toBe(23);
+
+    // Legacy row: attribution columns exist now but are NULL (not fabricated).
+    const old = legacy
+      .prepare("SELECT created_by, last_updated_by, created_via FROM notes WHERE id = ?")
+      .get("old-1") as { created_by: string | null; last_updated_by: string | null; created_via: string | null };
+    expect(old.created_by).toBeNull();
+    expect(old.last_updated_by).toBeNull();
+    expect(old.created_via).toBeNull();
+
+    // A NEW write on the migrated DB attributes correctly.
+    const migratedStore = new SqliteStore(legacy);
+    return migratedStore.createNote("fresh", { actor: "aaron", via: "mcp" }).then((n) => {
+      expect(n.createdBy).toBe("aaron");
+      expect(n.createdVia).toBe("mcp");
+      // The legacy row is still NULL and still queryable.
+      return migratedStore.queryNotes({ createdBy: "aaron" }).then((res) => {
+        expect(res.map((x) => x.content)).toEqual(["fresh"]);
+      });
+    });
+  });
+
+  it("re-running the v23 migration is idempotent (no duplicate-column error)", () => {
+    const again = new Database(":memory:");
+    const s = new SqliteStore(again); // runs migrations once
+    initSchema(again); // run again — must not throw
+    expect(() => s.createNote("ok", { actor: "x", via: "api" })).not.toThrow();
+  });
+});
+
+describe("write-attribution — cursor binding", () => {
+  it("changing an attribution filter between cursor polls invalidates the cursor", async () => {
+    await store.createNote("a", { actor: "aaron", via: "mcp" });
+    const page = await store.queryNotesPaged({ createdBy: "aaron" });
+    // Reusing the cursor under a DIFFERENT createdBy must be rejected, not
+    // silently continue aaron's watermark.
+    await expect(
+      store.queryNotesPaged({ createdBy: "mathilda", cursor: page.next_cursor }),
+    ).rejects.toThrow(/different query/i);
+  });
+});

package/core/src/cursor.ts

@@ -160,6 +160,14 @@ export interface QueryHashInputs {
   extension?: string | string[];
   ids?: string[];
   metadata?: Record<string, unknown>;
+  // Write-attribution filters (vault#298) — part of the result-set-affecting
+  // opts, so they're bound into the cursor: changing "who/via" between polls
+  // invalidates the cursor with cursor_query_mismatch rather than silently
+  // continuing the prior filter's watermark.
+  createdBy?: string;
+  lastUpdatedBy?: string;
+  createdVia?: string;
+  lastUpdatedVia?: string;
   dateFrom?: string;
   dateTo?: string;
   dateFilter?: { field?: string; from?: string; to?: string };