@vellumai/assistant 0.11.0 → 0.11.1-staging.2

package/src/__tests__/wake-schedule-trust.test.ts

@@ -0,0 +1,255 @@
+/**
+ * What a deferred wake's row must prove before its turn can recover the target
+ * conversation's resting trust.
+ *
+ * The scheduler's due-tick has no caller: it cannot re-derive who chose the
+ * wake's target or its trigger text, so the row itself has to carry that proof
+ * in fields no update path can rewrite. Two independent conditions must hold,
+ * and this file covers both plus every way each one fails.
+ *
+ * Authorization of the firing ITSELF (who may edit, enable, or trigger a wake
+ * schedule) is a route concern and lives in `wake-schedule-escalation.test.ts`.
+ */
+
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { recoverRestingTrustContext } from "../daemon/conversation-resting-trust.js";
+import {
+  FALLBACK_TURN_TRUST,
+  INTERNAL_GUARDIAN_TRUST_CONTEXT,
+  resolveTrustClass,
+} from "../daemon/trust-context.js";
+import type { TrustContext } from "../daemon/trust-context-types.js";
+import {
+  createConversation,
+  setConversationOriginChannelIfUnset,
+} from "../persistence/conversation-crud.js";
+import { getDb, getSqliteFrom } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+import type { WakeOptions } from "../runtime/agent-wake.js";
+import { resolveCapabilities } from "../runtime/capabilities.js";
+import {
+  LEGACY_DEFER_CREATED_BY,
+  OWNER_DEFER_CREATED_BY,
+} from "../schedule/defer-provenance.js";
+import { buildWakeScheduleOptions } from "../schedule/wake-schedule-options.js";
+import { resolveSensitiveToolDecision } from "../tools/tool-approval-handler.js";
+
+await initializeDb();
+
+const TARGET = "conv-guardian-owned";
+
+/**
+ * A row as `createOwnerDeferredWake` writes it: owner provenance, and a
+ * source-conversation binding equal to the wake target.
+ */
+const OWNER_WAKE_JOB = {
+  message: "Check back on this",
+  inferenceProfile: null,
+  createdBy: OWNER_DEFER_CREATED_BY,
+  createdFromConversationId: TARGET,
+};
+
+/** A defer carrying legacy provenance, which records no author. */
+const LEGACY_WAKE_JOB = {
+  ...OWNER_WAKE_JOB,
+  createdBy: LEGACY_DEFER_CREATED_BY,
+};
+
+/**
+ * Write a raw `origin_channel` the canonical channel set does not contain, the
+ * way a row from a newer build, a renamed channel id, or corrupted data would
+ * look. `setConversationOriginChannelIfUnset` only accepts a `ChannelId`, so
+ * this has to go in under the type system.
+ */
+function writeRawOriginChannel(conversationId: string, raw: string): void {
+  getSqliteFrom(getDb()).run(
+    "UPDATE conversations SET origin_channel = ? WHERE id = ?",
+    [raw, conversationId],
+  );
+}
+
+/**
+ * The decision the sensitive-tool gate reaches for an invocation with the given
+ * resting trust, with no channel approval cell to lift the floor. Absent trust
+ * is what a wake with no `trustContext` resolves at tool-setup time
+ * (`currentTurnTrustContext ?? trustContext ?? FALLBACK_TURN_TRUST`).
+ */
+function gateDecision(
+  trustContext: TrustContext | null | undefined,
+  reach: "sandbox" | "host",
+): string {
+  const { sensitiveToolApproval } = resolveCapabilities(
+    resolveTrustClass(trustContext ?? FALLBACK_TURN_TRUST),
+  );
+  return resolveSensitiveToolDecision({
+    reach,
+    cellThreshold: undefined,
+    sensitiveToolApproval,
+  });
+}
+
+/** The gate decision a wake built with these options would reach for `bash`. */
+function wakeGateDecision(options: WakeOptions): string {
+  return gateDecision(options.trustContext, "sandbox");
+}
+
+describe("an owner-authored defer on a guardian-owned conversation", () => {
+  beforeEach(() => {
+    getDb().run("DELETE FROM messages");
+    getDb().run("DELETE FROM conversations");
+    createConversation({ id: TARGET });
+  });
+
+  test("recovers the target's guardian resting trust", () => {
+    expect(buildWakeScheduleOptions(OWNER_WAKE_JOB, TARGET)).toEqual({
+      conversationId: TARGET,
+      hint: "Check back on this",
+      source: "defer",
+      persistTriggerAsEvent: true,
+      trustContext: INTERNAL_GUARDIAN_TRUST_CONTEXT,
+    });
+  });
+
+  test("clears the sensitive-tool gate at both reaches", () => {
+    const options = buildWakeScheduleOptions(OWNER_WAKE_JOB, TARGET);
+
+    // `bash` in the workspace sandbox and a host-reaching invocation alike.
+    // This is what lets a resumed deferral keep using the tools it was using
+    // when it deferred.
+    expect(gateDecision(options.trustContext, "sandbox")).toBe("proceed");
+    expect(gateDecision(options.trustContext, "host")).toBe("proceed");
+  });
+
+  test("the internal vellum channel counts as guardian-owned", () => {
+    createConversation({ id: "conv-vellum" });
+    setConversationOriginChannelIfUnset("conv-vellum", "vellum");
+
+    expect(
+      buildWakeScheduleOptions(
+        { ...OWNER_WAKE_JOB, createdFromConversationId: "conv-vellum" },
+        "conv-vellum",
+      ),
+    ).toHaveProperty("trustContext", INTERNAL_GUARDIAN_TRUST_CONTEXT);
+  });
+
+  test("the schedule's inference profile still rides along", () => {
+    expect(
+      buildWakeScheduleOptions(
+        { ...OWNER_WAKE_JOB, inferenceProfile: "fast" },
+        TARGET,
+      ),
+    ).toHaveProperty("forceOverrideProfile", "fast");
+  });
+});
+
+describe("a row without owner provenance recovers nothing", () => {
+  beforeEach(() => {
+    getDb().run("DELETE FROM messages");
+    getDb().run("DELETE FROM conversations");
+    createConversation({ id: TARGET });
+  });
+
+  test("a legacy defer fails closed even on a guardian-owned target", () => {
+    // A legacy row records no author for its target or text, so a retargeted
+    // one is indistinguishable from an untouched one. Such rows keep firing;
+    // they never recover trust.
+    const options = buildWakeScheduleOptions(LEGACY_WAKE_JOB, TARGET);
+
+    expect(options).not.toHaveProperty("trustContext");
+    expect(wakeGateDecision(options)).toBe("deny");
+  });
+
+  test("an unmarked schedule fails closed", () => {
+    const options = buildWakeScheduleOptions(
+      { ...OWNER_WAKE_JOB, createdBy: "agent" },
+      TARGET,
+    );
+
+    expect(options).not.toHaveProperty("trustContext");
+    expect(wakeGateDecision(options)).toBe("deny");
+  });
+
+  test("a marked row whose source binding was never set fails closed", () => {
+    const options = buildWakeScheduleOptions(
+      { ...OWNER_WAKE_JOB, createdFromConversationId: null },
+      TARGET,
+    );
+
+    expect(options).not.toHaveProperty("trustContext");
+    expect(wakeGateDecision(options)).toBe("deny");
+  });
+
+  test("a marked row retargeted away from its source binding fails closed", () => {
+    // The second half of the proof, standing on its own: even if the marker
+    // survived and the route guard were bypassed or regressed, moving
+    // `wakeConversationId` breaks the equality with the write-once source
+    // binding, so the retargeted row cannot elevate.
+    const options = buildWakeScheduleOptions(
+      { ...OWNER_WAKE_JOB, createdFromConversationId: "conv-somewhere-else" },
+      TARGET,
+    );
+
+    expect(options).not.toHaveProperty("trustContext");
+    expect(wakeGateDecision(options)).toBe("deny");
+  });
+});
+
+describe("target provenance still bounds an owner-authored defer", () => {
+  beforeEach(() => {
+    getDb().run("DELETE FROM messages");
+    getDb().run("DELETE FROM conversations");
+  });
+
+  /** An owner-marked row correctly bound to `conversationId`. */
+  function ownerJobFor(conversationId: string) {
+    return { ...OWNER_WAKE_JOB, createdFromConversationId: conversationId };
+  }
+
+  test("a remote-channel target recovers nothing", () => {
+    createConversation({ id: "conv-remote" });
+    setConversationOriginChannelIfUnset("conv-remote", "telegram");
+
+    const options = buildWakeScheduleOptions(
+      ownerJobFor("conv-remote"),
+      "conv-remote",
+    );
+
+    // Absent, not `undefined`: a fabricated context would either hand a
+    // remote-origin conversation the guardian's capabilities or bury the reply
+    // under `unknown` provenance.
+    expect(options).not.toHaveProperty("trustContext");
+    expect(wakeGateDecision(options)).toBe("deny");
+  });
+
+  test("an unrecognized stored origin recovers nothing", () => {
+    // `getConversationOriginChannel` would collapse an unparseable value into
+    // the same `null` an unset column yields, which would read as local. A row
+    // from a newer build, a renamed channel id, or corrupted data must land
+    // where a remote channel lands.
+    createConversation({ id: "conv-future" });
+    writeRawOriginChannel("conv-future", "channel-from-a-newer-build");
+
+    expect(recoverRestingTrustContext("conv-future")).toBeNull();
+    expect(
+      buildWakeScheduleOptions(ownerJobFor("conv-future"), "conv-future"),
+    ).not.toHaveProperty("trustContext");
+  });
+
+  test("an empty-string origin recovers nothing", () => {
+    createConversation({ id: "conv-blank" });
+    writeRawOriginChannel("conv-blank", "");
+
+    expect(recoverRestingTrustContext("conv-blank")).toBeNull();
+  });
+
+  test("a conversation that does not exist recovers nothing", () => {
+    // Inert in practice (the wake rejects it as `not_found` before a turn
+    // runs), but trust is granted on a positively recognized local origin, so
+    // an absent row must never be one.
+    expect(recoverRestingTrustContext("conv-missing")).toBeNull();
+    expect(
+      buildWakeScheduleOptions(ownerJobFor("conv-missing"), "conv-missing"),
+    ).not.toHaveProperty("trustContext");
+  });
+});

