@openparachute/vault 0.7.3-rc.13 → 0.7.3-rc.3

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/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

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.13",
+  "version": "0.7.3-rc.3",
   "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/auth-hub-jwt.test.ts

@@ -28,7 +28,7 @@ import { tmpdir } from "os";
 import { generateKeyPair, exportJWK, SignJWT } from "jose";
 import { writeVaultConfig, readVaultConfig } from "./config.ts";
 import { getVaultStore, clearVaultStoreCache } from "./vault-store.ts";
-import { authenticateVaultRequest, authenticateGlobalRequest, deriveVaultFromToken } from "./auth.ts";
+import { authenticateVaultRequest, authenticateGlobalRequest } from "./auth.ts";
 import { resetJwksCache, resetRevocationCache } from "./hub-jwt.ts";
 
 interface Keypair {
@@ -705,120 +705,3 @@ describe("pvt_* DROP (vault#282 Stage 2 — unvalidatable)", () => {
     expect("error" in result).toBe(false);
   });
 });
-
-// ---------------------------------------------------------------------------
-// deriveVaultFromToken — the derivation precedence for the canonical root
-// `/mcp` endpoint (U1). This function READS a validated token's claims to name
-// the target vault; it never authorizes (the router re-dispatches through the
-// full per-vault machinery). These cases isolate the three naming sources —
-// narrowed scope / `aud=vault.<name>` / single-element `vault_scope` — and the
-// fail-closed rules (agree → one name; disagree or none → `not_derivable`).
-// The end-to-end routing.test.ts covers the wired behavior; this pins the
-// precedence logic directly.
-// ---------------------------------------------------------------------------
-describe("deriveVaultFromToken — root /mcp vault derivation (U1)", () => {
-  test("all three sources agree → that vault", async () => {
-    const token = await signJwt(kp, {
-      iss: fixture.origin,
-      aud: "vault.journal",
-      scope: "vault:journal:write",
-      vaultScope: ["journal"],
-    });
-    expect(await deriveVaultFromToken(bearer(token))).toEqual({ vaultName: "journal" });
-  });
-
-  test("narrowed scope alone names the vault (non-vault aud, no vault_scope)", async () => {
-    const token = await signJwt(kp, {
-      iss: fixture.origin,
-      aud: "urn:opaque-resource",
-      scope: "vault:journal:read",
-    });
-    expect(await deriveVaultFromToken(bearer(token))).toEqual({ vaultName: "journal" });
-  });
-
-  test("aud=vault.<name> alone names the vault (broad scope names nothing)", async () => {
-    const token = await signJwt(kp, {
-      iss: fixture.origin,
-      aud: "vault.journal",
-      scope: "vault:read",
-    });
-    expect(await deriveVaultFromToken(bearer(token))).toEqual({ vaultName: "journal" });
-  });
-
-  test("single-element vault_scope alone names the vault", async () => {
-    const token = await signJwt(kp, {
-      iss: fixture.origin,
-      aud: "urn:opaque-resource",
-      scope: "vault:read",
-      vaultScope: ["journal"],
-    });
-    expect(await deriveVaultFromToken(bearer(token))).toEqual({ vaultName: "journal" });
-  });
-
-  test("multi-element vault_scope is NOT a single name → not_derivable (nothing else names)", async () => {
-    // Phase-2 multi-vault shape: a multi-element vault_scope doesn't name ONE
-    // vault, so at the single-vault root it can't be the sole source.
-    const token = await signJwt(kp, {
-      iss: fixture.origin,
-      aud: "urn:opaque-resource",
-      scope: "vault:read",
-      vaultScope: ["journal", "work"],
-    });
-    expect(await deriveVaultFromToken(bearer(token))).toEqual({ error: "not_derivable" });
-  });
-
-  test("sources disagree (scope vs aud) → not_derivable, never a guess", async () => {
-    const token = await signJwt(kp, {
-      iss: fixture.origin,
-      aud: "vault.work",
-      scope: "vault:journal:write",
-    });
-    expect(await deriveVaultFromToken(bearer(token))).toEqual({ error: "not_derivable" });
-  });
-
-  test("no source names a vault → not_derivable", async () => {
-    const token = await signJwt(kp, {
-      iss: fixture.origin,
-      aud: "urn:opaque-resource",
-      scope: "vault:read",
-    });
-    expect(await deriveVaultFromToken(bearer(token))).toEqual({ error: "not_derivable" });
-  });
-
-  test("no bearer → no_bearer", async () => {
-    const req = new Request("https://vault.test/mcp");
-    expect(await deriveVaultFromToken(req)).toEqual({ error: "no_bearer" });
-  });
-
-  test("non-JWT bearer (operator / legacy shape) names no vault → not_derivable", async () => {
-    // The operator VAULT_AUTH_TOKEN and legacy YAML keys are vault-agnostic —
-    // they can't route the token-derived root endpoint (they keep working at
-    // the per-vault URL).
-    expect(await deriveVaultFromToken(bearer("opaque-operator-secret"))).toEqual({
-      error: "not_derivable",
-    });
-  });
-
-  test("expired JWT → not_derivable (validated with the full trust kernel)", async () => {
-    const token = await signJwt(kp, {
-      iss: fixture.origin,
-      aud: "vault.journal",
-      scope: "vault:journal:write",
-      ttlSeconds: -10, // already expired
-    });
-    expect(await deriveVaultFromToken(bearer(token))).toEqual({ error: "not_derivable" });
-  });
-
-  test("revoked JWT → not_derivable (revocation runs in derivation too)", async () => {
-    const jti = "u1-derive-revoked";
-    const token = await signJwt(kp, {
-      iss: fixture.origin,
-      aud: "vault.journal",
-      scope: "vault:journal:write",
-      jti,
-    });
-    fixture.setRevoked([jti]);
-    resetRevocationCache();
-    expect(await deriveVaultFromToken(bearer(token))).toEqual({ error: "not_derivable" });
-  });
-});

