@remnic/core 9.69.39 → 9.69.40

package/src/activity/timeline/regenerate.test.ts

@@ -114,7 +114,6 @@ function priorEditsFromPrompt(prompt: string): unknown {
   return parsed.priorEdits;
 }
 
-
 test("disabled analysis persists deterministic cards and makes zero provider calls", async () => {
   await withStore(async (store, memoryDir) => {
     store.insertSnapshot(snapshot());
@@ -413,6 +412,88 @@ test("listPersistedTimelineDates lists only valid day files", async () => {
   }
 });
 
+test("a timezone change invalidates the cached day and re-analyzes (issue #2891)", async () => {
+  await withStore(async (store, memoryDir) => {
+    store.insertSnapshot(snapshot());
+    const remote = fakeRemote(async () => ({ content: '{"ops":[]}' }));
+    const analysis = parseActivityConfig({
+      timeline: { analysis: { enabled: true, provider: "openai", model: "gpt-test" } },
+    }).timeline.analysis;
+    const first = await regenerateTimelineDay({
+      date: DATE,
+      timezone: TZ,
+      memoryDir,
+      store,
+      timelineEnabled: true,
+      analysis,
+      deps: { remoteLlm: remote.remoteLlm },
+    });
+    assert.equal(first.status, "ok");
+    assert.equal(remote.calls, 1);
+    const sameTz = await regenerateTimelineDay({
+      date: DATE,
+      timezone: TZ,
+      memoryDir,
+      store,
+      timelineEnabled: true,
+      analysis,
+      deps: { remoteLlm: remote.remoteLlm },
+    });
+    assert.equal(sameTz.written, false);
+    assert.equal(remote.calls, 1);
+    const shifted = await regenerateTimelineDay({
+      date: DATE,
+      timezone: "America/New_York",
+      memoryDir,
+      store,
+      timelineEnabled: true,
+      analysis,
+      deps: { remoteLlm: remote.remoteLlm },
+    });
+    assert.equal(shifted.status, "ok");
+    assert.equal(shifted.written, true);
+    assert.equal(shifted.analyzed, true);
+    assert.equal(remote.calls, 2);
+    const persisted = JSON.parse(await readFile(timelineDayPath(memoryDir, DATE), "utf8"));
+    assert.equal(persisted.timezone, "America/New_York");
+  });
+});
+
+test("an empty day cached under one timezone is rebuilt under another (issue #2891)", async () => {
+  await withStore(async (store, memoryDir) => {
+    const remote = fakeRemote(async () => ({ content: '{"ops":[]}' }));
+    const analysis = parseActivityConfig({
+      timeline: { analysis: { enabled: true, provider: "openai", model: "gpt-test" } },
+    }).timeline.analysis;
+    const first = await regenerateTimelineDay({
+      date: DATE,
+      timezone: TZ,
+      memoryDir,
+      store,
+      timelineEnabled: true,
+      analysis,
+      deps: { remoteLlm: remote.remoteLlm },
+    });
+    assert.equal(first.status, "invalid_output");
+    assert.equal(first.analyzed, false);
+    assert.equal(remote.calls, 0);
+    const shifted = await regenerateTimelineDay({
+      date: DATE,
+      timezone: "America/New_York",
+      memoryDir,
+      store,
+      timelineEnabled: true,
+      analysis,
+      deps: { remoteLlm: remote.remoteLlm },
+    });
+    // Zero observations under any timezone: still a rebuild, never the
+    // UTC-cached file served with the old day derivation.
+    assert.equal(shifted.written, true);
+    const persisted = JSON.parse(await readFile(timelineDayPath(memoryDir, DATE), "utf8"));
+    assert.equal(persisted.timezone, "America/New_York");
+  });
+});
+
 test("a correction for another day does not change this day's hash, cache, or provider input", async () => {
   await withStore(async (store, memoryDir) => {
     store.insertSnapshot(snapshot());
@@ -502,4 +583,3 @@ test("a same-day correction updates hash, cards, and priorEdits", async () => {
     assert.notEqual(persistedSourceHash(await readFile(timelineDayPath(memoryDir, DATE), "utf8")), firstHash);
   });
 });
-

package/src/activity/timeline/regenerate.ts

@@ -191,12 +191,18 @@ function resolveClients(input: RegenerateTimelineDayInput): TimelineAnalysisClie
 }
 
 function sourceHash(input: {
+  timezone: string;
   observations: readonly TimelineObservation[];
   analysis: ActivityTimelineAnalysisConfig;
   corrections: readonly TimelineCorrection[];
 }): string {
   return hashActivityBody(
     JSON.stringify({
+      // The timezone is a day-window determinant (it bounds which
+      // observations the day sees), so it belongs to the source identity:
+      // identical observations under a different timezone must not reuse
+      // the cached day (issue #2891).
+      timezone: input.timezone,
       observations: input.observations.map((observation) => ({
         id: observation.id,
         contentHash: observation.contentHash,
@@ -310,7 +316,7 @@ async function regenerateUncached(input: RegenerateTimelineDayInput): Promise<Re
     const rawCards = buildTimelineDay({ date, timezone, observations }).cards;
     corrections = correctionsForCards(rawCards, corrections);
     const built = applyTimelineCorrections(rawCards, corrections);
-    const hash = sourceHash({ observations, analysis: input.analysis, corrections });
+    const hash = sourceHash({ timezone, observations, analysis: input.analysis, corrections });
     const prior = readPersisted(filePath);
     if (prior !== null && prior.sourceHash === hash && isCachedDayFinal(prior.status, input.analysis.enabled)) {
       return toResult(filePath, false, false, prior);

package/src/activity/vault-frontmatter.test.ts

@@ -1,7 +1,14 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import { applyVaultFrontmatter } from "./vault-frontmatter.js";
+import {
+  applyVaultFrontmatter,
+  renderVaultPropertyValue,
+  validateVaultProperties,
+  VAULT_PROPERTY_LIST_MAX_ITEMS,
+  VAULT_PROPERTY_SCALAR_MAX_CHARS,
+  VAULT_PROPERTY_TOTAL_MAX_CHARS,
+} from "./vault-frontmatter.js";
 
 test("applyVaultFrontmatter merges listed keys and sorts", () => {
   const merged = applyVaultFrontmatter("zeta: old\nalpha: keep\n", {
@@ -26,3 +33,94 @@ test("applyVaultFrontmatter leaves the original body unchanged when updates are
   const existing = "zeta: 1\n# comment stays\nalpha: 2\n";
   assert.equal(applyVaultFrontmatter(existing, {}), existing);
 });
+
+test("accepts a plain scalar and renders it verbatim (#2917)", () => {
+  assert.deepEqual(validateVaultProperties([{ key: "remnic_focus", value: "220" }]), { ok: true });
+  assert.equal(renderVaultPropertyValue("220"), "220");
+});
+
+test("accepts a list of plain scalars and renders a flow list (#2917)", () => {
+  assert.deepEqual(validateVaultProperties([{ key: "remnic_cards", value: ["a", "b"] }]), { ok: true });
+  assert.equal(renderVaultPropertyValue(["a", "b"]), "[a, b]");
+});
+
+test("rejects newline and control characters — the injection primitives (#2917)", () => {
+  assert.equal(validateVaultProperties([{ key: "remnic_x", value: "v\ninjected: yes" }]).ok, false);
+  assert.equal(validateVaultProperties([{ key: "remnic_x", value: "v\rinjected: yes" }]).ok, false);
+  assert.equal(validateVaultProperties([{ key: "remnic_x", value: "v\ttab" }]).ok, false);
+});
+
+test("rejects values whose YAML shape would change on re-read (#2917)", () => {
+  for (const value of [" padded", "padded ", "[seq]", "{map}", "#comment", "- item", "a #c", "ends:", "a: b"]) {
+    assert.equal(
+      validateVaultProperties([{ key: "remnic_x", value }]).ok,
+      false,
+      `value ${JSON.stringify(value)} must be rejected`,
+    );
+  }
+});
+
+test("a negative number stays a plain scalar (#2917)", () => {
+  assert.deepEqual(validateVaultProperties([{ key: "remnic_delta", value: "-5" }]), { ok: true });
+});
+
+test("rejects unsupported value shapes (#2917)", () => {
+  assert.equal(validateVaultProperties([{ key: "remnic_x", value: 42 as unknown as string }]).ok, false);
+  assert.equal(validateVaultProperties([{ key: "remnic_x", value: null as unknown as string }]).ok, false);
+  assert.equal(
+    validateVaultProperties([{ key: "remnic_x", value: { nested: true } as unknown as string }]).ok,
+    false,
+  );
+  assert.equal(validateVaultProperties([{ key: "remnic_x", value: [] as unknown as string[] }]).ok, false);
+});
+
+test("rejects oversize scalars, lists, keys, and totals (#2917)", () => {
+  assert.equal(
+    validateVaultProperties([{ key: "remnic_x", value: "v".repeat(VAULT_PROPERTY_SCALAR_MAX_CHARS + 1) }]).ok,
+    false,
+  );
+  assert.equal(validateVaultProperties([{ key: "x".repeat(65), value: "v" }]).ok, false);
+  const tooMany = Array.from({ length: VAULT_PROPERTY_LIST_MAX_ITEMS + 1 }, (_, i) => `item-${i}`);
+  assert.equal(validateVaultProperties([{ key: "remnic_x", value: tooMany }]).ok, false);
+  const entries = Array.from({ length: 30 }, (_, i) => ({
+    key: `remnic_k${i}`,
+    value: "v".repeat(100),
+  }));
+  assert.equal(
+    validateVaultProperties(entries).ok,
+    false,
+    `30 × 100+ chars must exceed the ${VAULT_PROPERTY_TOTAL_MAX_CHARS}-char total`,
+  );
+});
+
+test("rejects malformed keys (#2917)", () => {
+  assert.equal(validateVaultProperties([{ key: "remnic x:", value: "v" }]).ok, false);
+  assert.equal(validateVaultProperties([{ key: " padded", value: "v" }]).ok, false);
+  assert.equal(validateVaultProperties([{ key: "remnic#x", value: "v" }]).ok, false);
+  assert.equal(validateVaultProperties([{ key: "", value: "v" }]).ok, false);
+});
+
+test("rejects a final key that starts with a YAML indicator (#2917)", () => {
+  // Prefix "[" + key "focus" is the review case: the written line would
+  // be `[focus: 220`, which is not a mapping entry.
+  for (const key of ["[focus", "{focus", "*focus", "&focus", "!focus", "%focus"]) {
+    assert.equal(
+      validateVaultProperties([{ key, value: "220" }]).ok,
+      false,
+      `key ${JSON.stringify(key)} must be rejected`,
+    );
+  }
+  assert.deepEqual(validateVaultProperties([{ key: "remnic_focus", value: "220" }]), { ok: true });
+  assert.deepEqual(validateVaultProperties([{ key: "x_focus", value: "220" }]), { ok: true });
+});
+
+test("rejects flow delimiters inside list scalar items (#2917)", () => {
+  for (const item of ["a{", "a}", "a[", "a]", "a,b"]) {
+    assert.equal(
+      validateVaultProperties([{ key: "remnic_cards", value: [item] }]).ok,
+      false,
+      `list item ${JSON.stringify(item)} must be rejected`,
+    );
+  }
+  assert.deepEqual(validateVaultProperties([{ key: "remnic_cards", value: ["a", "b"] }]), { ok: true });
+});

package/src/activity/vault-frontmatter.ts

@@ -37,3 +37,134 @@ export function applyVaultFrontmatter(
     .map((key) => `${key}: ${merged.get(key)}`)
     .join("\n");
 }
+
+/**
+ * Frontmatter property boundary for the vault publisher (issue #2917).
+ *
+ * Property values written into note frontmatter must be single-line
+ * plain YAML scalars (or lists of them) whose rendered `key: value` line
+ * cannot change shape or inject keys when a YAML parser reads the note
+ * back. Validation is pure and total; the publisher runs it before any
+ * note byte is read or written, so a rejection can never leave a
+ * half-merged note behind.
+ */
+
+/** A supported property value: one plain scalar, or a list of them. */
+export type VaultPropertyValue = string | readonly string[];
+
+export const VAULT_PROPERTY_KEY_MAX_CHARS = 64;
+export const VAULT_PROPERTY_SCALAR_MAX_CHARS = 200;
+export const VAULT_PROPERTY_LIST_MAX_ITEMS = 20;
+export const VAULT_PROPERTY_TOTAL_MAX_CHARS = 2_000;
+
+// C0 controls, DEL, and C1 controls. Covers \n, \r, \t — a newline is the
+// frontmatter-injection primitive (`v\ninjected: yes` becomes a new key).
+const CONTROL_RE = /[\u0000-\u001f\u007f-\u009f]/;
+// Characters that make the first character a YAML indicator. `-`, `?`,
+// and `:` only indicate when followed by a space, so `-5` stays a plain
+// scalar while `- 5` does not.
+const INDICATOR_CHARS = ",[]{}#&*!|>'\"%@`";
+const INJECTION_RE = /: | #/;
+// Flow-collection delimiters. Lists render as `[a, b]`; a bare delimiter
+// inside an item splits or closes the sequence on re-read.
+const FLOW_ITEM_DELIM_RE = /[[\]{},]/;
+
+export type ValidateVaultPropertyResult = { ok: true } | { ok: false; reason: string };
+
+/** Render a validated value the way `mergeFrontmatterKeys` writes it. */
+export function renderVaultPropertyValue(value: VaultPropertyValue): string {
+  return typeof value === "string" ? value : `[${value.join(", ")}]`;
+}
+
+function hasLeadingYamlIndicator(text: string): boolean {
+  const first = text[0];
+  if (first === undefined) return false;
+  return INDICATOR_CHARS.includes(first) || ("-?:".includes(first) && text[1] === " ");
+}
+
+function validateScalar(value: string, label: string): ValidateVaultPropertyResult {
+  if (value.length === 0) {
+    return { ok: false, reason: `${label} must not be empty` };
+  }
+  if (value.length > VAULT_PROPERTY_SCALAR_MAX_CHARS) {
+    return { ok: false, reason: `${label} exceeds ${VAULT_PROPERTY_SCALAR_MAX_CHARS} characters` };
+  }
+  if (CONTROL_RE.test(value)) {
+    return { ok: false, reason: `${label} must not contain control characters or line breaks` };
+  }
+  if (value !== value.trim()) {
+    return { ok: false, reason: `${label} must not carry leading or trailing whitespace` };
+  }
+  if (hasLeadingYamlIndicator(value)) {
+    return { ok: false, reason: `${label} must be a plain scalar (leading "${value[0]}" changes its YAML shape)` };
+  }
+  if (INJECTION_RE.test(value)) {
+    return { ok: false, reason: `${label} must not contain ": " or " #"` };
+  }
+  if (value.endsWith(":")) {
+    return { ok: false, reason: `${label} must not end with ":"` };
+  }
+  return { ok: true };
+}
+
+/**
+ * Validate the final (already-prefixed) property set a publish would
+ * write: key shape, per-value scalar/list shape, per-value bounds, and
+ * the total rendered size across every entry.
+ */
+export function validateVaultProperties(
+  entries: ReadonlyArray<{ key: string; value: VaultPropertyValue }>,
+): ValidateVaultPropertyResult {
+  let total = 0;
+  for (const { key, value } of entries) {
+    if (key.length === 0) {
+      return { ok: false, reason: "property keys must not be empty" };
+    }
+    if (key.length > VAULT_PROPERTY_KEY_MAX_CHARS) {
+      return { ok: false, reason: `property key exceeds ${VAULT_PROPERTY_KEY_MAX_CHARS} characters` };
+    }
+    if (
+      CONTROL_RE.test(key) ||
+      key !== key.trim() ||
+      key.includes(":") ||
+      key.includes("#") ||
+      hasLeadingYamlIndicator(key)
+    ) {
+      return { ok: false, reason: `property key ${JSON.stringify(key)} is not a plain mapping key` };
+    }
+    if (typeof value === "string") {
+      const scalar = validateScalar(value, `property ${key}`);
+      if (!scalar.ok) return scalar;
+    } else {
+      if (!Array.isArray(value) || value.length === 0) {
+        return { ok: false, reason: `property ${key} must be a scalar string or a non-empty list of scalar strings` };
+      }
+      if (value.length > VAULT_PROPERTY_LIST_MAX_ITEMS) {
+        return { ok: false, reason: `property ${key} exceeds ${VAULT_PROPERTY_LIST_MAX_ITEMS} list items` };
+      }
+      for (const item of value) {
+        if (typeof item !== "string") {
+          return { ok: false, reason: `property ${key} must be a scalar string or a list of scalar strings` };
+        }
+        const scalar = validateScalar(item, `property ${key} list item`);
+        if (!scalar.ok) return scalar;
+        // Lists render in flow form `[a, b]`; a bare delimiter inside an
+        // item would split or close the sequence on re-read.
+        if (FLOW_ITEM_DELIM_RE.test(item)) {
+          return {
+            ok: false,
+            reason: `property ${key} list item must not contain flow delimiters "[", "]", "{", "}", or ","`,
+          };
+        }
+      }
+    }
+    total += key.length + 2 + renderVaultPropertyValue(value).length;
+    if (total > VAULT_PROPERTY_TOTAL_MAX_CHARS) {
+      return {
+        ok: false,
+        reason: `frontmatter properties exceed the ${VAULT_PROPERTY_TOTAL_MAX_CHARS}-character total`,
+      };
+    }
+  }
+  return { ok: true };
+}

package/src/activity/vault-publish.ts

@@ -261,6 +261,12 @@ export function parseAtxHeading(line: string): { level: number; text: string } |
   return { level, text: line.slice(start, end) };
 }
 
+/** True when `## ${name}` parses back to the same heading text. */
+export function headingSurvivesRoundTrip(name: string): boolean {
+  const parsed = parseAtxHeading(`## ${name}`);
+  return parsed !== null && parsed.text === name;
+}
+
 export function publishVaultRegion(input: {
   vaultPath: string;
   relativeFile: string;

package/src/activity/vault-publisher.test.ts

@@ -879,3 +879,175 @@ test("a concurrent editor save between read and rename aborts the publish and ke
     setVaultPublisherTestHooks(null);
   }
 });
+
+// ── Input-boundary regressions (issue #2917) ────────────────────────────
+// Every rejection below must fire before any file byte is read or written.
+
+test("a whitespace-padded section name is rejected, not silently trimmed (#2917)", () => {
+  const { vault, notePath } = makeVault();
+  const before = readFileSync(notePath, "utf8");
+  assert.throws(
+    () =>
+      publishVaultNote({
+        vaultPath: vault,
+        notePathTemplate: "{yyyy}-{MM}-{dd}.md",
+        date: DATE,
+        sections: [{ name: " timeline ", content: "fresh recap" }],
+      }),
+    /is not a valid region name/,
+  );
+  assert.equal(readFileSync(notePath, "utf8"), before, "the note is untouched");
+});
+
+test("a heading-strategy section name that cannot round-trip through the heading parser is rejected (#2917)", () => {
+  const { vault, notePath } = makeVault();
+  const before = readFileSync(notePath, "utf8");
+  // `## Timeline #` parses back as `Timeline` (closing hash sequence), so
+  // the region could never be matched on any publish.
+  assert.throws(
+    () =>
+      publishVaultNote({
+        vaultPath: vault,
+        notePathTemplate: "{yyyy}-{MM}-{dd}.md",
+        date: DATE,
+        strategy: "heading",
+        sections: [{ name: "Timeline #", content: "fresh recap" }],
+      }),
+    /not matchable by the heading parser/,
+  );
+  assert.equal(readFileSync(notePath, "utf8"), before, "the note is untouched");
+});
+
+test("a newline-bearing frontmatter value is rejected before any file mutation (#2917)", () => {
+  const { vault, notePath } = makeVault();
+  const before = readFileSync(notePath, "utf8");
+  const mtime = statSync(notePath).mtimeMs;
+  assert.throws(
+    () =>
+      publishVaultNote({
+        vaultPath: vault,
+        notePathTemplate: "{yyyy}-{MM}-{dd}.md",
+        date: DATE,
+        sections: [
+          {
+            name: "timeline",
+            content: "fresh recap",
+            properties: { focus: "220\ninjected: yes" },
+          },
+        ],
+        propertiesMode: "frontmatter",
+      }),
+    /control characters or line breaks/,
+  );
+  assert.equal(readFileSync(notePath, "utf8"), before, "the note is untouched");
+  assert.equal(statSync(notePath).mtimeMs, mtime, "no write attempt was made");
+});
+
+test("an oversize or injection-shaped frontmatter value is rejected before any file mutation (#2917)", () => {
+  const { vault, notePath } = makeVault();
+  const before = readFileSync(notePath, "utf8");
+  for (const value of ["x".repeat(201), "[flow]", "a #comment", " leading-space"] as const) {
+    assert.throws(
+      () =>
+        publishVaultNote({
+          vaultPath: vault,
+          notePathTemplate: "{yyyy}-{MM}-{dd}.md",
+          date: DATE,
+          sections: [{ name: "timeline", content: "fresh recap", properties: { focus: value } }],
+          propertiesMode: "frontmatter",
+        }),
+      RangeError,
+      `value ${JSON.stringify(value)} must be rejected at the boundary`,
+    );
+  }
+  assert.equal(readFileSync(notePath, "utf8"), before, "the note is untouched");
+});
+
+test("a valid list property publishes as a flow list in frontmatter (#2917)", () => {
+  const { vault, notePath } = makeVault();
+  const status = publishVaultNote({
+    vaultPath: vault,
+    notePathTemplate: "Daily Notes/{yyyy}/{MM}/{yyyy}-{MM}-{dd}.md",
+    date: DATE,
+    sections: [{ name: "timeline", content: "fresh recap", properties: { cards: ["a", "b"] } }],
+    propertiesMode: "frontmatter",
+  });
+  const after = readFileSync(notePath, "utf8");
+  assert.match(after, /^remnic_cards: \[a, b\]$/m);
+});
+
+test("frontmatter property totals are bounded across sections (#2917)", () => {
+  const { vault, notePath } = makeVault();
+  const before = readFileSync(notePath, "utf8");
+  // Each value is under the per-scalar cap; the SUM crosses the total.
+  const big = "v".repeat(200);
+  const properties = Object.fromEntries(
+    Array.from({ length: 12 }, (_, i) => [`k${i}`, big]),
+  );
+  assert.throws(
+    () =>
+      publishVaultNote({
+        vaultPath: vault,
+        notePathTemplate: "{yyyy}-{MM}-{dd}.md",
+        date: DATE,
+        sections: [
+          { name: "timeline", content: "fresh recap", properties },
+        ],
+        propertiesMode: "frontmatter",
+      }),
+    /character total/,
+  );
+  assert.equal(readFileSync(notePath, "utf8"), before, "the note is untouched");
+});
+
+test("a prefix that makes the final key start with a YAML indicator is rejected before any file mutation (#2917)", () => {
+  const { vault, notePath } = makeVault();
+  const before = readFileSync(notePath, "utf8");
+  const mtime = statSync(notePath).mtimeMs;
+  assert.throws(
+    () =>
+      publishVaultNote({
+        vaultPath: vault,
+        notePathTemplate: "{yyyy}-{MM}-{dd}.md",
+        date: DATE,
+        sections: [{ name: "timeline", content: "fresh recap", properties: { focus: "220" } }],
+        propertiesMode: "frontmatter",
+        propertiesPrefix: "[",
+      }),
+    /not a plain mapping key/,
+  );
+  assert.equal(readFileSync(notePath, "utf8"), before, "the note is untouched");
+  assert.equal(statSync(notePath).mtimeMs, mtime, "no write attempt was made");
+});
+
+test("a list item carrying a flow delimiter is rejected before any file mutation (#2917)", () => {
+  const { vault, notePath } = makeVault();
+  const before = readFileSync(notePath, "utf8");
+  const mtime = statSync(notePath).mtimeMs;
+  assert.throws(
+    () =>
+      publishVaultNote({
+        vaultPath: vault,
+        notePathTemplate: "{yyyy}-{MM}-{dd}.md",
+        date: DATE,
+        sections: [{ name: "timeline", content: "fresh recap", properties: { cards: ["a{"] } }],
+        propertiesMode: "frontmatter",
+      }),
+    /flow delimiter/,
+  );
+  assert.equal(readFileSync(notePath, "utf8"), before, "the note is untouched");
+  assert.equal(statSync(notePath).mtimeMs, mtime, "no write attempt was made");
+});
+
+test("a valid prefix still publishes a plain final key (#2917)", () => {
+  const { vault, notePath } = makeVault();
+  publishVaultNote({
+    vaultPath: vault,
+    notePathTemplate: "Daily Notes/{yyyy}/{MM}/{yyyy}-{MM}-{dd}.md",
+    date: DATE,
+    sections: [{ name: "timeline", content: "fresh recap", properties: { focus: "220" } }],
+    propertiesMode: "frontmatter",
+    propertiesPrefix: "x_",
+  });
+  assert.match(readFileSync(notePath, "utf8"), /^x_focus: 220$/m);
+});