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

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

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" },
         },
       }),
     });

package/src/mcp-http.ts

@@ -109,7 +109,7 @@ export async function handleScopedMcp(
   const instruction = await getServerInstruction(vaultName, auth);
   return handleMcp(
     req,
-    () => generateScopedMcpTools(vaultName, auth, callerBearer ?? null, req),
+    () => generateScopedMcpTools(vaultName, auth, callerBearer ?? null),
     `parachute-vault/${vaultName}`,
     vaultName,
     auth,
@@ -180,15 +180,9 @@ export async function handleMcp(
     }
     try {
       const result = await tool.execute((args ?? {}) as Record<string, unknown>);
-      // The one wrapper change (attachments-for-agents design, Wave 2):
-      // `resultContent`, when a tool defines it, decides the MCP content
-      // blocks instead of the universal single-text-block default —
-      // `read-attachment`'s image branch is the only current user (needs a
-      // REAL {type:"image"} block alongside the row-JSON text block).
-      const content = tool.resultContent
-        ? tool.resultContent(result)
-        : [{ type: "text" as const, text: JSON.stringify(result, null, 2) }];
-      return { content };
+      return {
+        content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }],
+      };
     } catch (err) {
       // vault#555 fix 6 — never re-wrap an already-formed McpError. Passing
       // the SAME instance straight through is strictly correct (no
@@ -235,14 +229,6 @@ export async function handleMcp(
         tag?: string;
         cycle?: unknown;
         referencing_tags?: unknown;
-        /** Attachment-tickets design (§2c "errors as JIT docs") — a short, imperative next-step, distinct from the older free-form `hint`. */
-        how_to?: string;
-        /** `read-attachment` (Wave 2) refusals — `image_too_large` / `unsupported_attachment_type` carry the attachment's actual byte size. */
-        size?: number;
-        /** `read-attachment` `image_too_large` — the 4 MiB cap it exceeded. */
-        max_bytes?: number;
-        /** `read-attachment` `unsupported_attachment_type` — the mime type that couldn't be read. */
-        mime_type?: string;
       };
       // Honest-queries validation errors (vault#550) — `limit`/`offset`/date
       // values that are structurally invalid rather than merely "no
@@ -413,21 +399,6 @@ export async function handleMcp(
           error_type: e.error_type,
           field: e.field,
           hint: e.hint,
-          // Forwarded when present (undefined keys are fine — JSON-RPC
-          // `data` just omits them) so a `structuredError()` call site that
-          // stamps extra fields — `limit`/`got`/`extension` (size/type
-          // refusals) or `how_to` (attachment-tickets' JIT-docs field, §2c)
-          // — isn't silently truncated down to error_type/field/hint by
-          // this backstop.
-          ...(e.limit !== undefined ? { limit: e.limit } : {}),
-          ...(e.got !== undefined ? { got: e.got } : {}),
-          ...(e.extension !== undefined ? { extension: e.extension } : {}),
-          ...(e.how_to !== undefined ? { how_to: e.how_to } : {}),
-          // read-attachment (Wave 2) refusal fields — same forward-when-present
-          // discipline as the ticket fields just above.
-          ...(e.size !== undefined ? { size: e.size } : {}),
-          ...(e.max_bytes !== undefined ? { max_bytes: e.max_bytes } : {}),
-          ...(e.mime_type !== undefined ? { mime_type: e.mime_type } : {}),
         });
       }
       return {

package/src/mcp-tools.ts

@@ -43,9 +43,6 @@ import {
 import { chooseHubOrigin, mintHubJwt, revokeHubJwt } from "./mcp-install.ts";
 import { looksLikeJwt } from "./hub-jwt.ts";
 import { readGlobalConfig, DEFAULT_PORT } from "./config.ts";
-import { getBaseUrl } from "./oauth-discovery.ts";
-import { getSharedAttachmentTicketProvider } from "./attachment-tickets.ts";
-import { createFsAttachmentBytesProvider } from "./attachment-bytes.ts";
 
 /**
  * Filter a vault projection to entries an in-scope tag contributes to.
@@ -113,12 +110,6 @@ export async function getServerInstruction(
     description: config?.description ?? null,
     projection,
     coordinates: resolveVaultCoordinates(),
-    // Bun always wires an in-process AttachmentTicketProvider AND a fresh
-    // fs-backed AttachmentBytesProvider per session (see
-    // `generateScopedMcpTools` below) — the connect-time brief can
-    // unconditionally teach both the ticket tools and read-attachment on
-    // this door.
-    attachments: { ticketsEnabled: true, readEnabled: true },
   });
 }
 
@@ -152,16 +143,6 @@ export function generateScopedMcpTools(
   vaultName: string,
   auth?: AuthResult,
   callerBearer?: string | null,
-  /**
-   * The incoming MCP request, when available (omitted by the many
-   * test-only call sites that construct tools without a live request).
-   * Threaded through ONLY so the attachment-ticket tools can resolve a
-   * request-accurate `urlBase` (honoring `X-Forwarded-Host`/proto, same as
-   * `getBaseUrl`) — falls back to `resolveVaultCoordinates()`'s configured/
-   * expose-state origin when omitted, so ticket tools are still present
-   * (just less precisely origined) in that case.
-   */
-  req?: Request,
 ): McpToolDef[] {
   const store = getVaultStore(vaultName);
 
@@ -244,48 +225,20 @@ export function generateScopedMcpTools(
     ? (info) => logStrictBypass(info)
     : undefined;
 
-  // Attachment tickets (Wave 1): bun always wires the in-process provider
-  // (see src/attachment-tickets.ts) — unlike the tag-scope predicates
-  // above, this isn't conditional on `scoped` because the tools should be
-  // listed for every session, scoped or not. Tag-scope confidentiality is
-  // still enforced (`noteVisible`, awaited inline inside the ticket tools'
-  // own async execute — see its doc comment in generateMcpTools for why
-  // this doesn't need the shared allowedHolder machinery the OTHER
-  // predicates above do).
-  const ticketNoteVisible = scoped
-    ? async (note: Note) => {
-        const allowed = await expandTokenTagScope(store, rawTags);
-        return noteWithinTagScope(note, allowed, rawTags);
-      }
-    : undefined;
-  const ticketUrlBase = req
-    ? `${getBaseUrl(req).replace(/\/$/, "")}/vault/${vaultName}`
-    : `${resolveVaultCoordinates().hubOrigin.replace(/\/$/, "")}/vault/${vaultName}`;
-
-  const tools = generateMcpTools(store, {
-    ...(expandVisibility ? { expandVisibility } : {}),
-    ...(nearTraversable ? { nearTraversable } : {}),
-    ...(ifExistsVisible ? { ifExistsVisible } : {}),
-    ...(aggregateVisibility ? { aggregateVisibility } : {}),
-    ...(writeContext ? { writeContext } : {}),
-    ...(strictBypass ? { strictBypass } : {}),
-    ...(onStrictBypass ? { onStrictBypass } : {}),
-    attachmentTickets: {
-      provider: getSharedAttachmentTicketProvider(),
-      vaultName,
-      urlBase: ticketUrlBase,
-      ...(ticketNoteVisible ? { noteVisible: ticketNoteVisible } : {}),
-    },
-    // Attachment bytes (Wave 2 model lane): bun always wires a fresh fs
-    // provider per session — cheap (stateless), unlike the ticket
-    // provider's process-wide shared Map. Same `ticketNoteVisible`
-    // tag-scope predicate as the ticket seam above (identical contract:
-    // "is the owning note in scope").
-    attachmentBytes: {
-      provider: createFsAttachmentBytesProvider(vaultName),
-      ...(ticketNoteVisible ? { noteVisible: ticketNoteVisible } : {}),
-    },
-  });
+  const tools = generateMcpTools(
+    store,
+    expandVisibility || nearTraversable || ifExistsVisible || aggregateVisibility || writeContext || strictBypass
+      ? {
+          ...(expandVisibility ? { expandVisibility } : {}),
+          ...(nearTraversable ? { nearTraversable } : {}),
+          ...(ifExistsVisible ? { ifExistsVisible } : {}),
+          ...(aggregateVisibility ? { aggregateVisibility } : {}),
+          ...(writeContext ? { writeContext } : {}),
+          ...(strictBypass ? { strictBypass } : {}),
+          ...(onStrictBypass ? { onStrictBypass } : {}),
+        }
+      : undefined,
+  );
 
   overrideVaultInfo(tools, vaultName, auth);
   applyTagDependencyGuards(tools, vaultName);

package/src/oauth-discovery.ts

@@ -27,7 +27,6 @@
  */
 
 import { getHubOrigin } from "./hub-jwt.ts";
-import { SCOPE_READ, SCOPE_WRITE } from "./scopes.ts";
 
 /**
  * OAuth scopes vault publishes through discovery, RESOURCE-NARROWED to the
@@ -88,36 +87,6 @@ export function handleProtectedResource(req: Request, vaultName: string): Respon
   });
 }
 
-/**
- * Protected Resource Metadata (RFC 9728) for the CANONICAL ROOT `/mcp`
- * endpoint (U1). Same document shape as `handleProtectedResource`, with two
- * deliberate differences that follow from the root being vault-AGNOSTIC (the
- * vault is derived from the token, not the URL):
- *
- *   - `resource` is the origin-root `<base>/mcp`, not a `/vault/<name>/mcp`.
- *   - `scopes_supported` advertises the UN-NARROWED forms `vault:read` /
- *     `vault:write` (there's no vault name to narrow to here). A spec-following
- *     client reads these and requests the broad forms; the hub's consent picker
- *     narrows the grant to a chosen vault at authorization time (that path
- *     already exists hub-side), minting a token stamped with a
- *     `vault:<name>:<verb>` scope + `aud=vault.<name>` — exactly what the root
- *     endpoint derives the target vault from. `admin` is intentionally omitted:
- *     the interactive connect flow grants read/write; admin is an operator
- *     concern, not something the consent picker offers.
- *
- * Served at the RFC 9728 §3.1 path-insertion location for the root resource:
- * `/.well-known/oauth-protected-resource/mcp`.
- */
-export function handleRootProtectedResource(req: Request): Response {
-  const base = getBaseUrl(req);
-  return Response.json({
-    resource: `${base}/mcp`,
-    authorization_servers: [getHubOrigin()],
-    scopes_supported: [SCOPE_READ, SCOPE_WRITE],
-    bearer_methods_supported: ["header"],
-  });
-}
-
 /**
  * OAuth 2.0 Authorization Server Metadata (RFC 8414).
  *

package/src/onboarding-seed.test.ts

@@ -23,17 +23,14 @@ import { BunStore } from "./vault-store.ts";
 import { seedOnboardingNotes } from "./onboarding-seed.ts";
 import {
   applySeedPack,
-  ARCHIVED_TAG,
   CAPTURE_ANYTHING_PATH,
   CONNECT_AI_PATH,
   GETTING_STARTED_PATH,
   NOTES_REQUIRED_TAGS,
-  STARTER_ONTOLOGY_PACK,
   SURFACE_STARTER_PACK,
   SURFACE_STARTER_PATH,
   TAGS_GRAPH_PATH,
   WELCOME_PATH,
-  welcomePack,
   YOURS_TO_KEEP_PATH,
 } from "../core/src/seed-packs.ts";
 import {
@@ -293,67 +290,6 @@ describe("applySeedPack — surface-starter via add-pack", () => {
   });
 });
 
-describe("applySeedPack — tag description preservation on re-apply (Aaron-ratified 2026-07-17)", () => {
-  test("fresh apply: a brand-new tag gets the pack's description, reported as touched not preserved", async () => {
-    const result = await applySeedPack(store, STARTER_ONTOLOGY_PACK);
-    expect(result.tags).toContain(ARCHIVED_TAG.name);
-    expect(result.preservedTagDescriptions).toEqual([]);
-
-    const record = await store.getTagRecord(ARCHIVED_TAG.name);
-    expect(record!.description).toBe(ARCHIVED_TAG.description);
-  });
-
-  test("re-apply unmodified: description is still the pack's text — upserted, not preserved", async () => {
-    await applySeedPack(store, STARTER_ONTOLOGY_PACK);
-    const rerun = await applySeedPack(store, STARTER_ONTOLOGY_PACK);
-    expect(rerun.preservedTagDescriptions).toEqual([]);
-
-    const record = await store.getTagRecord(ARCHIVED_TAG.name);
-    expect(record!.description).toBe(ARCHIVED_TAG.description);
-  });
-
-  test("re-apply after a user edit: the hand-tuned description survives and is reported preserved", async () => {
-    await applySeedPack(store, STARTER_ONTOLOGY_PACK);
-    const edited = "My own house rules for archiving — nothing like the default.";
-    await store.upsertTagRecord(ARCHIVED_TAG.name, { description: edited });
-
-    const rerun = await applySeedPack(store, STARTER_ONTOLOGY_PACK);
-    expect(rerun.preservedTagDescriptions).toContain(ARCHIVED_TAG.name);
-    // Still listed in `tags` — the tag itself was touched (fields/parent_names
-    // upsert unconditionally); only the description write was skipped.
-    expect(rerun.tags).toContain(ARCHIVED_TAG.name);
-
-    const record = await store.getTagRecord(ARCHIVED_TAG.name);
-    expect(record!.description).toBe(edited);
-  });
-
-  test("capture byte-identity anchor (NOTES_REQUIRED_TAGS) holds under either apply order", async () => {
-    // welcome, then starter-ontology.
-    await applySeedPack(store, welcomePack());
-    expect((await store.getTagRecord("capture"))!.description).toBe(
-      NOTES_REQUIRED_TAGS[0]!.description,
-    );
-    const afterOntology = await applySeedPack(store, STARTER_ONTOLOGY_PACK);
-    expect(afterOntology.preservedTagDescriptions).not.toContain("capture");
-    expect((await store.getTagRecord("capture"))!.description).toBe(
-      NOTES_REQUIRED_TAGS[0]!.description,
-    );
-  });
-
-  test("capture byte-identity anchor holds in the reverse order too", async () => {
-    // starter-ontology, then welcome.
-    await applySeedPack(store, STARTER_ONTOLOGY_PACK);
-    expect((await store.getTagRecord("capture"))!.description).toBe(
-      NOTES_REQUIRED_TAGS[0]!.description,
-    );
-    const afterWelcome = await applySeedPack(store, welcomePack());
-    expect(afterWelcome.preservedTagDescriptions).not.toContain("capture");
-    expect((await store.getTagRecord("capture"))!.description).toBe(
-      NOTES_REQUIRED_TAGS[0]!.description,
-    );
-  });
-});
-
 describe("vault-info / projection pointer (A2)", () => {
   test("projection carries getting_started when the note exists", async () => {
     // Absent before seeding → no pointer.