@openparachute/vault 0.7.3-rc.12 → 0.7.3-rc.2

package/core/src/seed-packs.ts

@@ -14,13 +14,6 @@
  *     surface (UI) over the vault. NOT default-seeded (ratified 2026-07-02:
  *     Surface Starter is out of the default seed) — added on demand via
  *     `parachute-vault add-pack surface-starter` or a console affordance.
- *   - `starter-ontology` — four starter **meta tags** (`view`, `archived`,
- *     `pinned`, `capture`) with constitution-style descriptions, plus seed
- *     `#view` notes mirroring the app's default pages (All notes, Recent,
- *     Pinned, Archive). NOT default-seeded (ratified 2026-07-16 design
- *     dialogue — deliberately opt-in; a fresh-vault materialization change
- *     needs its own decision) — added on demand via `parachute-vault
- *     add-pack starter-ontology` or a console affordance.
  *
  * Guides are the vault's skill files — the Parachute equivalent of a
  * `SKILL.md`. They're tagged `#guide` (GUIDE_TAG): notes that teach how this
@@ -805,172 +798,6 @@ export const SURFACE_STARTER_PACK: SeedPack = {
   ],
 };
 
-// ---------------------------------------------------------------------------
-// `starter-ontology` pack — four starter meta tags (opt-in)
-// ---------------------------------------------------------------------------
-
-/**
- * The starter ontology, ratified in the 2026-07-16 design dialogue (Letter 1,
- * Q5: "yes — tiny, opinionated, removable"): exactly four tags, no more.
- * "Really want to start simple" / "don't be too prescriptive" — the vault
- * ships the mechanisms; each parachute writes its own rules on top.
- *
- * A **meta tag** (the ratified user-facing term for "a tag with a schema")
- * is `view` alone here — it carries `fields`. `archived`, `pinned`, and
- * `capture` are plain tags: no schema, just a description that teaches the
- * convention. Every description below is written as a constitution — it's
- * read by both a human deciding whether to use the tag and an agent deciding
- * how to behave around it — plain and warm, describing the DEFAULT
- * convention rather than dictating one ("different people will draw that
- * line differently").
- *
- * `capture` is NOT redeclared with new text — it's the exact `NOTES_REQUIRED_TAGS`
- * entry, reused verbatim, because notes-ui's connect-time schema audit
- * compares its `description` byte-for-byte (see the comment on
- * `NOTES_REQUIRED_TAGS` above). Applying this pack must never be able to
- * drift that string out from under the welcome pack, in either apply order.
- *
- * `pinned` shipped once before and was dropped as vestigial (PR #547,
- * 2026-07-07): it was seeded onto `Welcome` with old sort-first semantics,
- * which did nothing visible on a fresh vault (the Notes app had no list
- * badge, and Welcome was already first). This is a different tag: the
- * ratified semantics are partition-not-sort, it isn't stamped onto any
- * existing note, and the pack ships a `Pinned` view that actually surfaces
- * it.
- */
-export const VIEW_TAG: SeedPackTag = {
-  name: "view",
-  description:
-    'A meta tag — it carries a schema, which is what makes a #view note a saved view rather than just a label. Tag a note #view and its metadata becomes the definition: `query` is the saved query itself (the same JSON shape query-notes accepts — tag, exclude_tags, search, metadata, order_by, ...), and `kind` says how to render the result (list, board, calendar, or gallery; an unrecognized or missing kind should degrade to list rather than fail — a view is never wrong to render as a list). `lane_by` names the metadata field a board\'s lanes come from; `date_field` names the date-typed field a calendar plots against — both only meaningful for their matching `kind`, and unset otherwise. The note\'s body is for people: what this view is for, when to reach for it. Because the definition lives in the vault as an ordinary note, any surface can read it and render the same view, and any agent can write one — "make me a board of my active drafts" is just creating a note. Authoring convention worth keeping: most views should write `exclude_tags: ["archived"]` into their own query rather than leaning on some surface-side default — an Archive view is the deliberate exception.',
-  fields: {
-    kind: {
-      type: "string",
-      description:
-        "How to render this view. Unrecognized or absent degrades to list — a view is never wrong to render as a list.",
-      enum: ["list", "board", "calendar", "gallery"],
-      default: "list",
-    },
-    query: {
-      type: "string",
-      description:
-        "The saved query — a JSON string of query-notes parameters (tag, exclude_tags, search, metadata, order_by, sort, ...). This is what actually determines which notes the view shows; kind only says how to draw them.",
-    },
-    lane_by: {
-      type: "string",
-      description:
-        "Board views only: the metadata field whose distinct values become the board's lanes/columns. Unset outside kind: board.",
-    },
-    date_field: {
-      type: "string",
-      description:
-        "Calendar views only: the date-typed metadata field the calendar plots notes against. Unset outside kind: calendar.",
-    },
-  },
-};
-
-export const ARCHIVED_TAG: SeedPackTag = {
-  name: "archived",
-  description:
-    "A plain tag — no schema, just a convention: this note is out of the flow of the present. Not deleted, not wrong, just done, closed, or set aside for now. The one behavior worth relying on: default views exclude archived notes unless a view's own query says otherwise (an Archive view, for instance, asks for them back on purpose). Archiving a note doesn't touch its content, tags, or links — it only changes whether it shows up by default. What actually gets archived, and when, is yours to decide: a finished project, last month's drafts, a conversation that's resolved. Different people will draw that line differently, and that's fine — the tag only promises the one thing above.",
-};
-
-export const PINNED_TAG: SeedPackTag = {
-  name: "pinned",
-  description:
-    "A plain tag — no schema, just a convention: this note gets surfaced first. Pinning is a partition, not a sort — a view that honors it renders pinned notes as their own small group above everything else, rather than nudging them up the existing order. That also means pinning doesn't fight with however the rest of a view is sorted; it just carves out a \"see this first\" spot above it. There's no built-in limit on how many notes can be pinned, and no rule about what belongs there — a current focus, something you keep needing to find, a note you're mid-thought on. Unpin by removing the tag. Different people, and different views, will use it differently; the tag only promises the placement, not the policy.",
-};
-
-export const VIEWS_PATH_PREFIX = "Views/";
-export const ALL_NOTES_VIEW_PATH = `${VIEWS_PATH_PREFIX}All notes`;
-export const RECENT_VIEW_PATH = `${VIEWS_PATH_PREFIX}Recent`;
-export const PINNED_VIEW_PATH = `${VIEWS_PATH_PREFIX}Pinned`;
-export const ARCHIVE_VIEW_PATH = `${VIEWS_PATH_PREFIX}Archive`;
-
-/**
- * Build the `starter-ontology` pack: the four meta tags above, plus four
- * seed `#view` notes mirroring the app's default pages — All notes, Recent,
- * Pinned, Archive — so "default app pages are shipped views" has its data
- * half from day one. Each view's `query` is written out explicitly
- * (`exclude_tags: ["archived"]` where it applies) rather than relying on any
- * surface-side default, per the authoring convention in `VIEW_TAG`'s own
- * description. Kept tiny on purpose — these are starting points, not a
- * demonstration of everything the schema can do.
- *
- * NOT applied by `src/onboarding-seed.ts`'s default materialization — opt-in
- * only, via `parachute-vault add-pack starter-ontology` or a console
- * affordance. A fresh-vault UX change (making this part of the default seed)
- * is a separate decision; this pack existing makes that a one-line flip
- * later, deliberately not taken here.
- */
-export const STARTER_ONTOLOGY_PACK: SeedPack = {
-  name: "starter-ontology",
-  description:
-    "The starter ontology: one meta tag (view, with a schema) and three plain tags (archived, pinned, capture), each with a constitution-style description — plus four seed #view notes (All notes, Recent, Pinned, Archive) mirroring the app's default pages. Opt-in — not seeded by default.",
-  // `capture` reused verbatim from NOTES_REQUIRED_TAGS (byte-equal to the
-  // welcome pack's — see the module doc above and NOTES_REQUIRED_TAGS'
-  // comment). Order matches the constitution ordering, not upsert order.
-  tags: [VIEW_TAG, ARCHIVED_TAG, PINNED_TAG, ...NOTES_REQUIRED_TAGS],
-  notes: [
-    {
-      path: ALL_NOTES_VIEW_PATH,
-      tags: ["view"],
-      content: `# All notes
-
-Everything in the vault except what's archived. The default view — no tag
-filter, no sort override, just the whole thing minus the notes you've set
-aside.
-`,
-      metadata: {
-        kind: "list",
-        query: JSON.stringify({ exclude_tags: ["archived"] }),
-      },
-    },
-    {
-      path: RECENT_VIEW_PATH,
-      tags: ["view"],
-      content: `# Recent
-
-The vault, newest edits first. Same notes as [[${ALL_NOTES_VIEW_PATH}]] —
-archived excluded — just ordered by when they last changed.
-`,
-      metadata: {
-        kind: "list",
-        query: JSON.stringify({
-          exclude_tags: ["archived"],
-          order_by: "updated_at",
-          sort: "desc",
-        }),
-      },
-    },
-    {
-      path: PINNED_VIEW_PATH,
-      tags: ["view"],
-      content: `# Pinned
-
-Whatever you've marked #pinned — the notes surfaced first, regardless of how
-anything else in the vault is organized.
-`,
-      metadata: {
-        kind: "list",
-        query: JSON.stringify({ tag: "pinned" }),
-      },
-    },
-    {
-      path: ARCHIVE_VIEW_PATH,
-      tags: ["view"],
-      content: `# Archive
-
-Everything tagged #archived — out of the flow of the present, but never
-gone. The one view that asks archived notes back on purpose.
-`,
-      metadata: {
-        kind: "list",
-        query: JSON.stringify({ tag: "archived" }),
-      },
-    },
-  ],
-};
-
 // ---------------------------------------------------------------------------
 // Registry
 // ---------------------------------------------------------------------------