package/src/auth.ts

@@ -30,7 +30,6 @@ import {
   hasScope,
   hasScopeForVault,
   legacyPermissionToScopes,
-  narrowedVaultNames,
   SCOPE_ADMIN,
   SCOPE_READ,
   SCOPE_WRITE,
@@ -713,66 +712,3 @@ export async function authenticateGlobalRequest(
   }
   return { error: Response.json({ error: "Unauthorized", message: "Invalid API key" }, { status: 401 }) };
 }
-
-/**
- * Outcome of deriving a target vault from a request's bearer at the canonical
- * root `/mcp` endpoint (U1). `vaultName` on success; a coarse failure `error`
- * otherwise. Both failure reasons map to the SAME 401 + root-PRM challenge at
- * the router — the distinction exists for logging/tests, never leaks to the
- * client. `no_bearer` = no credential presented; `not_derivable` = a credential
- * that names no single vault (non-JWT operator/legacy bearer, invalid /
- * expired / revoked JWT, or a JWT whose scope / `aud` / `vault_scope` sources
- * name zero or conflicting vaults).
- */
-export type VaultDerivation =
-  | { vaultName: string }
-  | { error: "no_bearer" | "not_derivable" };
-
-/**
- * Derive the target vault from a request's bearer token WITHOUT authorizing the
- * request. The caller re-dispatches the derived name through the full per-vault
- * auth machinery (`authenticateVaultRequest`), which re-validates the token
- * WITH the audience pin — derive-then-redispatch, so a bad derivation FAILS the
- * inner check rather than bypassing it (defense in depth). This function only
- * reads the claims well enough to name the vault; it is never the authorization
- * gate.
- *
- * Only hub-issued JWTs name a vault. The operator `VAULT_AUTH_TOKEN` and legacy
- * YAML keys are vault-agnostic (they name no resource — see scopes.ts), so they
- * return `not_derivable` here and keep working at the URL-addressed
- * `/vault/<name>/*` surface. The JWT is validated with the SAME scope-guard
- * trust kernel the per-vault path uses (signature, `iss` pin, `jti` +
- * revocation, expiry) but WITHOUT `expectedAudience` — at the root we don't yet
- * know which audience to expect; that pin is re-applied by the re-dispatch.
- *
- * From the validated claims, three independent sources can name a vault:
- *   1. a narrowed `vault:<name>:<verb>` scope,
- *   2. an `aud` of the form `vault.<name>`,
- *   3. a single-element `vault_scope` claim.
- * On a hub-minted token these AGREE. We collect every name any source provides
- * and require EXACTLY ONE distinct name: zero (nothing named a vault) and
- * two-or-more (the sources disagree) both fail closed with `not_derivable`. We
- * never pick a winner from a precedence order — an ambiguous or unnamed token
- * gets the discovery challenge, not a silent guess.
- */
-export async function deriveVaultFromToken(req: Request): Promise<VaultDerivation> {
-  const key = extractApiKey(req);
-  if (!key) return { error: "no_bearer" };
-  if (!looksLikeJwt(key)) return { error: "not_derivable" };
-  let claims;
-  try {
-    // No `expectedAudience`: the per-vault trust kernel minus the aud pin
-    // (which the re-dispatch re-applies). A bad signature / iss / expiry /
-    // revoked jti throws here → not_derivable → the standard 401 challenge.
-    claims = await validateHubJwt(key, {});
-  } catch {
-    return { error: "not_derivable" };
-  }
-  const named = new Set<string>();
-  for (const name of narrowedVaultNames(claims.scopes)) named.add(name);
-  const audMatch = claims.aud?.match(/^vault\.(.+)$/);
-  if (audMatch) named.add(audMatch[1]!);
-  if (claims.vaultScope.length === 1) named.add(claims.vaultScope[0]!);
-  if (named.size !== 1) return { error: "not_derivable" };
-  return { vaultName: [...named][0]! };
-}

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.");