@vellumai/assistant 0.4.56 → 0.5.0

package/src/daemon/conversation.ts

@@ -30,6 +30,7 @@ import { createToolAuditListener } from "../events/tool-audit-listener.js";
 import { createToolDomainEventPublisher } from "../events/tool-domain-event-publisher.js";
 import { registerToolMetricsLoggingListener } from "../events/tool-metrics-listener.js";
 import { registerToolNotificationListener } from "../events/tool-notification-listener.js";
+import { registerToolPermissionTelemetryListener } from "../events/tool-permission-telemetry-listener.js";
 import {
   registerToolProfilingListener,
   ToolProfiler,
@@ -294,6 +295,7 @@ export class Conversation {
     );
     registerToolTraceListener(this.eventBus, this.traceEmitter);
     registerToolProfilingListener(this.eventBus, this.profiler);
+    registerToolPermissionTelemetryListener(this.eventBus);
     const auditToolLifecycleEvent = createToolAuditListener();
     const publishToolDomainEvent = createToolDomainEventPublisher(
       this.eventBus,

package/src/daemon/daemon-control.ts

@@ -133,7 +133,7 @@ function isVellumDaemonProcess(pid: number): boolean {
  *  Wildcard addresses (0.0.0.0, ::) bind all interfaces but aren't
  *  connectable on all platforms — substitute loopback. IPv6 literals
  *  need brackets in URLs. */
-function healthCheckHost(host: string): string {
+export function healthCheckHost(host: string): string {
   if (host === "0.0.0.0") return "127.0.0.1";
   if (host === "::") return "[::1]";
   if (host.includes(":")) return `[${host}]`;

package/src/daemon/date-context.ts

@@ -1,9 +1,8 @@
 /**
- * Temporal context formatter for future weekday/weekend grounding.
+ * Temporal context formatter for date/time grounding.
  *
  * Produces a compact, deterministic payload describing the current date,
- * upcoming weekend/work-week windows, and a short horizon of labelled
- * future dates.  Intended for runtime injection into the model context.
+ * time, and timezone.  Intended for runtime injection into the model context.
  */
 
 export interface TemporalContextOptions {
@@ -17,13 +16,8 @@ export interface TemporalContextOptions {
   configuredUserTimeZone?: string | null;
   /** IANA timezone inferred from user profile/memory (if available). */
   userTimeZone?: string | null;
-  /** Number of future days to list (default 14, hard-capped at 14). */
-  horizonDays?: number;
 }
 
-const MAX_OUTPUT_CHARS = 1500;
-const MAX_HORIZON_ENTRIES = 14;
-
 const WEEKDAY_NAMES = [
   "Sunday",
   "Monday",
@@ -316,35 +310,8 @@ function formatLocalIsoWithOffset(date: Date, timeZone: string): string {
   return `${year}-${month}-${day}T${hour}:${minute}:${second}${offset}`;
 }
 
-/**
- * Advance a date by `days` calendar days in the given timezone.
- *
- * Computes the local date, adds days to the day component, then anchors
- * the result at noon local time to avoid DST-transition edge cases.
- */
-function addDays(date: Date, days: number, timeZone: string): Date {
-  const parts = localDateParts(date, timeZone);
-  // Use Date.UTC for calendar overflow (e.g. Jan 32 → Feb 1).
-  const ref = new Date(Date.UTC(parts.year, parts.month - 1, parts.day + days));
-  const tY = ref.getUTCFullYear();
-  const tM = ref.getUTCMonth() + 1;
-  const tD = ref.getUTCDate();
-  // Noon UTC covers UTC-12 through ~UTC+11.  For far-east timezones
-  // (UTC+12/+13/+14) noon UTC is already the next local day, so fall
-  // back to midnight UTC which resolves correctly there.
-  const noonUTC = new Date(Date.UTC(tY, tM - 1, tD, 12, 0, 0));
-  const r = localDateParts(noonUTC, timeZone);
-  if (r.year === tY && r.month === tM && r.day === tD) {
-    return noonUTC;
-  }
-  return new Date(Date.UTC(tY, tM - 1, tD, 0, 0, 0));
-}
-
 /**
  * Build a compact temporal context string for model injection.
- *
- * Output is hard-capped at {@link MAX_OUTPUT_CHARS} characters and
- * {@link MAX_HORIZON_ENTRIES} horizon entries.
  */
 export function buildTemporalContext(
   options: TemporalContextOptions = {},
@@ -376,67 +343,27 @@ export function buildTemporalContext(
       : resolvedUserTimeZone
         ? "user_profile_memory"
         : "assistant_host_fallback";
-  const horizonDays = Math.min(
-    options.horizonDays ?? MAX_HORIZON_ENTRIES,
-    MAX_HORIZON_ENTRIES,
-  );
-
   const todayParts = localDateParts(now, timeZone);
   const todayStr = formatLocalDate(now, timeZone);
   const todayWeekday = WEEKDAY_NAMES[todayParts.weekday];
 
-  // ── Next weekend (Saturday-Sunday) ──
-  const daysUntilSaturday = (6 - todayParts.weekday + 7) % 7 || 7;
-  const nextSaturday = addDays(now, daysUntilSaturday, timeZone);
-  const nextSunday = addDays(now, daysUntilSaturday + 1, timeZone);
-
-  // ── Next work week (Monday-Friday) ──
-  const daysUntilMonday = (1 - todayParts.weekday + 7) % 7 || 7;
-  const nextMonday = addDays(now, daysUntilMonday, timeZone);
-  const nextFriday = addDays(now, daysUntilMonday + 4, timeZone);
-
-  // ── Horizon list ──
-  const horizonLines: string[] = [];
-  for (let i = 1; i <= horizonDays; i++) {
-    const futureDate = addDays(now, i, timeZone);
-    const futureParts = localDateParts(futureDate, timeZone);
-    const label = WEEKDAY_NAMES[futureParts.weekday];
-    horizonLines.push(`  ${formatLocalDate(futureDate, timeZone)} ${label}`);
-  }
-
   const lines = [
     `<temporal_context>`,
     `Today: ${todayStr} (${todayWeekday})`,
     `Timezone: ${timeZone}`,
     `Current local time: ${formatLocalIsoWithOffset(now, timeZone)}`,
     `Current UTC time: ${now.toISOString()}`,
-    `Clock source: assistant host machine`,
-    `Assistant host timezone: ${resolvedHostTimeZone}`,
-    `User timezone: ${userTimeZone ?? "unknown"}`,
     `Timezone source: ${timeZoneSource}`,
-    ``,
-    `Week definitions: work week = Monday–Friday, weekend = Saturday–Sunday`,
-    ``,
-    `Next weekend: ${formatLocalDate(
-      nextSaturday,
-      timeZone,
-    )} – ${formatLocalDate(nextSunday, timeZone)}`,
-    `Next work week: ${formatLocalDate(
-      nextMonday,
-      timeZone,
-    )} – ${formatLocalDate(nextFriday, timeZone)}`,
-    ``,
-    `Upcoming dates:`,
-    ...horizonLines,
-    `</temporal_context>`,
   ];
 
-  let output = lines.join("\n");
-
-  // Hard cap: truncate if somehow over budget (shouldn't happen with 14 entries).
-  if (output.length > MAX_OUTPUT_CHARS) {
-    output = output.slice(0, MAX_OUTPUT_CHARS - 25) + "\n</temporal_context>";
+  if (userTimeZone && userTimeZone !== timeZone) {
+    lines.push(`User timezone: ${userTimeZone}`);
   }
+  if (resolvedHostTimeZone !== timeZone) {
+    lines.push(`Assistant host timezone: ${resolvedHostTimeZone}`);
+  }
+
+  lines.push(`</temporal_context>`);
 
-  return output;
+  return lines.join("\n");
 }

package/src/daemon/handlers/config-channels.ts

@@ -551,9 +551,14 @@ export async function handleChannelVerificationSession(
           rebind: msg.rebind,
           originConversationId: msg.originConversationId,
         });
+        if (result._pendingSlackDm) {
+          const { userId, text, assistantId: aid } = result._pendingSlackDm;
+          deliverVerificationSlack(userId, text, aid);
+        }
+        const { _pendingSlackDm: _, ...publicResult } = result;
         ctx.send({
           type: "channel_verification_session_response",
-          ...result,
+          ...publicResult,
         });
       } else {
         const result = createInboundChallenge(
@@ -591,9 +596,14 @@ export async function handleChannelVerificationSession(
         channel,
         originConversationId: msg.originConversationId,
       });
+      if (result._pendingSlackDm) {
+        const { userId, text, assistantId: aid } = result._pendingSlackDm;
+        deliverVerificationSlack(userId, text, aid);
+      }
+      const { _pendingSlackDm: _, ...publicResult } = result;
       ctx.send({
         type: "channel_verification_session_response",
-        ...result,
+        ...publicResult,
       });
     } else {
       ctx.send({

package/src/daemon/handlers/config-slack-channel.ts

@@ -8,6 +8,7 @@ import {
 import {
   ensureManualTokenConnection,
   removeManualTokenConnection,
+  syncManualTokenConnection,
 } from "../../oauth/manual-token-connection.js";
 import { getConnectionByProvider } from "../../oauth/oauth-store.js";
 import { credentialKey } from "../../security/credential-key.js";
@@ -40,6 +41,12 @@ export interface SlackChannelConfigResult {
 // -- Business logic --
 
 export async function getSlackChannelConfig(): Promise<SlackChannelConfigResult> {
+  const { teamId, teamName, botUserId, botUsername } = getConfig().slack;
+  const accountInfo = teamName
+    ? `${teamName}${botUsername ? ` (@${botUsername})` : ""}`
+    : undefined;
+  await syncManualTokenConnection("slack_channel", accountInfo);
+
   const hasBotToken = !!(await getSecureKeyAsync(
     credentialKey("slack_channel", "bot_token"),
   ));
@@ -49,7 +56,6 @@ export async function getSlackChannelConfig(): Promise<SlackChannelConfigResult>
   const conn = getConnectionByProvider("slack_channel");
   const connected =
     !!(conn && conn.status === "active") && hasBotToken && hasAppToken;
-  const { teamId, teamName, botUserId, botUsername } = getConfig().slack;
   return {
     success: true,
     hasBotToken,

package/src/daemon/handlers/config-telegram.ts

@@ -11,6 +11,7 @@ import {
 import {
   ensureManualTokenConnection,
   removeManualTokenConnection,
+  syncManualTokenConnection,
 } from "../../oauth/manual-token-connection.js";
 import { getConnectionByProvider } from "../../oauth/oauth-store.js";
 import { credentialKey } from "../../security/credential-key.js";
@@ -69,6 +70,11 @@ export type TelegramConfigResult = Omit<TelegramConfigResponse, "type">;
 // -- Extracted business logic functions --
 
 export async function getTelegramConfig(): Promise<TelegramConfigResult> {
+  const botUsername = getTelegramBotUsername();
+  await syncManualTokenConnection(
+    "telegram",
+    botUsername ? `@${botUsername}` : undefined,
+  );
   const hasBotToken = !!(await getSecureKeyAsync(
     credentialKey("telegram", "bot_token"),
   ));
@@ -78,7 +84,6 @@ export async function getTelegramConfig(): Promise<TelegramConfigResult> {
   const conn = getConnectionByProvider("telegram");
   const connected = !!(conn && conn.status === "active");
   const botId = getTelegramBotId();
-  const botUsername = getTelegramBotUsername();
   return {
     success: true,
     hasBotToken,

package/src/daemon/handlers/conversations.ts

@@ -581,14 +581,14 @@ export function deleteQueuedMessage(
   ) => { removeQueuedMessage(requestId: string): boolean } | undefined,
 ):
   | { removed: true }
-  | { removed: false; reason: "session_not_found" | "message_not_found" } {
+  | { removed: false; reason: "conversation_not_found" | "message_not_found" } {
   const conversation = findConversation(conversationId);
   if (!conversation) {
     log.warn(
       { conversationId, requestId },
       "No conversation found for delete_queued_message",
     );
-    return { removed: false, reason: "session_not_found" };
+    return { removed: false, reason: "conversation_not_found" };
   }
   const removed = conversation.removeQueuedMessage(requestId);
   if (removed) {

package/src/daemon/handlers/skills.ts

@@ -38,6 +38,7 @@ import {
   removeSkillsIndexEntry,
   validateManagedSkillId,
 } from "../../skills/managed-store.js";
+import { deleteSkillCapabilityMemory } from "../../skills/skill-memory.js";
 import { getWorkspaceSkillsDir } from "../../util/platform.js";
 import {
   CONFIG_RELOAD_DEBOUNCE_MS,
@@ -603,6 +604,9 @@ export async function uninstallSkill(
       } catch {
         /* best effort */
       }
+      // Best-effort cleanup of capability memory for uninstalled skill
+      // (managed path handles this internally via deleteManagedSkill)
+      deleteSkillCapabilityMemory(skillId);
     }
 
     // Clean config entry

package/src/daemon/lifecycle.ts

@@ -42,6 +42,7 @@ import { startMemoryJobsWorker } from "../memory/jobs-worker.js";
 import { initQdrantClient } from "../memory/qdrant-client.js";
 import { QdrantManager } from "../memory/qdrant-manager.js";
 import { rotateToolInvocations } from "../memory/tool-usage-store.js";
+import { deleteOldTraceEvents } from "../memory/trace-event-store.js";
 import {
   emitNotificationSignal,
   registerBroadcastFn,
@@ -61,6 +62,7 @@ import {
 import { ensureVellumGuardianBinding } from "../runtime/guardian-vellum-migration.js";
 import { RuntimeHttpServer } from "../runtime/http-server.js";
 import { startScheduler } from "../schedule/scheduler.js";
+import { seedCatalogSkillMemories } from "../skills/skill-memory.js";
 import { UsageTelemetryReporter } from "../telemetry/usage-telemetry-reporter.js";
 import { getLogger, initLogger } from "../util/logger.js";
 import {
@@ -373,6 +375,12 @@ export async function runDaemon(): Promise<void> {
     log.info("Daemon startup: starting memory worker");
     const memoryWorker = startMemoryJobsWorker();
 
+    // Seed capability memories for first-party catalog skills so the memory
+    // pipeline can surface relevant skills via semantic search.
+    void seedCatalogSkillMemories().catch((err) =>
+      log.warn({ err }, "Catalog skill memory seeding failed — continuing"),
+    );
+
     registerWatcherProviders();
     registerMessagingProviders();
 
@@ -400,7 +408,7 @@ export async function runDaemon(): Promise<void> {
         await emitNotificationSignal({
           sourceEventName: "schedule.notify",
           sourceChannel: "scheduler",
-          sourceSessionId: schedule.id,
+          sourceContextId: schedule.id,
           attentionHints: {
             requiresAction: true,
             urgency: "high",
@@ -422,7 +430,7 @@ export async function runDaemon(): Promise<void> {
         void emitNotificationSignal({
           sourceEventName: "schedule.complete",
           sourceChannel: "scheduler",
-          sourceSessionId: schedule.id,
+          sourceContextId: schedule.id,
           attentionHints: {
             requiresAction: false,
             urgency: "medium",
@@ -440,7 +448,7 @@ export async function runDaemon(): Promise<void> {
         void emitNotificationSignal({
           sourceEventName: "watcher.notification",
           sourceChannel: "watcher",
-          sourceSessionId: `watcher-${Date.now()}`,
+          sourceContextId: `watcher-${Date.now()}`,
           attentionHints: {
             requiresAction: false,
             urgency: "low",
@@ -458,7 +466,7 @@ export async function runDaemon(): Promise<void> {
         void emitNotificationSignal({
           sourceEventName: "watcher.escalation",
           sourceChannel: "watcher",
-          sourceSessionId: `watcher-escalation-${Date.now()}`,
+          sourceContextId: `watcher-escalation-${Date.now()}`,
           attentionHints: {
             requiresAction: true,
             urgency: "high",
@@ -824,6 +832,22 @@ export async function runDaemon(): Promise<void> {
       }
     }
 
+    // Prune trace events older than 7 days to keep the database lean.
+    // Deferred so synchronous cleanup doesn't block the startup path.
+    setTimeout(() => {
+      try {
+        const deletedTraceEvents = deleteOldTraceEvents(7);
+        if (deletedTraceEvents > 0) {
+          log.debug(
+            { deletedTraceEvents },
+            `Pruned ${deletedTraceEvents} trace event(s) older than 7 days`,
+          );
+        }
+      } catch (err) {
+        log.warn({ err }, "Trace event cleanup failed");
+      }
+    }, 0);
+
     const workspaceHeartbeat = new WorkspaceHeartbeatService();
     workspaceHeartbeat.start();
 

package/src/daemon/providers-setup.ts

@@ -49,7 +49,7 @@ export async function initializeProvidersAndTools(
   }
 
   // Rehydrate the platform assistant ID from the credential store so
-  // isPlatformManaged() works after assistant restarts.
+  // shouldUsePlatformCallbacks() works after assistant restarts.
   try {
     const key = credentialKey("vellum", "platform_assistant_id");
     const persisted = await getSecureKeyAsync(key);

package/src/daemon/server.ts

@@ -758,10 +758,7 @@ export class DaemonServer {
           config.providerOrder,
         );
         const { rateLimit } = config;
-        if (
-          rateLimit.maxRequestsPerMinute > 0 ||
-          rateLimit.maxTokensPerSession > 0
-        ) {
+        if (rateLimit.maxRequestsPerMinute > 0) {
           provider = new RateLimitProvider(
             provider,
             rateLimit,
@@ -915,7 +912,6 @@ export class DaemonServer {
       resolveChannelCapabilities(
         sourceChannel,
         sourceInterface,
-        null,
         options?.transport?.chatType,
       ),
     );

package/src/daemon/shutdown-handlers.ts

@@ -30,6 +30,7 @@ export interface ShutdownDeps {
 
 export function installShutdownHandlers(deps: ShutdownDeps): void {
   let shuttingDown = false;
+  let exitCode = 0;
 
   const shutdown = async () => {
     if (shuttingDown) return;
@@ -134,19 +135,24 @@ export function installShutdownHandlers(deps: ShutdownDeps): void {
     await Sentry.flush(2000);
     clearTimeout(forceTimer);
     deps.cleanupPidFile();
-    process.exit(0);
+    process.exit(exitCode);
   };
 
   process.on("SIGTERM", shutdown);
   process.on("SIGINT", shutdown);
+  process.on("SIGHUP", shutdown);
 
   process.on("unhandledRejection", (reason) => {
-    log.error({ err: reason }, "Unhandled promise rejection");
+    log.error({ err: reason }, "Unhandled promise rejection — initiating shutdown");
     Sentry.captureException(reason);
+    exitCode = 1;
+    void shutdown();
   });
 
   process.on("uncaughtException", (err) => {
-    log.error({ err }, "Uncaught exception");
+    log.error({ err }, "Uncaught exception — initiating shutdown");
     Sentry.captureException(err);
+    exitCode = 1;
+    void shutdown();
   });
 }

package/src/daemon/tool-side-effects.ts

@@ -12,6 +12,7 @@ import { join } from "node:path";
 import { compileApp } from "../bundler/app-compiler.js";
 import { generateAppIcon } from "../media/app-icon-generator.js";
 import { getApp, getAppsDir, isMultifileApp } from "../memory/app-store.js";
+import { deliverVerificationSlack } from "../runtime/verification-outbound-actions.js";
 import { updatePublishedAppDeployment } from "../services/published-app-updater.js";
 import type { ToolExecutionResult } from "../tools/types.js";
 import { getLogger } from "../util/logger.js";
@@ -226,6 +227,45 @@ registerHook(
   },
 );
 
+// Dispatch pending Slack DM delivery when a CLI verification command
+// completes.  The CLI subprocess is sandboxed and cannot reach the
+// gateway, so it includes a `_pendingSlackDm` field in its JSON output.
+// This hook runs in the unsandboxed daemon process and delivers the DM.
+registerHook("bash", (_name, input, result) => {
+  const command = (input.command ?? "") as string;
+  if (!command.includes("channel-verification-sessions")) return;
+  if (!result.content.includes("_pendingSlackDm")) return;
+
+  type PendingDm = { userId: string; text: string; assistantId: string };
+  type Parsed = { _pendingSlackDm?: PendingDm };
+
+  const dispatch = (parsed: Parsed) => {
+    if (parsed._pendingSlackDm) {
+      const { userId, text, assistantId } = parsed._pendingSlackDm;
+      deliverVerificationSlack(userId, text, assistantId);
+      return true;
+    }
+    return false;
+  };
+
+  // Try full content first (handles pretty-printed single-object JSON)
+  try {
+    if (dispatch(JSON.parse(result.content.trim()) as Parsed)) return;
+  } catch {
+    // Not a single JSON object — fall back to line-by-line for
+    // multi-object output (e.g. cancel + create chained with &&).
+  }
+  for (const line of result.content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("{")) continue;
+    try {
+      if (dispatch(JSON.parse(trimmed) as Parsed)) return;
+    } catch {
+      continue;
+    }
+  }
+});
+
 // ── Runner ───────────────────────────────────────────────────────────
 
 /**

package/src/daemon/trace-emitter.ts

@@ -1,9 +1,17 @@
 import { v4 as uuid } from "uuid";
 
+import {
+  getMaxSequence,
+  persistTraceEvent,
+} from "../memory/trace-event-store.js";
+import { getLogger } from "../util/logger.js";
 import type { ServerMessage, TraceEventKind } from "./message-protocol.js";
+import type { TraceEvent } from "./message-types/messages.js";
 
 export type TraceEventStatus = "info" | "success" | "warning" | "error";
 
+const log = getLogger("trace-emitter");
+
 const SUMMARY_MAX_LENGTH = 200;
 const ATTRIBUTE_VALUE_MAX_LENGTH = 500;
 
@@ -19,12 +27,21 @@ export interface TraceEmitOptions {
  * even if timestamps collide.
  */
 export class TraceEmitter {
-  private sequence = 0;
+  private sequence: number;
 
   constructor(
     private readonly conversationId: string,
     private sendToClient: (msg: ServerMessage) => void,
-  ) {}
+  ) {
+    // Seed from the highest persisted sequence so that new events always
+    // have strictly higher sequence numbers, even across daemon restarts.
+    try {
+      const maxPersisted = getMaxSequence(conversationId);
+      this.sequence = maxPersisted + 1;
+    } catch {
+      this.sequence = 0;
+    }
+  }
 
   updateSender(sendToClient: (msg: ServerMessage) => void): void {
     this.sendToClient = sendToClient;
@@ -50,7 +67,14 @@ export class TraceEmitter {
       attributes,
     };
 
+    // Send to client first so synchronous DB writes don't block SSE delivery.
     this.sendToClient(event);
+
+    try {
+      persistTraceEvent(event as TraceEvent);
+    } catch (err) {
+      log.warn({ err, eventId }, "Failed to persist trace event");
+    }
   }
 }
 

package/src/events/domain-events.ts

@@ -70,7 +70,7 @@ export interface DaemonDomainEvents {
   "daemon.lifecycle.stopped": {
     stoppedAtMs: number;
   };
-  "daemon.session.created": {
+  "daemon.conversation.created": {
     conversationId: string;
     createdAtMs: number;
   };

package/src/events/tool-permission-telemetry-listener.ts

@@ -0,0 +1,46 @@
+import { recordLifecycleEvent } from "../memory/lifecycle-events-store.js";
+import { getLogger } from "../util/logger.js";
+import type { EventBus, Subscription } from "./bus.js";
+import type { AssistantDomainEvents } from "./domain-events.js";
+
+const log = getLogger("tool-permission-telemetry");
+
+export function registerToolPermissionTelemetryListener(
+  eventBus: EventBus<AssistantDomainEvents>,
+): Subscription {
+  // Track which tool calls were actually prompted so we only record
+  // decided telemetry for real user interactions, not auto-allowed tools.
+  // Uses a composite key (requestId:toolName) because requestId is per-message,
+  // not per-tool-call — parallel tool_use blocks share the same requestId.
+  const promptedToolCalls = new Set<string>();
+
+  return eventBus.onAny((event) => {
+    try {
+      switch (event.type) {
+        case "tool.permission.requested": {
+          const { requestId, toolName } = event.payload;
+          if (requestId) {
+            promptedToolCalls.add(`${requestId}:${toolName}`);
+          }
+          recordLifecycleEvent(`permission_prompt:${toolName}`);
+          return;
+        }
+        case "tool.permission.decided": {
+          const { requestId, toolName, decision } = event.payload;
+          const key = requestId ? `${requestId}:${toolName}` : undefined;
+          if (key && promptedToolCalls.has(key)) {
+            promptedToolCalls.delete(key);
+            recordLifecycleEvent(
+              `permission_decided:${toolName}:${decision}`,
+            );
+          }
+          return;
+        }
+        default:
+          return;
+      }
+    } catch (err) {
+      log.warn({ err }, "Failed to record permission telemetry event");
+    }
+  });
+}

package/src/inbound/platform-callback-registration.ts

@@ -24,28 +24,10 @@ import {
   getPlatformInternalApiKey,
 } from "../config/env.js";
 import { getIsContainerized } from "../config/env-registry.js";
-import { isManagedProxyEnabledSync } from "../providers/managed-proxy/context.js";
 import { getLogger } from "../util/logger.js";
 
 const log = getLogger("platform-callback-registration");
 
-/**
- * Whether this is a platform-managed deployment with usable managed credentials.
- *
- * True when PLATFORM_BASE_URL and PLATFORM_ASSISTANT_ID are both set **and**
- * the managed proxy prerequisites (including the assistant API key) were
- * satisfied the last time `resolveManagedProxyContext()` ran. This prevents
- * the system prompt from claiming managed credentials are available during
- * partial/failed platform bootstrap where the API key is missing.
- */
-export function isPlatformManaged(): boolean {
-  return (
-    !!getPlatformBaseUrl() &&
-    !!getPlatformAssistantId() &&
-    isManagedProxyEnabledSync()
-  );
-}
-
 /**
  * Whether the daemon should register callback routes with the platform.
  * True when IS_CONTAINERIZED, PLATFORM_BASE_URL, and PLATFORM_ASSISTANT_ID