@@ -980,7 +807,6 @@ export const SEED_PACK_NAMES = [
   "welcome",
   "getting-started",
   "surface-starter",
-  "starter-ontology",
 ] as const;
 
 export type SeedPackName = (typeof SEED_PACK_NAMES)[number];
@@ -1009,8 +835,6 @@ export function getSeedPack(
       return GETTING_STARTED_PACK;
     case "surface-starter":
       return SURFACE_STARTER_PACK;
-    case "starter-ontology":
-      return STARTER_ONTOLOGY_PACK;
     default:
       return null;
   }
@@ -1025,14 +849,6 @@ export interface ApplySeedPackResult {
   pack: string;
   /** Tag names upserted (upserts are idempotent; always every declared tag). */
   tags: string[];
-  /**
-   * Subset of `tags` whose DESCRIPTION was left untouched this run because it
-   * had been hand-edited away from the pack's canonical text (see
-   * `applySeedPack`'s description-preservation rule below). `fields` /
-   * `parent_names` / `relationships` are still upserted unconditionally for
-   * these tags — only the description write was skipped.
-   */
-  preservedTagDescriptions: string[];
   /** Note paths written this run (absent ones). */
   seededNotes: string[];
   /** Note paths skipped because a note already lives there (idempotency). */
@@ -1045,30 +861,6 @@ export interface ApplySeedPackResult {
  * rows — so a re-run can never duplicate, and never clobbers a note the
  * operator/AI has since edited or recreated.
  *
- * **Tag description preservation** (Aaron-ratified 2026-07-17): a pack writes
- * a tag's `description` only when (a) the tag has no prior description (new
- * tag, or an existing bare row nothing ever described), or (b) the prior
- * description is still byte-identical to the pack's own text — i.e. no one
- * has touched it. The moment a description differs from the pack's current
- * text, it's treated as a deliberate hand edit (a user-tuned "constitution")
- * and is never overwritten by a re-apply; omitting the `description` key from
- * the `upsertTagRecord` patch is what preserves it (the store keeps whatever
- * is already there). `fields` / `parent_names` / `relationships` are NOT
- * given this treatment here — they still upsert unconditionally, same as
- * before this change; those axes are more entangled with schema-validation
- * side effects (indexed-column lifecycle, cross-tag type agreement) to
- * safely split out in this pass. Description-only is the ratified scope.
- *
- * Known, accepted tradeoff: this compares against the pack's CURRENT text
- * only, not any prior canonical version. If a pack's canonical description
- * changes upstream, a vault that never touched it reads as "matches the OLD
- * text, therefore edited" from the new pack's point of view, and keeps the
- * old text too — same outcome as a genuine hand edit. That's fine:
- * constitutions aren't security patches that must propagate; a future
- * doctor-style scan can surface "description drifted from the current pack
- * text" as an informational finding without this applier needing to guess
- * intent. See CHANGELOG.
- *
  * Errors propagate — best-effort semantics (seed-must-never-fail-a-create)
  * belong to the caller, which knows its failure policy.
  *
@@ -1083,7 +875,6 @@ export async function applySeedPack(
   const result: ApplySeedPackResult = {
     pack: pack.name,
     tags: [],
-    preservedTagDescriptions: [],
     seededNotes: [],
     skippedNotes: [],
   };
@@ -1091,19 +882,12 @@ export async function applySeedPack(
   // Parents first so `parent_names` reads naturally in logs (the store accepts
   // forward references, but the order matches the conceptual model).
   for (const decl of pack.tags) {
-    const existing = await store.getTagRecord(decl.name);
-    const priorDescription = existing?.description ?? null;
-    const isUserEdited = priorDescription != null && priorDescription !== decl.description;
-
     await store.upsertTagRecord(decl.name, {
-      // Omitted (not `undefined`-valued) when preserving — `upsertTagRecord`
-      // treats an absent `description` key as "keep the current value".
-      ...(isUserEdited ? {} : { description: decl.description }),
+      description: decl.description,
       ...(decl.parent_names ? { parent_names: decl.parent_names } : {}),
       ...(decl.fields ? { fields: decl.fields } : {}),
     });
     result.tags.push(decl.name);
-    if (isUserEdited) result.preservedTagDescriptions.push(decl.name);
   }
 
   for (const note of pack.notes) {

package/core/src/store.ts

@@ -38,7 +38,6 @@ import {
   loadSchemaConfig,
   validateNote as runValidateNote,
   resolveNoteSchemas,
-  normalizeDateFields,
   type ResolvedSchemas,
   type ValidationStatus,
 } from "./schema-defaults.js";
@@ -501,16 +500,6 @@ export class BunSqliteStore implements Store {
   // ---- Notes ----
 
   async createNote(content: string, opts?: { id?: string; path?: string; tags?: string[]; metadata?: Record<string, unknown>; created_at?: string; extension?: string; actor?: string | null; via?: string | null }): Promise<Note> {
-    // Normalize `date`-typed field values to canonical UTC ISO form BEFORE
-    // the write (vault#date-field-type — mixed-offset TEXT-compare
-    // corruption). COPY-ON-WRITE (round 2) — reassign the local `opts`
-    // binding from the returned value rather than mutating the caller's
-    // object; see `normalizeDateFields`'s doc comment.
-    if (opts?.metadata) {
-      const normalized = normalizeDateFields(this.getSchemaConfig(), { tags: opts.tags, metadata: opts.metadata });
-      if (normalized !== opts.metadata) opts = { ...opts, metadata: normalized };
-    }
-
     const note = noteOps.createNote(this.db, content, opts);
 
     if (content) {
@@ -559,20 +548,6 @@ export class BunSqliteStore implements Store {
       actor?: string | null;
       via?: string | null;
       if_updated_at?: string;
-      /**
-       * `date`-field normalization override (vault#date-field-type review
-       * round 2). By default, `normalizeDateFields` below resolves the note's
-       * effective schema against its CURRENT tags in the DB — correct when
-       * this call doesn't also change tags. A caller that adds a tag IN THIS
-       * SAME logical update (via a separate `store.tagNote` issued right
-       * after this call — see mcp.ts's `update-note` handler and the batch
-       * upsert "update"/"replace" branch) must pass the PROJECTED final tag
-       * set here instead, or a newly-added tag's `type: "date"` field never
-       * gets seen (the schema resolution would still be looking at the
-       * pre-write tag set) and its offset-bearing value would persist
-       * verbatim. Ignored when `updates.metadata` is undefined.
-       */
-      tagsForSchemaResolution?: string[];
     },
   ): Promise<Note> {
     let oldPath: string | undefined;
@@ -586,19 +561,7 @@ export class BunSqliteStore implements Store {
     if (updates.path !== undefined || updates.metadata !== undefined) {
       const existing = noteOps.getNote(this.db, id);
       if (updates.path !== undefined) oldPath = existing?.path;
-      if (updates.metadata !== undefined) {
-        priorMetadataForRefs = existing?.metadata;
-        // Normalize `date`-typed field values to canonical UTC ISO form
-        // BEFORE the write (vault#date-field-type — mixed-offset TEXT-
-        // compare corruption). COPY-ON-WRITE (round 2) — reassign the local
-        // `updates` binding from the returned value rather than mutating the
-        // caller's object; see `normalizeDateFields`'s doc comment.
-        // `tagsForSchemaResolution` (when the caller is ALSO adding a tag in
-        // this same logical update) wins over the note's current DB tags.
-        const tagsForResolution = updates.tagsForSchemaResolution ?? existing?.tags;
-        const normalized = normalizeDateFields(this.getSchemaConfig(), { tags: tagsForResolution, metadata: updates.metadata });
-        if (normalized !== updates.metadata) updates = { ...updates, metadata: normalized };
-      }
+      if (updates.metadata !== undefined) priorMetadataForRefs = existing?.metadata;
     }
 
     const note = noteOps.updateNote(this.db, id, updates);
@@ -1071,18 +1034,7 @@ export class BunSqliteStore implements Store {
   // ---- Bulk Operations ----
 
   async createNotes(inputs: noteOps.BulkNoteInput[]): Promise<Note[]> {
-    // Same pre-write `date`-field normalization as singleton createNote
-    // (vault#date-field-type) — this bulk path bypasses it otherwise.
-    // COPY-ON-WRITE (round 2) — build a new array with only the items that
-    // actually need a rewrite replaced; never mutate the caller's `inputs`
-    // or its element objects.
-    const schemaConfig = this.getSchemaConfig();
-    const normalizedInputs = inputs.map((input) => {
-      if (!input.metadata) return input;
-      const normalized = normalizeDateFields(schemaConfig, { tags: input.tags, metadata: input.metadata });
-      return normalized !== input.metadata ? { ...input, metadata: normalized } : input;
-    });
-    const notes = noteOps.createNotes(this.db, normalizedInputs);
+    const notes = noteOps.createNotes(this.db, inputs);
     for (const note of notes) {
       // Bulk path needs the same config-cache invalidation as singleton
       // createNote — without it, a batch that includes `_tags/*` notes
@@ -1292,7 +1244,7 @@ export class BunSqliteStore implements Store {
         const mapped = indexedFieldOps.mapFieldType(spec.type);
         if (!mapped) {
           throw new indexedFieldOps.IndexedFieldError(
-            `field "${fieldName}" has unsupported type "${spec.type}" for indexing (supported: string, integer, boolean, reference, date)`,
+            `field "${fieldName}" has unsupported type "${spec.type}" for indexing (supported: string, integer, boolean, reference)`,
           );
         }
         // Throws IndexedFieldError on an invalid identifier (e.g. kebab-case).
@@ -1424,14 +1376,6 @@ export class BunSqliteStore implements Store {
    * place.)
    */
   async createNoteRaw(content: string, opts?: { id?: string; path?: string; tags?: string[]; metadata?: Record<string, unknown>; created_at?: string; extension?: string }): Promise<Note> {
-    // Same pre-write `date`-field normalization as createNote
-    // (vault#date-field-type) — the legacy Obsidian importer (obsidian.ts)
-    // funnels through this path and bypasses createNote's copy otherwise.
-    // COPY-ON-WRITE (round 2) — see normalizeDateFields's doc comment.
-    if (opts?.metadata) {
-      const normalized = normalizeDateFields(this.getSchemaConfig(), { tags: opts.tags, metadata: opts.metadata });
-      if (normalized !== opts.metadata) opts = { ...opts, metadata: normalized };
-    }
     return noteOps.createNote(this.db, content, opts);
   }
 

package/core/src/tag-schemas.ts

@@ -18,7 +18,6 @@
 import { Database } from "bun:sqlite";
 import { mapFieldType, validateFieldName } from "./indexed-fields.js";
 import { loadTagHierarchy, findParentCycle } from "./tag-hierarchy.js";
-import { timestampToMs } from "./cursor.js";
 
 // ---------------------------------------------------------------------------
 // Types
@@ -193,7 +192,7 @@ export class InvalidFieldDefaultError extends Error {
 
 /**
  * Thrown by `upsertTagRecord` (core/src/store.ts's chokepoint) when a
- * field's declared `type` isn't one of the recognized values (vault#555
+ * field's declared `type` isn't one of the six recognized values (vault#555
  * — `update-tag{fields:{weird:{type:"frobnicator"}}}` used to be accepted
  * and persisted verbatim, no error, for any NON-indexed field: the only
  * existing type check, `mapFieldType`, ran solely on `indexed: true` fields
@@ -256,13 +255,13 @@ export function validateFieldDefault(field: string, spec: TagFieldSchema): TagFi
 
 /**
  * The full recognized vocabulary for `TagFieldSchema.type` — storage/
- * advisory validation accepts all eight; only `string`/`integer`/`boolean`/
- * `reference`/`date` are INDEXABLE (that narrower subset is
- * `indexed-fields.ts`'s `TYPE_MAP`, enforced separately via `mapFieldType`
- * for `indexed: true` fields). Matches `defaultMatchesType`'s switch and
- * `schema-defaults.ts`'s `SchemaField.type` union — kept in lockstep by hand
- * across the two deliberately-decoupled modules (see `validateFieldDefault`'s
- * doc comment for why they don't cross-import).
+ * advisory validation accepts all seven; only `string`/`integer`/`boolean`/
+ * `reference` are INDEXABLE (that narrower subset is `indexed-fields.ts`'s
+ * `TYPE_MAP`, enforced separately via `mapFieldType` for `indexed: true`
+ * fields). Matches `defaultMatchesType`'s switch and `schema-defaults.ts`'s
+ * `SchemaField.type` union — kept in lockstep by hand across the two
+ * deliberately-decoupled modules (see `validateFieldDefault`'s doc comment
+ * for why they don't cross-import).
  *
  * `reference` (vault#typed-reference-field) is a dual-write field type: the
  * value is stored + validated exactly like `string` (an id/path/title the
@@ -271,18 +270,11 @@ export function validateFieldDefault(field: string, spec: TagFieldSchema): TagFi
  * to a note and maintains a graph `links` edge from this note to the
  * resolved target, with `relationship` set to the field name. See
  * `docs/design/typed-reference-field.md` for the full design + known gaps.
- *
- * `date` stores/validates like `string` (an ISO-8601 date or timestamp) so
- * indexed `date` fields sort correctly under a plain TEXT comparison — see
- * `defaultMatchesType`'s `"date"` case and `schema-defaults.ts`'s
- * `valueMatchesType`, both of which reuse `cursor.ts`'s `timestampToMs`
- * (the SAME UTC-correct parser `date_filter`'s `updated_at` bound uses) so
- * there's exactly one ISO-parsing implementation in the codebase, not two.
  */
-export const VALID_FIELD_TYPES = ["string", "number", "integer", "boolean", "array", "object", "reference", "date"] as const;
+export const VALID_FIELD_TYPES = ["string", "number", "integer", "boolean", "array", "object", "reference"] as const;
 
 /**
- * Validate that a field's declared `type` is one of the recognized
+ * Validate that a field's declared `type` is one of the six recognized
  * values (vault#555). Returns `null` when `type` is unset (own-field checks
  * elsewhere already treat an unset type as "nothing to check against") or
  * recognized; otherwise a {@link TagFieldViolation} with `reason:
@@ -336,7 +328,7 @@ export function collectOwnFieldDefaultAndTypeViolations(
   return violations;
 }
 
-/** Same eight-type vocabulary as `TagFieldSchema.type`'s doc comment. Unknown/unset types pass (nothing to check against). */
+/** Same seven-type vocabulary as `TagFieldSchema.type`'s doc comment. Unknown/unset types pass (nothing to check against). */
 function defaultMatchesType(value: unknown, type: string): boolean {
   switch (type) {
     case "string":
@@ -356,13 +348,6 @@ function defaultMatchesType(value: unknown, type: string): boolean {
     // VALID_FIELD_TYPES's doc comment.
     case "reference":
       return typeof value === "string";
-    // `date` accepts an ISO-8601 date (`YYYY-MM-DD`) or full RFC3339
-    // timestamp — the SAME grammar `date_filter`'s `updated_at` bound
-    // parses (`timestampToMs`, imported from cursor.ts), not a second,
-    // independently-drifting date parser. See VALID_FIELD_TYPES's doc
-    // comment.
-    case "date":
-      return typeof value === "string" && timestampToMs(value) !== null;
     default:
       return true;
   }
@@ -782,7 +767,7 @@ export function collectTagFieldViolations(
         violations.push({
           field: fieldName,
           reason: "unsupported_indexed_type",
-          message: `field "${fieldName}" has unsupported type "${spec.type}" for indexing (supported: string, integer, boolean, reference, date)`,
+          message: `field "${fieldName}" has unsupported type "${spec.type}" for indexing (supported: string, integer, boolean, reference)`,
         });
       } else {
         try {

package/core/src/types.ts

@@ -400,12 +400,6 @@ export interface NoteIndex {
   metadata?: Record<string, unknown>;
   byteSize: number;
   preview: string;
-  /** Derived from the first non-empty line of content (title axis, ratified
-   *  2026-07-17) — NEVER stored, computed fresh at read time by
-   *  `computeDisplayTitle`. `null` when content has no non-empty line.
-   *  Surfaces decide how to render a `null` title (e.g. a timestamp/path
-   *  fallback); core just reports the honest content-derived value. */
-  displayTitle: string | null;
   /** Opt-in link degree (see `Note.linkCount`). */
   linkCount?: number;
   /** Full-text search relevance score (see `Note.score`). Carried onto the
@@ -456,7 +450,7 @@ export interface Store {
    */
   getNoteByPath(path: string, extension?: string): Promise<Note | null>;
   getNotes(ids: string[]): Promise<Note[]>;
-  updateNote(id: string, updates: { content?: string; append?: string; prepend?: string; path?: string; extension?: string; metadata?: Record<string, unknown>; created_at?: string; skipUpdatedAt?: boolean; actor?: string | null; via?: string | null; if_updated_at?: string; tagsForSchemaResolution?: string[] }): Promise<Note>;
+  updateNote(id: string, updates: { content?: string; append?: string; prepend?: string; path?: string; extension?: string; metadata?: Record<string, unknown>; created_at?: string; skipUpdatedAt?: boolean; actor?: string | null; via?: string | null; if_updated_at?: string }): Promise<Note>;
   /**
    * Set a note's `created_at` and `updated_at` explicitly. Import-only:
    * used by the portable-md round-trip path to restore timestamps from

package/core/src/vault-projection.ts

@@ -272,49 +272,6 @@ function sqliteToUserType(t: string): string {
   return t.toLowerCase();
 }
 
-// ---------------------------------------------------------------------------
-// Attachments orientation block (attachment-tickets design, Wave 0+1)
-// ---------------------------------------------------------------------------
-
-/**
- * The Attachments orientation block, rendered into the connect-time
- * markdown brief (`projectionToMarkdown`) so every agent learns, every
- * session, how to move file bytes into/out of this vault without spending
- * its own context on them (bytes never ride MCP either way).
- *
- * `ticketsEnabled` reflects whether THIS door has wired an
- * `AttachmentTicketProvider` (bun: always, as of the Wave 1 PR; cloud: not
- * yet — its mirror is a separate PR). `readEnabled` reflects whether it's
- * wired an `AttachmentBytesProvider` (bun: always, as of this PR — Wave 2).
- * An unwired seam omits BOTH its tool(s) from `tools/list` (see
- * `generateMcpTools`'s `attachmentTickets` / `attachmentBytes` opts) AND
- * its sentence here — the brief never dangles a pointer at a tool the
- * agent can't actually call.
- *
- * Kept as a single dense paragraph (not its own multi-line list) to stay
- * inside the connect-time brief's token budget — see
- * `projectionToMarkdown`'s doc comment.
- */
-export function attachmentsInstructionBlock(opts: { ticketsEnabled: boolean; readEnabled?: boolean }): string {
-  const sentences: string[] = [
-    "Notes can carry file attachments (`include_attachments: true` on `query-notes` returns their rows; bytes don't ride MCP tool RESULTS unless you ask for them).",
-  ];
-  if (opts.ticketsEnabled) {
-    sentences.push(
-      "To move bytes without spending your own context, call `request-attachment-upload` / `request-attachment-download` — each mints a short-lived, single-use URL (with a ready-to-run `curl_example`) your shell spends directly; no MCP session credential is needed to spend it.",
-    );
-  }
-  if (opts.readEnabled) {
-    sentences.push(
-      "To read an attachment directly into this conversation, call `read-attachment` — text comes back as a paginated `content` slice, images as a real image you can see, audio/video as a transcript pointer (never raw bytes), and PDF/other binary formats point you at a download ticket instead.",
-    );
-  }
-  sentences.push(
-    "If your runtime holds this vault's own API token, REST works too: upload = `POST {base}/storage/upload` (multipart `file`, ≤100 MB) then `POST {base}/notes/{id}/attachments` `{path, mimeType, transcribe?}`; download = `GET {base}/storage/{path}` with the same `Authorization: Bearer` (honors a `Range: bytes=a-b` header for partial reads). Audio attached with `transcribe: true` is transcribed automatically.",
-  );
-  return sentences.join(" ");
-}
-
 // ---------------------------------------------------------------------------
 // Markdown rendering — for getServerInstruction
 // ---------------------------------------------------------------------------
@@ -345,13 +302,6 @@ export function projectionToMarkdown(args: {
    * known and always surfaced. See `chooseHubOrigin` (src/mcp-install.ts).
    */
   coordinates?: { hubOrigin: string; hubOriginKnown: boolean };
-  /**
-   * Attachments orientation (see `attachmentsInstructionBlock`). Omitted
-   * defaults to `{ ticketsEnabled: false }` — safe-by-default so a caller
-   * that hasn't wired ticket support yet (or a test fixture) never
-   * accidentally advertises tools it can't back.
-   */
-  attachments?: { ticketsEnabled: boolean; readEnabled?: boolean };
 }): string {
   const { vaultName, description, projection, coordinates } = args;
   const stats = projection.stats;
@@ -468,11 +418,6 @@ export function projectionToMarkdown(args: {
   lines.push("");
   lines.push("If schema or tags change during this session, call `vault-info` to refresh the full projection. Call `list-tags { include_schema: true }` for tag-only details.");
 
-  lines.push("");
-  lines.push("## Attachments");
-  lines.push("");
-  lines.push(attachmentsInstructionBlock(args.attachments ?? { ticketsEnabled: false }));
-
   // Scripting pointer block: the connect-time brief used to dead-end on
   // querying — an agent had no path to "how do I script/automate against this
   // vault." Point at the guide rather than inlining it, to keep this brief

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openparachute/vault",
-  "version": "0.7.3-rc.12",
+  "version": "0.7.3-rc.2",
   "description": "Agent-native knowledge graph. Notes, tags, links over MCP.",
   "module": "src/cli.ts",
   "type": "module",

package/src/add-pack.test.ts

@@ -140,35 +140,3 @@ describe("add-pack surface-starter", () => {
     expect(stdout).toContain("~ tag   capture (upserted)");
   });
 });
-
-describe("add-pack — tag description preservation on re-apply (Aaron-ratified 2026-07-17)", () => {
-  test("a hand-edited description survives a re-apply and is reported 'kept', not 'upserted'", () => {
-    expect(runCli(["create", "packed", "--json"], { PARACHUTE_HOME: home }).exitCode).toBe(0);
-
-    // Simulate an operator/AI hand-editing the capture tag's constitution.
-    const dbPath = join(home, "vault", "data", "packed", "vault.db");
-    const editedDescription = "Our house rules for capture — not the default text.";
-    const writeDb = new Database(dbPath);
-    writeDb.query("UPDATE tags SET description = ? WHERE name = ?").run(
-      editedDescription,
-      "capture",
-    );
-    writeDb.close();
-
-    const { exitCode, stdout } = runCli(
-      ["add-pack", "welcome", "--vault", "packed"],
-      { PARACHUTE_HOME: home },
-    );
-    expect(exitCode).toBe(0);
-    expect(stdout).toContain("~ tag   capture (kept user description)");
-    // guide wasn't edited, so it still reports the old vocabulary.
-    expect(stdout).toContain("~ tag   guide (upserted)");
-
-    const readDb = new Database(dbPath, { readonly: true });
-    const row = readDb
-      .query("SELECT description FROM tags WHERE name = ?")
-      .get("capture") as { description: string };
-    readDb.close();
-    expect(row.description).toBe(editedDescription);
-  });
-});

package/src/cli.ts

@@ -4842,11 +4842,7 @@ async function cmdAddPack(args: string[]) {
       console.log(`  = note  ${path} (already exists — left untouched)`);
     }
     for (const tag of result.tags) {
-      if (result.preservedTagDescriptions.includes(tag)) {
-        console.log(`  ~ tag   ${tag} (kept user description)`);
-      } else {
-        console.log(`  ~ tag   ${tag} (upserted)`);
-      }
+      console.log(`  ~ tag   ${tag} (upserted)`);
     }
     if (result.seededNotes.length === 0 && result.tags.length === 0) {
       console.log("  Nothing to add — everything was already in place.");

package/src/contract-errors.test.ts

@@ -315,7 +315,7 @@ describe("contract: error taxonomy — #554 (flipped from todo)", () => {
     expect(record?.fields ?? null).toBeFalsy();
   });
 
-  // Positive control — every one of the recognized types (indexable or
+  // Positive control — every one of the seven recognized types (indexable or
   // not) is accepted without complaint.
   it("REST PUT /api/tags/:name accepts every recognized field type", async () => {
     const req = new Request("http://localhost/api/tags/widget", {
@@ -329,7 +329,6 @@ describe("contract: error taxonomy — #554 (flipped from todo)", () => {
           e: { type: "array" },
           f: { type: "object" },
           g: { type: "reference" },
-          h: { type: "date" },
         },
       }),
     });