@vellumai/assistant 0.11.0 → 0.11.1-staging.2

package/src/daemon/host-transfer-proxy.ts

@@ -52,7 +52,9 @@ interface TransferEntry {
  * This gives 120s minimum, plus ~1s per MB + 30s buffer for larger files.
  */
 function computeTimeoutMs(sizeBytes?: number): number {
-  if (sizeBytes == null) return 120_000;
+  if (sizeBytes == null) {
+    return 120_000;
+  }
   const sizeBased = (sizeBytes / (1024 * 1024)) * 1000 + 30_000;
   return Math.max(120_000, sizeBased);
 }
@@ -181,7 +183,9 @@ export class HostTransferProxy {
         targetClientId: resolvedTargetClientId,
         op: "host_transfer",
       });
-      if (rejection != null) return Promise.resolve(rejection);
+      if (rejection != null) {
+        return Promise.resolve(rejection);
+      }
     }
 
     const requestId = uuid();
@@ -383,7 +387,9 @@ export class HostTransferProxy {
         targetClientId: resolvedTargetClientId,
         op: "host_transfer",
       });
-      if (rejection != null) return Promise.resolve(rejection);
+      if (rejection != null) {
+        return Promise.resolve(rejection);
+      }
     }
 
     const requestId = uuid();
@@ -514,7 +520,9 @@ export class HostTransferProxy {
       return;
     }
     const transferId = interaction.metadata?.transferId as string | undefined;
