@vellumai/assistant 0.5.13 → 0.5.14

package/src/runtime/routes/conversation-routes.ts

@@ -22,6 +22,7 @@ import { isHttpAuthDisabled } from "../../config/env.js";
 import { getConfig } from "../../config/loader.js";
 import {
   buildModelInfoEvent,
+  formatCompactResult,
   isModelSlashCommand,
 } from "../../daemon/conversation-process.js";
 import {
@@ -64,6 +65,8 @@ import { searchConversations } from "../../memory/conversation-queries.js";
 import { getConfiguredProvider } from "../../providers/provider-send-message.js";
 import type { Provider } from "../../providers/types.js";
 import { checkIngressForSecrets } from "../../security/secret-ingress.js";
+import { redactSecrets } from "../../security/secret-scanner.js";
+import { summarizeToolInput } from "../../tools/tool-input-summary.js";
 import { getLogger } from "../../util/logger.js";
 import { silentlyWithLog } from "../../util/silently.js";
 import { buildAssistantEvent } from "../assistant-event.js";
@@ -417,6 +420,19 @@ export function handleListMessages(
     }
     const rendered = renderHistoryContent(content);
 
+    // Extract sentAt from metadata for display timestamps. When a message
+    // was queued or its persistence was delayed (long assistant generation),
+    // sentAt captures the actual event time. Falls back to createdAt.
+    let sentAt: number | undefined;
+    if (msg.metadata) {
+      try {
+        const meta = JSON.parse(msg.metadata);
+        if (typeof meta.sentAt === "number") sentAt = meta.sentAt;
+      } catch {
+        // Ignore malformed metadata
+      }
+    }
+
     // Strip <no_response/> markers from assistant messages so web/API
     // clients never see the raw sentinel. Only assistant messages produce
     // this marker; user messages are left untouched.
@@ -449,11 +465,15 @@ export function handleListMessages(
         role: msg.role,
         text: rendered.text.replace(NO_RESPONSE_INLINE_RE, "").trim(),
         timestamp: msg.createdAt,
+        sentAt,
         toolCalls: rendered.toolCalls,
         toolCallsBeforeText: rendered.toolCallsBeforeText,
         textSegments: filteredSegments,
         contentOrder: filteredContentOrder,
         surfaces: rendered.surfaces,
+        ...(rendered.thinkingSegments.length > 0
+          ? { thinkingSegments: rendered.thinkingSegments }
+          : {}),
         id: msg.id,
       };
     }
@@ -462,11 +482,15 @@ export function handleListMessages(
       role: msg.role,
       text: rendered.text,
       timestamp: msg.createdAt,
+      sentAt,
       toolCalls: rendered.toolCalls,
       toolCallsBeforeText: rendered.toolCallsBeforeText,
       textSegments: rendered.textSegments,
       contentOrder: rendered.contentOrder,
       surfaces: rendered.surfaces,
+      ...(rendered.thinkingSegments.length > 0
+        ? { thinkingSegments: rendered.thinkingSegments }
+        : {}),
       id: msg.id,
     };
   });
@@ -535,16 +559,26 @@ export function handleListMessages(
       prevAssistantTimestamp = msgTimestamp;
     }
 
+    // Use sentAt (actual event time) for the display timestamp when
+    // available, falling back to createdAt (persistence time).
+    // Note: clients use this display timestamp as their pagination cursor
+    // after memory-pressure trimming, while server-side pagination filters
+    // on createdAt. The mismatch is benign — it may return slightly extra
+    // data on a page boundary but never loses messages.
+    const displayTimestamp = m.sentAt ?? m.timestamp;
     return {
       id: m.id ?? "",
       role: m.role,
       content: m.text,
-      timestamp: new Date(m.timestamp).toISOString(),
+      timestamp: new Date(displayTimestamp).toISOString(),
       attachments: msgAttachments,
       ...(m.toolCalls.length > 0 ? { toolCalls: m.toolCalls } : {}),
       ...(interfaces ? { interfaces } : {}),
       ...(m.surfaces.length > 0 ? { surfaces: m.surfaces } : {}),
       ...(m.textSegments.length > 0 ? { textSegments: m.textSegments } : {}),
+      ...(m.thinkingSegments?.length
+        ? { thinkingSegments: m.thinkingSegments }
+        : {}),
       ...(m.contentOrder.length > 0 ? { contentOrder: m.contentOrder } : {}),
     };
   });