package/src/__tests__/web-fetch.test.ts

@@ -645,8 +645,12 @@ describe("web_fetch tool", () => {
       { url: "https://example.com/start" },
       {
         resolveHostAddresses: async (hostname) => {
-          if (hostname === "example.com") return ["93.184.216.34"];
-          if (hostname === "evil-redirect.example") return ["192.168.1.100"];
+          if (hostname === "example.com") {
+            return ["93.184.216.34"];
+          }
+          if (hostname === "evil-redirect.example") {
+            return ["192.168.1.100"];
+          }
           return ["93.184.216.34"];
         },
         requestExecutor: async (_url, _requestOptions) => {
@@ -1289,8 +1293,12 @@ describe("web_fetch tool", () => {
       { url: "https://example.com/start" },
       {
         resolveHostAddresses: async (hostname) => {
-          if (hostname === "example.com") return ["93.184.216.34"];
-          if (hostname === "redirect.example") return ["203.0.113.8"];
+          if (hostname === "example.com") {
+            return ["93.184.216.34"];
+          }
+          if (hostname === "redirect.example") {
+            return ["203.0.113.8"];
+          }
           return ["93.184.216.34"];
         },
         requestExecutor: async (_url, requestOptions) => {
@@ -1360,8 +1368,12 @@ describe("web_fetch tool", () => {
       { url: "https://example.com/start" },
       {
         resolveHostAddresses: async (hostname) => {
-          if (hostname === "example.com") return ["93.184.216.34"];
-          if (hostname === "internal.example") return ["10.0.0.8"];
+          if (hostname === "example.com") {
+            return ["93.184.216.34"];
+          }
+          if (hostname === "internal.example") {
+            return ["10.0.0.8"];
+          }
           return ["93.184.216.34"];
         },
       },
@@ -1379,7 +1391,9 @@ describe("web_fetch tool", () => {
       { url: "https://example.com/start", timeout_seconds: 1 },
       {
         resolveHostAddresses: async (hostname) => {
-          if (hostname === "example.com") return ["93.184.216.34"];
+          if (hostname === "example.com") {
+            return ["93.184.216.34"];
+          }
           return await new Promise<string[]>(() => {});
         },
         requestExecutor: async () => {

package/src/__tests__/web-search-catalog-parity.test.ts

@@ -60,11 +60,18 @@ function entryToPlain(
     out.displayNameLong = entry.displayNameLong;
   }
   out.kind = entry.kind;
-  if (entry.apiKeyPrefix !== undefined) out.apiKeyPrefix = entry.apiKeyPrefix;
-  if (entry.envVar !== undefined) out.envVar = entry.envVar;
-  if (entry.secretKey !== undefined) out.secretKey = entry.secretKey;
-  if (entry.fallbackOrder !== undefined)
+  if (entry.apiKeyPrefix !== undefined) {
+    out.apiKeyPrefix = entry.apiKeyPrefix;
+  }
+  if (entry.envVar !== undefined) {
+    out.envVar = entry.envVar;
+  }
+  if (entry.secretKey !== undefined) {
+    out.secretKey = entry.secretKey;
+  }
+  if (entry.fallbackOrder !== undefined) {
     out.fallbackOrder = entry.fallbackOrder;
+  }
   if (entry.privacyPolicyUrl !== undefined) {
     out.privacyPolicyUrl = entry.privacyPolicyUrl;
   }

package/src/__tests__/web-search-history.test.ts

@@ -10,9 +10,8 @@ describe("stripHistoricalWebSearchResults", () => {
       { role: "assistant", content: [{ type: "text", text: "Hi" }] },
     ];
 
-    const { messages: result, stats } = stripHistoricalWebSearchResults(
-      messages,
-    );
+    const { messages: result, stats } =
+      stripHistoricalWebSearchResults(messages);
 
     expect(result).toEqual(messages);
     expect(stats.blocksStripped).toBe(0);
@@ -20,68 +19,64 @@ describe("stripHistoricalWebSearchResults", () => {
     expect(stats.messagesModified).toBe(0);
   });
 
-  test(
-    "replaces historical web_search_tool_result with text summary including title+url",
-    () => {
-      const messages: Message[] = [
-        { role: "user", content: [{ type: "text", text: "Search cats" }] },
-        {
-          role: "assistant",
-          content: [
-            { type: "text", text: "Let me look" },
-            {
-              type: "server_tool_use",
-              id: "stu_1",
-              name: "web_search",
-              input: { query: "cats" },
-            },
-            {
-              type: "web_search_tool_result",
-              tool_use_id: "stu_1",
-              content: [
-                {
-                  type: "web_search_result",
-                  url: "https://cats.com",
-                  title: "Cats!",
-                  encrypted_content: "expired_token_1",
-                },
-                {
-                  type: "web_search_result",
-                  url: "https://felines.org",
-                  title: "Feline facts",
-                  encrypted_content: "expired_token_2",
-                },
-              ],
-            },
-            { type: "text", text: "Here's what I found." },
-          ],
-        },
-      ];
+  test("replaces historical web_search_tool_result with text summary including title+url", () => {
+    const messages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "Search cats" }] },
+      {
+        role: "assistant",
+        content: [
+          { type: "text", text: "Let me look" },
+          {
+            type: "server_tool_use",
+            id: "stu_1",
+            name: "web_search",
+            input: { query: "cats" },
+          },
+          {
+            type: "web_search_tool_result",
+            tool_use_id: "stu_1",
+            content: [
+              {
+                type: "web_search_result",
+                url: "https://cats.com",
+                title: "Cats!",
+                encrypted_content: "expired_token_1",
+              },
+              {
+                type: "web_search_result",
+                url: "https://felines.org",
+                title: "Feline facts",
+                encrypted_content: "expired_token_2",
+              },
+            ],
+          },
+          { type: "text", text: "Here's what I found." },
+        ],
+      },
+    ];
 
-      const { messages: result, stats } = stripHistoricalWebSearchResults(
-        messages,
-      );
+    const { messages: result, stats } =
+      stripHistoricalWebSearchResults(messages);
 
-      expect(stats.blocksStripped).toBe(1);
-      expect(stats.serverToolUsesDropped).toBe(1);
-      expect(stats.messagesModified).toBe(1);
+    expect(stats.blocksStripped).toBe(1);
+    expect(stats.serverToolUsesDropped).toBe(1);
+    expect(stats.messagesModified).toBe(1);
 
-      const assistantMsg = result[1];
-      const types = assistantMsg.content.map((b) => b.type);
-      expect(types).toEqual(["text", "text", "text"]);
+    const assistantMsg = result[1];
+    const types = assistantMsg.content.map((b) => b.type);
+    expect(types).toEqual(["text", "text", "text"]);
 
-      const summary = assistantMsg.content[1];
-      expect(summary.type).toBe("text");
-      if (summary.type === "text") {
-        expect(summary.text).toContain("cats");
-        expect(summary.text).toContain("Cats!");
-        expect(summary.text).toContain("https://cats.com");
-        expect(summary.text).toContain("Feline facts");
-        expect(summary.text).toContain("https://felines.org");
-        expect(summary.text).not.toContain("expired_token_1");
-      }
-    },
-  );
+    const summary = assistantMsg.content[1];
+    expect(summary.type).toBe("text");
+    if (summary.type === "text") {
+      expect(summary.text).toContain("cats");
+      expect(summary.text).toContain("Cats!");
+      expect(summary.text).toContain("https://cats.com");
+      expect(summary.text).toContain("Feline facts");
+      expect(summary.text).toContain("https://felines.org");
+      expect(summary.text).not.toContain("expired_token_1");
+    }
+  });
 
   test("drops server_tool_use paired with converted results", () => {
     const messages: Message[] = [
@@ -110,9 +105,8 @@ describe("stripHistoricalWebSearchResults", () => {
       },
     ];
 
-    const { messages: result, stats } = stripHistoricalWebSearchResults(
-      messages,
-    );
+    const { messages: result, stats } =
+      stripHistoricalWebSearchResults(messages);
 
     expect(stats.blocksStripped).toBe(1);
     expect(stats.serverToolUsesDropped).toBe(1);
@@ -153,9 +147,8 @@ describe("stripHistoricalWebSearchResults", () => {
       },
     ];
 
-    const { messages: result, stats } = stripHistoricalWebSearchResults(
-      messages,
-    );
+    const { messages: result, stats } =
+      stripHistoricalWebSearchResults(messages);
 
     expect(stats.serverToolUsesDropped).toBe(1);
     const types = result[0].content.map((b) => b.type);
@@ -190,9 +183,8 @@ describe("stripHistoricalWebSearchResults", () => {
       },
     ];
 
-    const { messages: result, stats } = stripHistoricalWebSearchResults(
-      messages,
-    );
+    const { messages: result, stats } =
+      stripHistoricalWebSearchResults(messages);
 
     expect(stats.blocksStripped).toBe(1);
     expect(result[0].content).toHaveLength(1);
@@ -224,9 +216,8 @@ describe("stripHistoricalWebSearchResults", () => {
       },
     ];
 
-    const { messages: result, stats } = stripHistoricalWebSearchResults(
-      messages,
-    );
+    const { messages: result, stats } =
+      stripHistoricalWebSearchResults(messages);
 
     expect(stats.blocksStripped).toBe(1);
     expect(stats.serverToolUsesDropped).toBe(0);
@@ -284,9 +275,8 @@ describe("stripHistoricalWebSearchResults", () => {
       },
     ];
 
-    const { messages: result, stats } = stripHistoricalWebSearchResults(
-      messages,
-    );
+    const { messages: result, stats } =
+      stripHistoricalWebSearchResults(messages);
 
     expect(stats.blocksStripped).toBe(2);
     expect(stats.serverToolUsesDropped).toBe(2);
@@ -297,8 +287,12 @@ describe("stripHistoricalWebSearchResults", () => {
 
     const first = result[0].content[0];
     const second = result[0].content[2];
-    if (first.type === "text") expect(first.text).toContain("first");
-    if (second.type === "text") expect(second.text).toContain("second");
+    if (first.type === "text") {
+      expect(first.text).toContain("first");
+    }
+    if (second.type === "text") {
+      expect(second.text).toContain("second");
+    }
   });
 
   test("does not mutate the input messages array", () => {

package/src/__tests__/web-search.test.ts

@@ -798,8 +798,12 @@ async function executeBraveSearchHelper(
           const r = results[i];
           lines.push(`${i + 1}. ${r.title}`);
           lines.push(`   URL: ${r.url}`);
-          if (r.description) lines.push(`   ${r.description}`);
-          if (r.age) lines.push(`   Age: ${r.age}`);
+          if (r.description) {
+            lines.push(`   ${r.description}`);
+          }
+          if (r.age) {
+            lines.push(`   Age: ${r.age}`);
+          }
           if (r.extra_snippets && r.extra_snippets.length > 0) {
             for (const snippet of r.extra_snippets) {
               lines.push(`   > ${snippet}`);
@@ -978,7 +982,9 @@ async function executeTavilySearchHelper(
     search_depth: "advanced",
     max_results: count,
   };
-  if (timeRange) body.time_range = timeRange;
+  if (timeRange) {
+    body.time_range = timeRange;
+  }
 
   const MAX_RETRIES = 3;
   const BASE_DELAY_MS = 1;
@@ -1012,8 +1018,12 @@ async function executeTavilySearchHelper(
           const r = results[i];
           const title = r.title?.trim() || r.url?.trim() || "Untitled result";
           lines.push(`${i + 1}. ${title}`);
-          if (r.url) lines.push(`   URL: ${r.url}`);
-          if (r.content) lines.push(`   ${r.content}`);
+          if (r.url) {
+            lines.push(`   URL: ${r.url}`);
+          }
+          if (r.content) {
+            lines.push(`   ${r.content}`);
+          }
           if (typeof r.score === "number") {
             lines.push(`   Score: ${r.score.toFixed(3)}`);
           }

package/src/__tests__/worker-entrypoint-guards.test.ts

@@ -23,6 +23,12 @@ import { Glob } from "bun";
 const DISABLE_CALL = "disableStreamSeqStamping()";
 const PID_GUARD_CALL = "startWorkerPidFileGuard(";
 
+/** Shape of a shutdown that schedules `process.exit` instead of calling it. */
+const DEFERRED_EXIT = ".finally(() => process.exit";
+
+/** A synchronously-set shutdown flag re-checked before work starts. */
+const BAILOUT = /if\s*\(\s*shuttingDown\s*\)\s*\{\s*return;/;
+
 /**
  * The first call each entrypoint makes that can run orphaned schedule/job
  * work. The PID guard must be armed before this — its on-arm identity check
@@ -80,6 +86,39 @@ describe("worker entrypoint guards", () => {
     ).toEqual([]);
   });
 
+  /**
+   * Arming the guard before work-start is only sufficient while the eviction
+   * path exits synchronously. An entrypoint that defers its exit (to reap child
+   * processes first) hands control back to startup, which then runs its
+   * work-start call anyway: for the memory worker that means
+   * `resetRunningJobsToPending()` flipping the LIVE successor's in-progress
+   * jobs back to pending. Such an entrypoint must re-check and bail.
+   */
+  test("an entrypoint that defers its exit bails out before starting work", () => {
+    const offenders = findWorkerEntrypoints().filter((file) => {
+      const source = readFileSync(join(process.cwd(), "src", file), "utf8");
+      if (!source.includes(DEFERRED_EXIT)) {
+        return false;
+      }
+      const marker = WORK_START_MARKERS[file];
+      if (marker == null) {
+        return true;
+      }
+      const guardAt = source.indexOf(PID_GUARD_CALL);
+      const workAt = source.indexOf(marker);
+      if (guardAt < 0 || workAt < 0) {
+        return true;
+      }
+      return !BAILOUT.test(source.slice(guardAt, workAt));
+    });
+    expect(
+      offenders,
+      "A worker whose shutdown defers process.exit must re-check a " +
+        "synchronously-set shutdown flag and return before its work-start " +
+        "call, so an evicted worker cannot run work against live data.",
+    ).toEqual([]);
+  });
+
   test("every worker entrypoint arms the PID guard before starting work", () => {
     const offenders = findWorkerEntrypoints().filter((file) => {
       const marker = WORK_START_MARKERS[file];

package/src/__tests__/workspace-greetings.test.ts

@@ -13,7 +13,9 @@ mock.module("node:fs", () => ({
   },
   readFileSync: (path: string, _encoding: string) => {
     const name = path.split("/").pop() ?? "";
-    if (name in workspaceFiles) return workspaceFiles[name];
+    if (name in workspaceFiles) {
+      return workspaceFiles[name];
+    }
     throw new Error(`ENOENT: ${path}`);
   },
 }));

package/src/__tests__/workspace-migration-026-backfill-install-meta.test.ts

@@ -85,7 +85,9 @@ function writeIntegrityManifest(
 
 function readInstallMeta(skillName: string): Record<string, unknown> | null {
   const path = join(skillsDir, skillName, "install-meta.json");
-  if (!existsSync(path)) return null;
+  if (!existsSync(path)) {
+    return null;
+  }
   return JSON.parse(readFileSync(path, "utf-8"));
 }
 

package/src/__tests__/workspace-migration-043-release-notes-latex-rendering.test.ts

@@ -108,7 +108,9 @@ describe("workspace migration 043-release-notes-latex-rendering", () => {
       `${priorContent}\n${content.slice(priorContent.length + 1)}`,
     );
     // The appended block starts at the marker.
-    expect(content.slice(priorContent.length)).toMatch(/^\n<!-- release-note-id:/);
+    expect(content.slice(priorContent.length)).toMatch(
+      /^\n<!-- release-note-id:/,
+    );
     // No triple-newline (would indicate a stray blank line).
     expect(content).not.toContain("\n\n\n");
   });