-    if (transferId) this.transfers.delete(transferId);
+    if (transferId) {
+      this.transfers.delete(transferId);
+    }
 
     if (result.isError) {
       interaction.rpcResolve({
@@ -582,7 +590,9 @@ export class HostTransferProxy {
     transferId: string,
   ): { sizeBytes: number; sha256: string } | null {
     const meta = this.justConsumedMetadata.get(transferId);
-    if (!meta) return null;
+    if (!meta) {
+      return null;
+    }
     this.justConsumedMetadata.delete(transferId);
     return meta;
   }
@@ -659,9 +669,13 @@ export class HostTransferProxy {
   /** Cancel a pending transfer by requestId. */
   cancel(requestId: string): void {
     const interaction = pendingInteractions.get(requestId);
-    if (!interaction) return;
+    if (!interaction) {
+      return;
+    }
     const transferId = interaction.metadata?.transferId as string | undefined;
-    if (transferId) this.transfers.delete(transferId);
+    if (transferId) {
+      this.transfers.delete(transferId);
+    }
     pendingInteractions.resolve(requestId, "cancelled");
     const { conversationId } = interaction;
     try {
@@ -720,7 +734,9 @@ export class HostTransferProxy {
   dispose(): void {
     for (const entry of pendingInteractions.getByKind("host_transfer")) {
       const transferId = entry.metadata?.transferId as string | undefined;
-      if (transferId) this.transfers.delete(transferId);
+      if (transferId) {
+        this.transfers.delete(transferId);
+      }
       pendingInteractions.resolve(entry.requestId, "cancelled");
       const { conversationId } = entry;
       try {

package/src/daemon/identity-helpers.ts

@@ -7,7 +7,9 @@ import { getWorkspacePromptPath } from "../util/platform.js";
 export function getAssistantName(): string | null {
   try {
     const path = getWorkspacePromptPath("IDENTITY.md");
-    if (!existsSync(path)) return null;
+    if (!existsSync(path)) {
+      return null;
+    }
     const content = readFileSync(path, "utf-8");
     const match = content.match(/\*\*Name:\*\*\s*(.+)/);
     return match?.[1]?.trim() || null;

package/src/daemon/install-symlink.ts

@@ -73,11 +73,15 @@ function trySymlink(target: string, symlinkPath: string): boolean {
         return false;
       }
       const dest = readlinkSync(symlinkPath);
-      if (dest === target) return true;
+      if (dest === target) {
+        return true;
+      }
       // Stale or dangling symlink — remove before creating new one
       unlinkSync(symlinkPath);
     } catch (e) {
-      if ((e as NodeJS.ErrnoException)?.code !== "ENOENT") return false;
+      if ((e as NodeJS.ErrnoException)?.code !== "ENOENT") {
+        return false;
+      }
       // Path doesn't exist — proceed to create symlink
     }
 
@@ -104,13 +108,17 @@ function ensureLocalBinInShellProfile(localBinDir: string): void {
     : shell.endsWith("/bash")
       ? join(home, ".bash_profile")
       : null;
-  if (!profilePath) return;
+  if (!profilePath) {
+    return;
+  }
 
   try {
     const contents = existsSync(profilePath)
       ? readFileSync(profilePath, "utf-8")
       : "";
-    if (contents.includes(localBinDir)) return;
+    if (contents.includes(localBinDir)) {
+      return;
+    }
     const line = `\nexport PATH="${localBinDir}:$PATH"\n`;
     appendFileSync(profilePath, line);
     log.info(
@@ -158,10 +166,14 @@ function commandResolvesElsewhere(
  * Skipped when VELLUM_DEV=1 (developers manage their own PATH).
  */
 export function installAssistantSymlink(): void {
-  if (process.env.VELLUM_DEV === "1") return;
+  if (process.env.VELLUM_DEV === "1") {
+    return;
+  }
 
   const target = resolveAssistantBinary();
-  if (!target) return;
+  if (!target) {
+    return;
+  }
 
   const localBinDir = join(homedir(), ".local", "bin");
   const candidateDirs = ["/usr/local/bin", localBinDir];

package/src/daemon/interrupted-turn-reconciler.ts

@@ -16,17 +16,17 @@
  * still-set flags here at boot; the monitor clears them a few seconds later.
  *
  * Each resume runs under the conversation's reconstructed resting trust (see
- * {@link recoverRestingTrustContext}); conversations whose trust can't be
- * rebuilt from persisted state are cleared but left un-resumed.
+ * `recoverRestingTrustContext` in `conversation-resting-trust.ts`);
+ * conversations whose trust can't be rebuilt from persisted state are cleared
+ * but left un-resumed.
  */
 
 import {
-  getConversationOriginChannel,
   incrementProcessingResumeAttempts,
   listInterruptedConversations,
 } from "../persistence/conversation-crud.js";
 import { getLogger } from "../util/logger.js";
-import { INTERNAL_GUARDIAN_TRUST_CONTEXT } from "./trust-context.js";
+import { recoverRestingTrustContext } from "./conversation-resting-trust.js";
 import type { TrustContext } from "./trust-context-types.js";
 
 const log = getLogger("interrupted-turns");
@@ -69,39 +69,13 @@ export interface InterruptedTurnReconciliation {
   capped: string[];
   /**
    * Conversation ids left un-resumed because their resting trust could not be
-   * reconstructed from persisted state (a remote-channel turn whose per-actor
-   * gateway verdict is not stored). Their stale flag is still cleared.
+   * reconstructed from persisted state: a remote-channel turn whose per-actor
+   * gateway verdict is not stored, or an origin the build does not recognize.
+   * Their stale flag is still cleared.
    */
   trustUnrecoverable: string[];
 }
 
-/**
- * Rebuild the trust context an interrupted conversation must resume under, or
- * `null` when it can't be recovered.
- *
- * Only the guardian's own local conversations are recoverable at rest: a
- * remote-channel turn's trust class is stamped per inbound message from the
- * gateway verdict and never persisted, so it cannot be reconstructed here.
- * Local conversations — `originChannel` unset (a desktop/web/CLI turn that
- * never carried a channel message) or the internal `vellum` channel — belong
- * to the guardian owner, so they resume under
- * {@link INTERNAL_GUARDIAN_TRUST_CONTEXT}: the trust class `loadFromDb` needs
- * to rehydrate their guardian-provenance history instead of filtering it to
- * empty. Any other origin returns `null` so the caller skips the resume rather
- * than run the turn under a fabricated context — which would either grant a
- * low-trust turn guardian capability or bury the reply under `unknown`
- * provenance.
- */
-function recoverRestingTrustContext(
-  conversationId: string,
-): TrustContext | null {
-  const originChannel = getConversationOriginChannel(conversationId);
-  if (originChannel === null || originChannel === "vellum") {
-    return INTERNAL_GUARDIAN_TRUST_CONTEXT;
-  }
-  return null;
-}
-
 /**
  * When `resumeEnabled` is set, pick the conversations to resume together with
  * the resting trust each wake runs under. Conversations whose resting trust

package/src/daemon/lifecycle.ts

@@ -61,6 +61,7 @@ import {
 import { APP_VERSION } from "../version.js";
 import { getWorkflowRunManager } from "../workflows/run-manager.js";
 import { repairAdaptiveThinkingOnManagedProfiles } from "../workspace/adaptive-thinking-repair.js";
+import { ensureByokDefaultProfiles } from "../workspace/byok-default-profile-ensure.js";
 import { ensureCompleteCustomProfiles } from "../workspace/custom-profile-ensure.js";
 import { ensureDefaultProvider } from "../workspace/default-provider-ensure.js";
 import { startWorkspaceHeartbeatService } from "../workspace/heartbeat-service.js";
@@ -474,13 +475,11 @@ export async function runDaemon(): Promise<void> {
   // seeder and persisted alongside schema defaults.
   const defaultConfigMerge = mergeDefaultWorkspaceConfig();
 
-  // Seed inference profiles into the workspace config. Managed Anthropic
-  // profiles are overwritten on every boot so Vellum can push updates.
-  // Off-platform hatches additionally create user profiles + a personal
-  // provider connection for the hatch provider.
+  // Seed inference profiles into the workspace config: active/advisor
+  // resolution plus, on off-platform hatches, `llm.defaultProvider` and a
+  // personal provider connection for the hatch provider.
   try {
     seedInferenceProfiles({
-      preserveProfileNames: defaultConfigMerge.providedLlmProfileNames,
       preserveActiveProfile: defaultConfigMerge.providedLlmActiveProfile,
       isHatch: defaultConfigMerge.hadOverlay,
       db: dbReady ? getDb() : undefined,
@@ -524,6 +523,22 @@ export async function runDaemon(): Promise<void> {
     );
   }
 
+  // Runs on every boot, after the default-provider ensure (it keys off
+  // llm.defaultProvider) and before custom-profile materialization (so
+  // copies it retires this boot are never pointlessly materialized first;
+  // its comparison normalizes both sides through the same completion, so
+  // ordering is not correctness-bearing).
+  // See workspace/byok-default-profile-ensure.ts for the full rationale.
+  try {
+    ensureByokDefaultProfiles(getWorkspaceDir());
+    log.info("BYOK default profile ensure pass complete");
+  } catch (err) {
+    log.warn(
+      { err },
+      "BYOK default profile ensure pass failed; continuing startup",
+    );
+  }
+
   // Runs on every boot, after the overlay merge and profile seeding and
   // before the first loadConfig(), so no resolution ever sees a partial
   // custom profile. See workspace/custom-profile-ensure.ts for why this is

package/src/daemon/message-types/web-activity.ts

@@ -10,6 +10,7 @@ export type WebSearchProviderId =
   | "brave"
   | "perplexity"
   | "tavily"
+  | "keenable"
   | "firecrawl";
 
 /** Provider that backed a `web_fetch` call. `default` is the built-in fetcher. */

package/src/daemon/now-scratchpad.ts

@@ -11,7 +11,9 @@ import { stripCommentLines } from "../util/strip-comment-lines.js";
  */
 export function readNowScratchpad(): string | null {
   const nowPath = getWorkspacePromptPath("NOW.md");
-  if (!existsSync(nowPath)) return null;
+  if (!existsSync(nowPath)) {
+    return null;
+  }
   try {
     const stripped = stripCommentLines(readFileSync(nowPath, "utf-8")).trim();
     return stripped.length > 0 ? stripped : null;

package/src/daemon/orphan-reaper.test.ts

@@ -116,7 +116,9 @@ function zombieChildPids(): number[] {
   const out: number[] = [];
   for (const entry of readdirSync("/proc")) {
     const pid = Number(entry);
-    if (!Number.isInteger(pid) || pid <= 1) continue;
+    if (!Number.isInteger(pid) || pid <= 1) {
+      continue;
+    }
     let stat: string;
     try {
       stat = readFileSync(`/proc/${pid}/stat`, "utf8");
@@ -124,7 +126,9 @@ function zombieChildPids(): number[] {
       continue;
     }
     const parsed = parseProcStat(stat);
-    if (parsed && parsed.state === "Z" && parsed.ppid === self) out.push(pid);
+    if (parsed && parsed.state === "Z" && parsed.ppid === self) {
+      out.push(pid);
+    }
   }
   return out;
 }
@@ -132,16 +136,21 @@ function zombieChildPids(): number[] {
 const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
 
 afterAll(() => {
-  if (!lib) return;
+  if (!lib) {
+    return;
+  }
   // Reap anything still lingering so the test process leaves no zombies.
-  for (const pid of zombieChildPids())
+  for (const pid of zombieChildPids()) {
     lib.symbols.waitpid(pid, ptr(statusBuf), WNOHANG);
+  }
 });
 
 itLinux(
   "defers then reaps a reparented orphan while libuv reaps the tracked child",
   async () => {
-    if (!lib) return;
+    if (!lib) {
+      return;
+    }
     // GIVEN this process is a child subreaper, so orphaned grandchildren
     // reparent here exactly as they reparent to a PID-1 daemon
     expect(lib.symbols.prctl(PR_SET_CHILD_SUBREAPER, 1n, 0n, 0n, 0n)).toBe(0);
@@ -176,7 +185,9 @@ itLinux(
     const scan2 = selectReapable(zombieChildPids(), scan1.nextSeen);
     let reaped = 0;
     for (const pid of scan2.reap) {
-      if (lib.symbols.waitpid(pid, ptr(statusBuf), WNOHANG) > 0) reaped++;
+      if (lib.symbols.waitpid(pid, ptr(statusBuf), WNOHANG) > 0) {
+        reaped++;
+      }
     }
     await sleep(50);
 

package/src/daemon/orphan-reaper.ts

@@ -67,7 +67,9 @@ let waitStatusPtr: unknown = null;
  * is unavailable so daemon startup never fails on this subsystem.
  */
 function initWaitpid(): boolean {
-  if (waitpid) return true;
+  if (waitpid) {
+    return true;
+  }
   try {
     const lib = dlopen("libc.so.6", {
       waitpid: {
@@ -105,12 +107,16 @@ export function parseProcStat(
 ): { comm: string; state: string; ppid: number } | null {
   const lparen = content.indexOf("(");
   const rparen = content.lastIndexOf(")");
-  if (lparen === -1 || rparen === -1 || rparen < lparen) return null;
+  if (lparen === -1 || rparen === -1 || rparen < lparen) {
+    return null;
+  }
   const comm = content.slice(lparen + 1, rparen);
   const rest = content.slice(rparen + 2).split(" ");
   const state = rest[0];
   const ppid = Number(rest[1]);
-  if (!state || !Number.isInteger(ppid)) return null;
+  if (!state || !Number.isInteger(ppid)) {
+    return null;
+  }
   return { comm, state, ppid };
 }
 
@@ -145,7 +151,9 @@ function findZombieChildren(): ZombieChild[] {
   }
   for (const entry of entries) {
     const pid = Number(entry);
-    if (!Number.isInteger(pid) || pid <= 1) continue;
+    if (!Number.isInteger(pid) || pid <= 1) {
+      continue;
+    }
     let stat: string;
     try {
       stat = readFileSync(`/proc/${pid}/stat`, "utf8");
@@ -166,7 +174,9 @@ function findZombieChildren(): ZombieChild[] {
  * leaving newly-defunct children for libuv to reap first.
  */
 function reapScan(): void {
-  if (!waitpid) return;
+  if (!waitpid) {
+    return;
+  }
   const zombies = findZombieChildren();
   const byPid = new Map(zombies.map((z) => [z.pid, z]));
   const { reap, nextSeen } = selectReapable([...byPid.keys()], seenLastScan);
@@ -174,7 +184,9 @@ function reapScan(): void {
   for (const pid of reap) {
     const rc = waitpid(pid, waitStatusPtr, WNOHANG);
     // rc > 0: reaped. rc <= 0 (0 = not yet, -1 = ECHILD/raced): leave it.
-    if (rc > 0) reaped.push(byPid.get(pid)!);
+    if (rc > 0) {
+      reaped.push(byPid.get(pid)!);
+    }
   }
   seenLastScan = nextSeen;
   if (reaped.length > 0) {
@@ -194,7 +206,9 @@ function reapScan(): void {
  * (otherwise reparented orphans are reaped by the real init).
  */
 export function startOrphanReaper(): void {
-  if (scanTimer) return;
+  if (scanTimer) {
+    return;
+  }
   if (process.platform !== "linux" || process.pid !== 1) {
     log.info(
       { platform: process.platform, pid: process.pid },
@@ -202,7 +216,9 @@ export function startOrphanReaper(): void {
     );
     return;
   }
-  if (!initWaitpid()) return;
+  if (!initWaitpid()) {
+    return;
+  }
   seenLastScan = new Set();
   scanTimer = setInterval(reapScan, SCAN_INTERVAL_MS);
   scanTimer.unref?.();

package/src/daemon/parse-actual-tokens-from-error.ts

@@ -23,7 +23,9 @@ export function parseActualTokensFromError(
   // ContextOverflowError. Use the parsed field directly when available.
   if (isContextOverflowError(errorOrMessage)) {
     const actual = errorOrMessage.actualTokens;
-    if (typeof actual === "number" && actual > 0) return actual;
+    if (typeof actual === "number" && actual > 0) {
+      return actual;
+    }
     // Typed error without `actualTokens` — fall through to regex-parse the
     // underlying message in case the upstream body carries it in text form.
     return parseFromMessage(errorOrMessage.message ?? null);
@@ -63,25 +65,37 @@ const OVERFLOW_MESSAGE_PATTERNS: readonly RegExp[] = [
  * error, a plain `Error`/object with a `message`, or a raw string.
  */
 export function looksLikeContextOverflowError(err: unknown): boolean {
-  if (isContextOverflowError(err)) return true;
+  if (isContextOverflowError(err)) {
+    return true;
+  }
   const message = extractMessage(err);
-  if (message === null) return false;
+  if (message === null) {
+    return false;
+  }
   return OVERFLOW_MESSAGE_PATTERNS.some((pattern) => pattern.test(message));
 }
 
 /** Pull a message string out of an untyped error-ish value, if possible. */
 function extractMessage(errorOrMessage: unknown): string | null {
-  if (errorOrMessage == null) return null;
-  if (typeof errorOrMessage === "string") return errorOrMessage;
+  if (errorOrMessage == null) {
+    return null;
+  }
+  if (typeof errorOrMessage === "string") {
+    return errorOrMessage;
+  }
   if (typeof errorOrMessage === "object" && "message" in errorOrMessage) {
     const msg = (errorOrMessage as { message?: unknown }).message;
-    if (typeof msg === "string") return msg;
+    if (typeof msg === "string") {
+      return msg;
+    }
   }
   return null;
 }
 
 function parseFromMessage(errorMessage: string | null): number | null {
-  if (!errorMessage) return null;
+  if (!errorMessage) {
+    return null;
+  }
 
   // Match patterns like "242201 tokens > 200000" or "242201 > 200000 maximum"
   const match = errorMessage.match(
@@ -90,7 +104,9 @@ function parseFromMessage(errorMessage: string | null): number | null {
   if (match) {
     const raw = (match[1] || match[2]).replace(/,/g, "");
     const parsed = parseInt(raw, 10);
-    if (!isNaN(parsed) && parsed > 0) return parsed;
+    if (!isNaN(parsed) && parsed > 0) {
+      return parsed;
+    }
   }
 
   // Fallback: match "too many input tokens: N > M"
@@ -98,7 +114,9 @@ function parseFromMessage(errorMessage: string | null): number | null {
   if (fallback) {
     const raw = fallback[1].replace(/,/g, "");
     const parsed = parseInt(raw, 10);
-    if (!isNaN(parsed) && parsed > 0) return parsed;
+    if (!isNaN(parsed) && parsed > 0) {
+      return parsed;
+    }
   }
 
   return null;

package/src/daemon/persist-media-references.ts

@@ -63,7 +63,9 @@ function referenceMediaBlock(
   block: ImageContent | FileContent,
   position: number,
 ): ContentBlock | null {
-  if (block.source.type !== "base64") return block;
+  if (block.source.type !== "base64") {
+    return block;
+  }
   const { data, media_type } = block.source;
   const filename =
     block.source.filename ??
@@ -131,7 +133,9 @@ export function referenceMediaBlocksForPersist(
   let position = 0;
   const convert = (block: ContentBlock): ContentBlock => {
     if (block.type === "image" || block.type === "file") {
-      if (block.source.type !== "base64") return block;
+      if (block.source.type !== "base64") {
+        return block;
+      }
       return (
         referenceMediaBlock(
           conversationId,

package/src/daemon/pkb-context-tracker.test.ts

@@ -51,7 +51,12 @@ describe("getInContextPkbPaths", () => {
     const conversation = makeConversation([
       assistantMessageWithBlocks([fileReadToolUse(insidePath)]),
     ]);
-    const result = getInContextPkbPaths(conversation, [], PKB_ROOT, WORKING_DIR);
+    const result = getInContextPkbPaths(
+      conversation,
+      [],
+      PKB_ROOT,
+      WORKING_DIR,
+    );
     expect(result).toEqual(new Set([insidePath]));
   });
 
@@ -59,7 +64,12 @@ describe("getInContextPkbPaths", () => {
     const conversation = makeConversation([
       assistantMessageWithBlocks([fileReadToolUse("/etc/hosts")]),
     ]);
-    const result = getInContextPkbPaths(conversation, [], PKB_ROOT, WORKING_DIR);
+    const result = getInContextPkbPaths(
+      conversation,
+      [],
+      PKB_ROOT,
+      WORKING_DIR,
+    );
     expect(result).toEqual(new Set());
   });
 
@@ -74,7 +84,12 @@ describe("getInContextPkbPaths", () => {
     const conversation = makeConversation([
       assistantMessageWithBlocks([bogus]),
     ]);
-    const result = getInContextPkbPaths(conversation, [], PKB_ROOT, WORKING_DIR);
+    const result = getInContextPkbPaths(
+      conversation,
+      [],
+      PKB_ROOT,
+      WORKING_DIR,
+    );
     expect(result).toEqual(new Set());
   });
 
@@ -111,7 +126,12 @@ describe("getInContextPkbPaths", () => {
         fileReadToolUse("notes/../../../etc/shadow"),
       ]),
     ]);
-    const result = getInContextPkbPaths(conversation, [], PKB_ROOT, WORKING_DIR);
+    const result = getInContextPkbPaths(
+      conversation,
+      [],
+      PKB_ROOT,
+      WORKING_DIR,
+    );
     expect(result).toEqual(new Set());
   });
 
@@ -124,7 +144,12 @@ describe("getInContextPkbPaths", () => {
         fileReadToolUse("./deep/subdir/file.md"),
       ]),
     ]);
-    const result = getInContextPkbPaths(conversation, [], PKB_ROOT, WORKING_DIR);
+    const result = getInContextPkbPaths(
+      conversation,
+      [],
+      PKB_ROOT,
+      WORKING_DIR,
+    );
     expect(result).toEqual(new Set());
   });
 
@@ -135,7 +160,12 @@ describe("getInContextPkbPaths", () => {
     const conversation = makeConversation([
       assistantMessageWithBlocks([fileReadToolUse("pkb/threads.md")]),
     ]);
-    const result = getInContextPkbPaths(conversation, [], PKB_ROOT, WORKING_DIR);
+    const result = getInContextPkbPaths(
+      conversation,
+      [],
+      PKB_ROOT,
+      WORKING_DIR,
+    );
     expect(result).toEqual(new Set([path.join(PKB_ROOT, "threads.md")]));
   });
 
@@ -147,9 +177,7 @@ describe("getInContextPkbPaths", () => {
       PKB_ROOT,
       WORKING_DIR,
     );
-    expect(result).toEqual(
-      new Set([path.join(PKB_ROOT, "notes/relative.md")]),
-    );
+    expect(result).toEqual(new Set([path.join(PKB_ROOT, "notes/relative.md")]));
   });
 
   test("auto-inject and file_read paths union (no duplicates)", () => {

package/src/daemon/pkb-context-tracker.ts

@@ -100,12 +100,20 @@ export function getInContextPkbPaths(
   }
 
   for (const message of conversation.messages) {
-    if (!Array.isArray(message.content)) continue;
+    if (!Array.isArray(message.content)) {
+      continue;
+    }
     for (const block of message.content as ContentBlock[]) {
-      if (block.type !== "tool_use") continue;
-      if (block.name !== FILE_READ_TOOL_NAME) continue;
+      if (block.type !== "tool_use") {
+        continue;
+      }
+      if (block.name !== FILE_READ_TOOL_NAME) {
+        continue;
+      }
       const rawPath = block.input?.path;
-      if (typeof rawPath !== "string" || rawPath.length === 0) continue;
+      if (typeof rawPath !== "string" || rawPath.length === 0) {
+        continue;
+      }
       // Mirror `file_read`'s own path resolution: absolute paths are taken
       // as-is; relative paths resolve against the tool's working directory
       // (NOT `pkbRoot`). Resolving relative paths against `pkbRoot` would

package/src/daemon/pointer-conversation-trust.ts

@@ -62,7 +62,9 @@ export async function elevatePointerConversationToGuardian(
     isOwnerContext &&
     !resolveCapabilities(priorTrustClass).canAccessMemory &&
     !conversation.isProcessing();
-  if (!shouldElevate) return () => {};
+  if (!shouldElevate) {
+    return () => {};
+  }
 
   conversation.setTrustContext(INTERNAL_GUARDIAN_TRUST_CONTEXT);
   await conversation.ensureActorScopedHistory();

package/src/daemon/process-message.ts

@@ -154,7 +154,9 @@ export function deriveIngressIdempotencyKey(options?: {
 function buildEventEmitter(
   observer?: (msg: AssistantEvent) => void,
 ): (msg: AssistantEvent) => void {
-  if (!observer) {return broadcastMessage;}
+  if (!observer) {
+    return broadcastMessage;
+  }
   return (msg) => {
     broadcastMessage(msg);
     try {