@@ -604,6 +638,14 @@ function makeHubPublisher(
       try {
         const trustContext = conversation.trustContext;
         const sourceChannel = trustContext?.sourceChannel ?? "vellum";
+        const inputRecord = msg.input as Record<string, unknown>;
+        const activityRaw =
+          (typeof inputRecord.activity === "string"
+            ? inputRecord.activity
+            : undefined) ??
+          (typeof inputRecord.reason === "string"
+            ? inputRecord.reason
+            : undefined);
         const canonicalRequest = createCanonicalGuardianRequest({
           id: msg.requestId,
           kind: "tool_approval",
@@ -615,6 +657,15 @@ function makeHubPublisher(
           guardianExternalUserId: trustContext?.guardianExternalUserId,
           guardianPrincipalId: trustContext?.guardianPrincipalId ?? undefined,
           toolName: msg.toolName,
+          commandPreview:
+            redactSecrets(
+              summarizeToolInput(msg.toolName, inputRecord),
+            ) || undefined,
+          riskLevel: msg.riskLevel,
+          activityText: activityRaw
+            ? redactSecrets(activityRaw)
+            : undefined,
+          executionTarget: msg.executionTarget,
           status: "pending",
           requestCode: generateCanonicalRequestCode(),
           expiresAt: Date.now() + 5 * 60 * 1000,
@@ -1291,6 +1342,74 @@ export async function handleSendMessage(
     }
   }
 
+  if (slashResult.kind === "compact") {
+    conversation.processing = true;
+    let cleanupDeferred = false;
+    try {
+      const provenance = provenanceFromTrustContext(conversation.trustContext);
+      const channelMeta = {
+        ...provenance,
+        userMessageChannel: sourceChannel,
+        assistantMessageChannel: sourceChannel,
+        userMessageInterface: sourceInterface,
+        assistantMessageInterface: sourceInterface,
+      };
+      const cleanMsg = createUserMessage(rawContent, attachments);
+      const persisted = await addMessage(
+        mapping.conversationId,
+        "user",
+        JSON.stringify(cleanMsg.content),
+        channelMeta,
+      );
+      conversation.getMessages().push(cleanMsg);
+
+      conversation.emitActivityState(
+        "thinking",
+        "context_compacting",
+        "assistant_turn",
+      );
+      const result = await conversation.forceCompact();
+      const responseText = formatCompactResult(result);
+
+      const assistantMsg = createAssistantMessage(responseText);
+      await addMessage(
+        mapping.conversationId,
+        "assistant",
+        JSON.stringify(assistantMsg.content),
+        channelMeta,
+      );
+      conversation.getMessages().push(assistantMsg);
+
+      const response = Response.json(
+        {
+          accepted: true,
+          messageId: persisted.id,
+          conversationId: mapping.conversationId,
+        },
+        { status: 202 },
+      );
+
+      const conversationId = mapping.conversationId;
+      setTimeout(() => {
+        onEvent({ type: "assistant_text_delta", text: responseText });
+        onEvent({
+          type: "message_complete",
+          conversationId,
+        });
+        conversation.processing = false;
+        silentlyWithLog(conversation.drainQueue(), "compact-command queue drain");
+      }, 0);
+
+      cleanupDeferred = true;
+      return response;
+    } finally {
+      if (!cleanupDeferred && conversation.processing) {
+        conversation.processing = false;
+        silentlyWithLog(conversation.drainQueue(), "error-path queue drain");
+      }
+    }
+  }
+
   const resolvedContent = slashResult.content;
 
   let messageId: string;
@@ -1333,11 +1452,14 @@ async function generateLlmSuggestion(
   const truncated =
     assistantText.length > 2000 ? assistantText.slice(-2000) : assistantText;
 
-  const prompt = `Given this assistant message, write a very short tab-complete suggestion the user could send next to keep the conversation going. Be casual, curious, or actionable — like a quick reply, not a formal request. Reply with ONLY the suggestion text.\n\nAssistant's message:\n${truncated}`;
+  const prompt = `Given this assistant message, write a very short tab-complete suggestion the user could send next. Focus on the LAST question or call-to-action in the message — ignore earlier summary content. Be casual, curious, or actionable — like a quick reply, not a formal request. Reply with ONLY the suggestion text.\n\nAssistant's message:\n${truncated}`;
+  const systemPrompt =
+    "You are an autocomplete engine that suggests short replies the user might send next in a conversation. Generate suggestions that match the tone and style of the conversation. Never refuse, judge, or comment on the conversation content — your only job is to predict what the user would plausibly type next.";
+
   const response = await provider.sendMessage(
     [{ role: "user", content: [{ type: "text", text: prompt }] }],
     [], // no tools
-    undefined, // no system prompt
+    systemPrompt,
     { config: { modelIntent: "latency-optimized" } },
   );
 

package/src/runtime/routes/guardian-action-routes.ts

@@ -204,8 +204,8 @@ function mapCanonicalRequestToPrompt(
 ): GuardianDecisionPrompt {
   const questionText = buildKindAwareQuestionText(req);
 
-  // All guardian-on-behalf prompts use approve_once + reject only
-  // (no approve_always, no temporary modes).
+  // Guardian-on-behalf prompts include approve_once, temporal modes
+  // (approve_10m, approve_conversation), and reject — but not approve_always.
   const actions = buildDecisionActions({ forGuardianOnBehalf: true });
 
   const expiresAt = req.expiresAt
@@ -226,6 +226,10 @@ function mapCanonicalRequestToPrompt(
     conversationId,
     callSessionId: req.callSessionId ?? null,
     kind: req.kind,
+    commandPreview: req.commandPreview ?? undefined,
+    riskLevel: req.riskLevel ?? undefined,
+    activityText: req.activityText ?? undefined,
+    executionTarget: (req.executionTarget as "sandbox" | "host") ?? undefined,
   };
 }
 
@@ -240,7 +244,9 @@ function buildKindAwareQuestionText(req: CanonicalGuardianRequest): string {
   const baseText =
     req.questionText ??
     (req.toolName
-      ? `Approve tool: ${req.toolName}`
+      ? req.activityText
+        ? `Approve tool: ${req.toolName} — ${req.activityText}`
+        : `Approve tool: ${req.toolName}`
       : `Guardian request: ${req.kind}`);
 
   if (req.kind === "access_request") {

package/src/runtime/routes/identity-routes.ts

@@ -9,10 +9,12 @@ import { fileURLToPath } from "node:url";
 
 import { z } from "zod";
 
-import { getBaseDataDir } from "../../config/env-registry.js";
 import { parseIdentityFields } from "../../daemon/handlers/identity.js";
 import { getMaxMigrationVersion } from "../../memory/migrations/registry.js";
-import { getWorkspacePromptPath } from "../../util/platform.js";
+import {
+  getWorkspaceDir,
+  getWorkspacePromptPath,
+} from "../../util/platform.js";
 import { WORKSPACE_MIGRATIONS } from "../../workspace/migrations/registry.js";
 import { getLastWorkspaceMigrationId } from "../../workspace/migrations/runner.js";
 import { httpError } from "../http-errors.js";
@@ -28,8 +30,8 @@ interface DiskSpaceInfo {
 
 function getDiskSpaceInfo(): DiskSpaceInfo | null {
   try {
-    const baseDataDir = getBaseDataDir();
-    const diskPath = baseDataDir && existsSync(baseDataDir) ? baseDataDir : "/";
+    const wsDir = getWorkspaceDir();
+    const diskPath = existsSync(wsDir) ? wsDir : "/";
     const stats = statfsSync(diskPath);
     const totalBytes = stats.bsize * stats.blocks;
     const freeBytes = stats.bsize * stats.bavail;
@@ -261,6 +263,25 @@ export function identityRouteDefinitions(): RouteDefinition[] {
         migrations: z.object({}).passthrough(),
       }),
     },
+    {
+      endpoint: "healthz",
+      method: "GET",
+      handler: () => handleDetailedHealth(),
+      policyKey: "health",
+      summary: "Detailed health check (alias)",
+      description:
+        "Alias for /v1/health. Returns runtime health including version, disk, memory, CPU, and migration status.",
+      tags: ["system"],
+      responseBody: z.object({
+        status: z.string(),
+        timestamp: z.string(),
+        version: z.string(),
+        disk: z.object({}).passthrough(),
+        memory: z.object({}).passthrough(),
+        cpu: z.object({}).passthrough(),
+        migrations: z.object({}).passthrough(),
+      }),
+    },
     {
       endpoint: "identity",
       method: "GET",

package/src/runtime/routes/llm-context-normalization.ts

@@ -18,6 +18,7 @@ export interface LlmContextSummary {
   responseToolCallCount?: number;
   responsePreview?: string;
   toolCallNames?: string[];
+  estimatedCostUsd?: number | null;
 }
 
 export interface LlmContextSection {

package/src/runtime/routes/log-export-routes.ts

@@ -33,8 +33,8 @@ import {
 } from "../../memory/schema.js";
 import { getLogger } from "../../util/logger.js";
 import {
+  getDaemonStderrLogPath,
   getDataDir,
-  getRootDir,
   getWorkspaceConfigPath,
   getWorkspaceDir,
 } from "../../util/platform.js";
@@ -186,7 +186,7 @@ async function handleExport(body: ExportRequestBody): Promise<Response> {
       }
     }
 
-    const stderrPath = join(getRootDir(), "daemon-stderr.log");
+    const stderrPath = getDaemonStderrLogPath();
     if (existsSync(stderrPath)) {
       try {
         const stat = statSync(stderrPath);
@@ -452,6 +452,8 @@ const WORKSPACE_SKIP_DIRS = new Set([
   "data/attachments",
   "data/sounds",
   "conversations",
+  "signals",
+  "deprecated",
 ]);
 
 /** Files at the workspace root to skip (already covered by sanitized fields). */
@@ -666,6 +668,20 @@ function readSanitizedConfig(): Record<string, unknown> | undefined {
 // ---------------------------------------------------------------------------
 
 export function logExportRouteDefinitions(): RouteDefinition[] {
+  const exportRequestBody = z.object({
+    auditLimit: z
+      .number()
+      .int()
+      .optional()
+      .describe("Max audit records (default 1000)"),
+    conversationId: z
+      .string()
+      .optional()
+      .describe("Scope to a single conversation"),
+    startTime: z.number().optional().describe("Lower bound epoch ms"),
+    endTime: z.number().optional().describe("Upper bound epoch ms"),
+  });
+
   return [
     {
       endpoint: "export",
@@ -673,17 +689,23 @@ export function logExportRouteDefinitions(): RouteDefinition[] {
       policyKey: "export",
       summary: "Export logs and audit data",
       description:
-        "Export audit records, daemon logs, workspace contents, and config as a tar.gz archive.",
+        "Export audit records, assistant logs, workspace contents, and config as a tar.gz archive.",
+      tags: ["export"],
+      requestBody: exportRequestBody,
+      handler: async ({ req }) => {
+        const body = (await req.json()) as ExportRequestBody;
+        return handleExport(body);
+      },
+    },
+    {
+      endpoint: "logs/export",
+      method: "POST",
+      policyKey: "export",
+      summary: "Export logs and audit data (alias)",
+      description:
+        "Alias for /v1/export. Export audit records, assistant logs, workspace contents, and config as a tar.gz archive.",
       tags: ["export"],
-      requestBody: z.object({
-        auditLimit: z
-          .number()
-          .int()
-          .describe("Max audit records (default 1000)"),
-        conversationId: z.string().describe("Scope to a single conversation"),
-        startTime: z.number().describe("Lower bound epoch ms"),
-        endTime: z.number().describe("Upper bound epoch ms"),
-      }),
+      requestBody: exportRequestBody,
       handler: async ({ req }) => {
         const body = (await req.json()) as ExportRequestBody;
         return handleExport(body);

package/src/runtime/routes/migration-routes.ts

@@ -11,7 +11,6 @@
  * results with is_valid flag and detailed error descriptions.
  */
 
-import { join } from "node:path";
 import { Database } from "bun:sqlite";
 
 import { z } from "zod";
@@ -23,9 +22,8 @@ import { clearCache as clearTrustCache } from "../../permissions/trust-store.js"
 import { getLogger } from "../../util/logger.js";
 import {
   getDbPath,
-  getHooksDir,
-  getRootDir,
   getWorkspaceDir,
+  getWorkspaceHooksDir,
 } from "../../util/platform.js";
 import { httpError } from "../http-errors.js";
 import type { RouteDefinition } from "../http-router.js";
@@ -145,8 +143,9 @@ export async function handleMigrationExport(req: Request): Promise<Response> {
 
   try {
     const { archive, manifest } = buildExportVBundle({
-      trustPath: join(getRootDir(), "protected", "trust.json"),
-      hooksDir: getHooksDir(),
+      // hooksDir is intentionally omitted — hooks now live under workspace/hooks/
+      // and are included in the workspace walk. Passing hooksDir separately would
+      // export them twice (once as workspace/hooks/... and again as hooks/...).
       workspaceDir: getWorkspaceDir(),
       source: "runtime-export",
       description,
@@ -301,11 +300,9 @@ export async function handleMigrationImportPreflight(
       });
     }
 
-    // Step 2: Analyze what would change on import
     const pathResolver = new DefaultPathResolver(
-      join(getRootDir(), "protected"),
       getWorkspaceDir(),
-      getHooksDir(),
+      getWorkspaceHooksDir(),
     );
 
     const report = analyzeImport({
@@ -386,9 +383,8 @@ export async function handleMigrationImport(req: Request): Promise<Response> {
     }
 
     const pathResolver = new DefaultPathResolver(
-      join(getRootDir(), "protected"),
       getWorkspaceDir(),
-      getHooksDir(),
+      getWorkspaceHooksDir(),
     );
 
     // Close the live SQLite connection before overwriting assistant.db on disk.

package/src/runtime/routes/oauth-apps.ts

@@ -18,6 +18,7 @@ import {
   listConnections,
   upsertApp,
 } from "../../oauth/oauth-store.js";
+import { serializeProviderSummary } from "../../oauth/provider-serializer.js";
 import { httpError } from "../http-errors.js";
 import type { RouteDefinition } from "../http-router.js";
 
@@ -75,15 +76,7 @@ export function oauthAppsRouteDefinitions(): RouteDefinition[] {
 
         const providerRow = getProvider(providerKey);
         const provider = providerRow
-          ? {
-              provider_key: providerRow.providerKey,
-              display_name: providerRow.displayName ?? null,
-              description: providerRow.description ?? null,
-              dashboard_url: providerRow.dashboardUrl ?? null,
-              client_id_placeholder: providerRow.clientIdPlaceholder ?? null,
-              requires_client_secret: !!(providerRow.requiresClientSecret ?? 1),
-              supports_managed_mode: !!providerRow.managedServiceConfigKey,
-            }
+          ? serializeProviderSummary(providerRow)
           : null;
 
         return Response.json({

package/src/runtime/routes/oauth-providers.ts

@@ -0,0 +1,60 @@
+/**
+ * Route handlers for listing and getting OAuth providers.
+ *
+ * Provides read-only endpoints for querying the registered OAuth provider
+ * catalog. All endpoints are bearer-token authenticated via the standard
+ * runtime auth middleware.
+ */
+
+import { getProvider, listProviders } from "../../oauth/oauth-store.js";
+import { serializeProviderSummary } from "../../oauth/provider-serializer.js";
+import { httpError } from "../http-errors.js";
+import type { RouteDefinition } from "../http-router.js";
+
+/**
+ * Build route definitions for OAuth provider list/get endpoints.
+ */
+export function oauthProvidersRouteDefinitions(): RouteDefinition[] {
+  return [
+    // GET /v1/oauth/providers — List all providers with optional filtering.
+    {
+      endpoint: "oauth/providers",
+      method: "GET",
+      handler: ({ url }) => {
+        const rows = listProviders();
+        let serialized = rows
+          .map((row) => serializeProviderSummary(row))
+          .filter((s): s is NonNullable<typeof s> => s !== null);
+
+        const supportsManagedModeParam = url.searchParams.get(
+          "supports_managed_mode",
+        );
+        if (supportsManagedModeParam === "true") {
+          serialized = serialized.filter((p) => p.supports_managed_mode);
+        } else if (supportsManagedModeParam === "false") {
+          serialized = serialized.filter((p) => !p.supports_managed_mode);
+        }
+
+        return Response.json({ providers: serialized });
+      },
+    },
+
+    // GET /v1/oauth/providers/:providerKey — Get a single provider.
+    {
+      endpoint: "oauth/providers/:providerKey",
+      method: "GET",
+      handler: ({ params }) => {
+        const row = getProvider(params.providerKey);
+        if (!row) {
+          return httpError(
+            "NOT_FOUND",
+            `No OAuth provider registered for "${params.providerKey}"`,
+            404,
+          );
+        }
+
+        return Response.json({ provider: serializeProviderSummary(row) });
+      },
+    },
+  ];
+}

package/src/runtime/routes/pairing-routes.ts

@@ -147,8 +147,6 @@ export function cleanupPairingState(pairingRequestId: string): void {
 export interface PairingHandlerContext {
   pairingStore: PairingStore;
   bearerToken: string | undefined;
-  /** Feature-flag client token to include in pairing approval responses so iOS can PATCH flags. */
-  featureFlagToken: string | undefined;
   pairingBroadcast?: (msg: ServerMessage) => void;
 }
 
@@ -281,9 +279,6 @@ export async function handlePairingRequest(
         bearerToken: ctx.bearerToken,
         gatewayUrl: entry.gatewayUrl,
         localLanUrl: entry.localLanUrl,
-        ...(ctx.featureFlagToken
-          ? { featureFlagToken: ctx.featureFlagToken }
-          : {}),
         ...(credentials
           ? {
               accessToken: credentials.accessToken,
@@ -388,9 +383,6 @@ export function handlePairingStatus(
       bearerToken: entry.bearerToken,
       gatewayUrl: entry.gatewayUrl,
       localLanUrl: entry.localLanUrl,
-      ...(ctx.featureFlagToken
-        ? { featureFlagToken: ctx.featureFlagToken }
-        : {}),
       ...(credentialEntry
         ? {
             accessToken: credentialEntry.credentials.accessToken,

package/src/runtime/routes/settings-routes.ts

@@ -564,7 +564,6 @@ const SAFE_ENV_VAR_EXACT_NAMES = new Set([
   "VISUAL",
   "TZ",
   "TMPDIR",
-  "BASE_DATA_DIR",
   "QDRANT_HTTP_PORT",
   "PORT",
   "DEBUG",

package/src/runtime/routes/telemetry-routes.ts

@@ -35,6 +35,9 @@ export async function handleRecordLifecycleEvent(
   }
 
   const event = recordLifecycleEvent(eventName);
+  if (!event) {
+    return Response.json({ skipped: true });
+  }
   log.info({ eventName, eventId: event.id }, "Recorded lifecycle event");
 
   return Response.json({ id: event.id, event_name: event.eventName });
@@ -55,10 +58,19 @@ export function telemetryRouteDefinitions(): RouteDefinition[] {
       requestBody: z.object({
         event_name: z.string().describe("Event name: app_open or hatch"),
       }),
-      responseBody: z.object({
-        id: z.string().describe("Event ID"),
-        event_name: z.string(),
-      }),
+      responseBody: z.union([
+        z.object({
+          id: z.string().describe("Event ID"),
+          event_name: z.string(),
+        }),
+        z.object({
+          skipped: z
+            .literal(true)
+            .describe(
+              "Event skipped due to usage data collection being disabled",
+            ),
+        }),
+      ]),
       handler: async ({ req }) => handleRecordLifecycleEvent(req),
     },
   ];

package/src/security/encrypted-store.ts

@@ -30,7 +30,7 @@ import { dirname, join } from "node:path";
 import { getIsContainerized } from "../config/env-registry.js";
 import { ensureDir, pathExists } from "../util/fs.js";
 import { getLogger } from "../util/logger.js";
-import { getPlatformName, getRootDir } from "../util/platform.js";
+import { getPlatformName, getProtectedDir } from "../util/platform.js";
 
 const log = getLogger("encrypted-store");
 
@@ -80,7 +80,7 @@ interface EncryptedEntry {
 let storePathOverride: string | null = null;
 
 function getStorePath(): string {
-  return storePathOverride ?? join(getRootDir(), "protected", "keys.enc");
+  return storePathOverride ?? join(getProtectedDir(), "keys.enc");
 }
 
 /** @internal Test-only: override the store file path. Pass `null` to reset. */

package/src/security/secret-allowlist.ts

@@ -18,7 +18,7 @@ import { join } from "node:path";
 
 import { pathExists } from "../util/fs.js";
 import { getLogger } from "../util/logger.js";
-import { getRootDir } from "../util/platform.js";
+import { getProtectedDir } from "../util/platform.js";
 
 const log = getLogger("secret-allowlist");
 
@@ -45,7 +45,7 @@ let allowedRegexes: RegExp[] = [];
 export function loadAllowlist(): void {
   if (loaded || fileChecked) return;
 
-  const filePath = join(getRootDir(), "protected", "secret-allowlist.json");
+  const filePath = join(getProtectedDir(), "secret-allowlist.json");
   if (!pathExists(filePath)) {
     fileChecked = true;
     return;
@@ -169,7 +169,7 @@ function validateAllowlist(
  * Returns validation errors, or null if the file doesn't exist.
  */
 export function validateAllowlistFile(): AllowlistValidationError[] | null {
-  const filePath = join(getRootDir(), "protected", "secret-allowlist.json");
+  const filePath = join(getProtectedDir(), "secret-allowlist.json");
   if (!pathExists(filePath)) return null;
 
   const raw = readFileSync(filePath, "utf-8");