@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

package/src/runtime/routes/__tests__/retrospective-routes.test.ts

@@ -63,6 +63,7 @@ function insertMessage(
   createdAt: number,
 ): void {
   rawRun(
+    "test:insertMessage",
     "INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES (?, ?, ?, ?, ?)",
     `msg-${conversationId}-${role}-${createdAt}`,
     conversationId,
@@ -74,6 +75,7 @@ function insertMessage(
 
 function setCreatedAt(conversationId: string, createdAt: number): void {
   rawRun(
+    "test:setCreatedAt",
     "UPDATE conversations SET created_at = ? WHERE id = ?",
     createdAt,
     conversationId,
@@ -105,6 +107,7 @@ function recordUsageCostAt(
     { estimatedCostUsd, pricingStatus: "priced" },
   );
   rawRun(
+    "test:setUsageCreatedAt",
     "UPDATE llm_usage_events SET created_at = ? WHERE id = ?",
     createdAt,
     event.id,
@@ -268,6 +271,7 @@ describe("listRetrospectiveRuns handler", () => {
       source: MEMORY_RETROSPECTIVE_SOURCE,
     });
     rawRun(
+      "test:setCreatedAtAndCost",
       "UPDATE conversations SET created_at = ?, total_estimated_cost = ? WHERE id = ?",
       1000,
       0.42,

package/src/runtime/routes/__tests__/schedule-routes-create.test.ts

@@ -0,0 +1,70 @@
+/**
+ * The `createSchedule` route accepts `script` mode (not just execute/workflow),
+ * so a catalog skill's `setup.ts` can register a script-mode schedule via the
+ * CLI/HTTP path instead of the in-assistant `schedule_create` tool.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import { initializeDb } from "../../../persistence/db-init.js";
+import { ROUTES } from "../schedule-routes.js";
+
+await initializeDb();
+
+const createHandler = (() => {
+  const route = ROUTES.find((r) => r.operationId === "createSchedule");
+  if (!route) throw new Error("createSchedule route not found");
+  return route.handler;
+})();
+
+interface CreateResult {
+  schedule: {
+    name: string;
+    mode: string;
+    script: string | null;
+    timeoutMs: number | null;
+  };
+}
+
+async function create(body: Record<string, unknown>): Promise<CreateResult> {
+  return (await createHandler({ body })) as CreateResult;
+}
+
+describe("createSchedule route — script mode", () => {
+  test("returns the created script schedule with its command + timeout", async () => {
+    const { schedule } = await create({
+      name: "wt-script-create",
+      mode: "script",
+      script: 'cd "$VELLUM_WORKSPACE_DIR/schedules/$__SCHEDULE_ID" && bun poll.ts',
+      expression: "*/15 * * * *",
+      description: "polls github",
+      timeoutMs: 120000,
+    });
+    expect(schedule.name).toBe("wt-script-create");
+    expect(schedule.mode).toBe("script");
+    expect(schedule.script).toContain("bun poll.ts");
+    expect(schedule.timeoutMs).toBe(120000);
+  });
+
+  test("script mode does not require a message", async () => {
+    const { schedule } = await create({
+      name: "wt-script-nomsg",
+      mode: "script",
+      script: "echo hi",
+      expression: "0 * * * *",
+      description: "d",
+    });
+    expect(schedule.mode).toBe("script");
+  });
+
+  test("rejects script mode without a script", async () => {
+    await expect(
+      create({
+        name: "wt-script-missing",
+        mode: "script",
+        expression: "* * * * *",
+        description: "d",
+      }),
+    ).rejects.toThrow(/script is required/);
+  });
+});

package/src/runtime/routes/__tests__/schedule-worker-routes.test.ts

@@ -0,0 +1,161 @@
+/**
+ * Tests for the schedule worker control routes (start / stop / status).
+ *
+ * The route handlers run inside the daemon and own the worker process. We mock
+ * schedule worker-control and the config loader so the tests assert handler
+ * behaviour:
+ *   - start spawns as a daemon child (detached:false), enables the flag only on
+ *     success, and throws on spawn failure (flag untouched).
+ *   - stop disables the flag and signals the worker.
+ *   - status reports the worker process, the flag, and the in-process runner.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import * as actualLoader from "../../../config/loader.js";
+import { getScheduleWorkerPidPath } from "../../../util/platform.js";
+
+class FakeSpawnError extends Error {}
+
+let spawnImpl: () => Promise<{ pid: number; alreadyRunning: boolean }>;
+let spawnArgs: Array<{ detached?: boolean; terminateOnTimeout?: boolean }> = [];
+let stopImpl: () => { status: "running" | "not_running"; pid?: number };
+/** Records the `schedules.worker.enabled` values written via saveRawConfig. */
+let enabledCalls: boolean[] = [];
+let workerProbe: { status: "running" | "not_running"; pid?: number } = {
+  status: "not_running",
+};
+let configEnabled = false;
+
+mock.module("../../../schedule/worker-control.js", () => ({
+  ScheduleWorkerSpawnError: FakeSpawnError,
+  spawnScheduleWorkerProcess: async (opts: {
+    detached?: boolean;
+    terminateOnTimeout?: boolean;
+  }) => {
+    spawnArgs.push(opts);
+    return spawnImpl();
+  },
+  stopScheduleWorkerProcess: () => stopImpl(),
+  probeScheduleWorker: () => workerProbe,
+}));
+
+mock.module("../../../config/loader.js", () => ({
+  ...actualLoader,
+  getConfigReadOnly: () => ({
+    schedules: { worker: { enabled: configEnabled } },
+  }),
+  loadRawConfig: () => ({}),
+  saveRawConfig: (cfg: { schedules?: { worker?: { enabled?: boolean } } }) => {
+    enabledCalls.push(cfg.schedules?.worker?.enabled === true);
+  },
+}));
+
+const { ROUTES } = await import("../schedule-worker-routes.js");
+
+function handler(operationId: string) {
+  const route = ROUTES.find((r) => r.operationId === operationId);
+  if (!route) {
+    throw new Error(`route ${operationId} not registered`);
+  }
+  return route.handler as () => Promise<Record<string, unknown>>;
+}
+
+beforeEach(() => {
+  spawnArgs = [];
+  enabledCalls = [];
+  spawnImpl = async () => ({ pid: 4242, alreadyRunning: false });
+  stopImpl = () => ({ status: "not_running" });
+  workerProbe = { status: "not_running" };
+  configEnabled = false;
+});
+
+describe("schedules_worker_start", () => {
+  test("spawns as a daemon child and enables the flag on success", async () => {
+    spawnImpl = async () => ({ pid: 4242, alreadyRunning: false });
+
+    const res = await handler("schedules_worker_start")();
+
+    expect(spawnArgs).toEqual([{ detached: false, terminateOnTimeout: true }]);
+    expect(enabledCalls).toEqual([true]);
+    expect(res).toEqual({
+      pid: 4242,
+      alreadyRunning: false,
+      workerEnabled: true,
+      pidPath: getScheduleWorkerPidPath(),
+    });
+  });
+
+  test("reports an already-running worker without re-spawning", async () => {
+    spawnImpl = async () => ({ pid: 99, alreadyRunning: true });
+
+    const res = await handler("schedules_worker_start")();
+
+    expect(res).toMatchObject({ pid: 99, alreadyRunning: true });
+    expect(enabledCalls).toEqual([true]);
+  });
+
+  test("throws and leaves the flag untouched when the spawn fails", async () => {
+    spawnImpl = async () => {
+      throw new FakeSpawnError("worker exited during startup");
+    };
+
+    await expect(handler("schedules_worker_start")()).rejects.toThrow(
+      "worker exited during startup",
+    );
+    expect(enabledCalls).toEqual([]);
+  });
+});
+
+describe("schedules_worker_stop", () => {
+  test("disables the flag and reports a signalled running worker", async () => {
+    stopImpl = () => ({ status: "running", pid: 555 });
+
+    const res = await handler("schedules_worker_stop")();
+
+    expect(enabledCalls).toEqual([false]);
+    expect(res).toEqual({
+      workerWasRunning: true,
+      pid: 555,
+      workerEnabled: false,
+    });
+  });
+
+  test("disables the flag and succeeds when no worker is running", async () => {
+    stopImpl = () => ({ status: "not_running" });
+
+    const res = await handler("schedules_worker_stop")();
+
+    expect(enabledCalls).toEqual([false]);
+    expect(res).toEqual({ workerWasRunning: false, workerEnabled: false });
+  });
+});
+
+describe("schedules_worker_status", () => {
+  test("reports a running worker with the flag on and the in-process scheduler standing down", async () => {
+    workerProbe = { status: "running", pid: 321 };
+    configEnabled = true;
+
+    const res = await handler("schedules_worker_status")();
+
+    expect(res).toEqual({
+      status: "running",
+      pid: 321,
+      workerEnabled: true,
+      inProcessScheduler: { status: "not_running" },
+    });
+  });
+
+  test("reports the daemon as the schedule runner when the flag is off", async () => {
+    workerProbe = { status: "not_running" };
+    configEnabled = false;
+
+    const res = await handler("schedules_worker_status")();
+
+    expect(res).toEqual({
+      status: "not_running",
+      workerEnabled: false,
+      inProcessScheduler: { status: "running", pid: process.pid },
+    });
+  });
+});

package/src/runtime/routes/__tests__/surface-action-routes.test.ts

@@ -110,7 +110,7 @@ mock.module("../../../daemon/conversation-store.js", () => ({
 }));
 
 mock.module("../../../persistence/raw-query.js", () => ({
-  rawGet: (sql: string, ...params: unknown[]) => {
+  rawGet: (_label: string, sql: string, ...params: unknown[]) => {
     rawGetCalls.push({ sql, params });
     return rawGetReturn;
   },

package/src/runtime/routes/__tests__/surface-content-routes.test.ts

@@ -75,7 +75,7 @@ mock.module("../../../daemon/conversation-store.js", () => ({
 }));
 
 mock.module("../../../persistence/raw-query.js", () => ({
-  rawGet: (sql: string, ...params: unknown[]) => {
+  rawGet: (_label: string, sql: string, ...params: unknown[]) => {
     rawGetCalls.push({ sql, params });
     return rawGetReturn;
   },

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

@@ -13,7 +13,10 @@ import { resolveAgentWithAutoInstall } from "../../acp/auto-install.js";
 import { getAcpSessionManager } from "../../acp/index.js";
 import { prepareAgentEnv } from "../../acp/prepare-agent-env.js";
 import { formatResolveFailure } from "../../acp/resolve-agent.js";
-import { AcpResumeError } from "../../acp/session-manager.js";
+import {
+  AcpResumeError,
+  AcpSessionNotFoundError,
+} from "../../acp/session-manager.js";
 import type { AcpSessionState } from "../../acp/types.js";
 import { getConfig } from "../../config/loader.js";
 import type { UserDecision } from "../../permissions/types.js";
@@ -29,6 +32,7 @@ import {
   ConflictError,
   FailedDependencyError,
   ForbiddenError,
+  InternalError,
   NotFoundError,
 } from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
@@ -387,8 +391,16 @@ async function cancelSession({ pathParams }: RouteHandlerArgs) {
   const manager = getAcpSessionManager();
   try {
     await manager.cancel(id);
-  } catch {
-    throw new NotFoundError("ACP session not found");
+  } catch (err) {
+    // Only a genuinely unknown session is a 404. A protocol-cancel failure on a
+    // still-live session is a real error, not a missing session, so it surfaces
+    // as a 500 rather than a misleading not-found.
+    if (err instanceof AcpSessionNotFoundError) {
+      throw new NotFoundError("ACP session not found");
+    }
+    throw new InternalError(
+      err instanceof Error ? err.message : "Failed to cancel ACP session",
+    );
   }
   return { acpSessionId: id, cancelled: true };
 }

package/src/runtime/routes/app-management-routes.ts

@@ -49,7 +49,10 @@ import { compareSemver } from "../../daemon/handlers/shared.js";
 import { computeContentId } from "../../util/content-id.js";
 import { getLogger } from "../../util/logger.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
-import { publishAppsChanged } from "../sync/resource-sync-events.js";
+import {
+  getOriginClientId,
+  publishAppsChanged,
+} from "../sync/resource-sync-events.js";
 import {
   BadRequestError,
   NotFoundError,
@@ -63,12 +66,6 @@ const log = getLogger("app-management-routes");
 // Helpers
 // ---------------------------------------------------------------------------
 
-function getOriginClientId(
-  headers: RouteHandlerArgs["headers"],
-): string | undefined {
-  return headers?.["x-vellum-client-id"]?.trim() || undefined;
-}
-
 function getSharedAppsDir(): string {
   return join(
     homedir(),

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

@@ -179,6 +179,10 @@ function handleSecret({ body }: RouteHandlerArgs) {
   (resolved?.rpcResolve as ((r: SecretPromptResult) => void) | undefined)?.({
     value: value ?? null,
     delivery: (effectiveDelivery as SecretDelivery) ?? "store",
+    // A missing value here is a deliberate user cancel (the client dismissed
+    // the prompt), distinct from the timeout path. Tag it so downstream callers
+    // can treat it as a valid outcome rather than a failure.
+    ...(value === undefined ? { reason: "cancelled" as const } : {}),
   });
   return { accepted: true };
 }

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

@@ -2,11 +2,17 @@
  * Route handlers for attachment upload, download, and deletion.
  */
 import {
+  closeSync,
   copyFileSync,
   existsSync,
   mkdirSync,
+  openSync,
+  readFileSync,
+  readSync,
   realpathSync,
   statSync,
+  unlinkSync,
+  writeFileSync,
 } from "node:fs";
 import { join, resolve, sep } from "node:path";
 
@@ -26,6 +32,11 @@ import {
   getFilePathForAttachment,
   validateAttachmentUpload,
 } from "../../persistence/attachments-store.js";
+import {
+  isHeifImage,
+  jpegFilenameFor,
+  normalizeImageBytes,
+} from "../../util/image-conversion.js";
 import { getWorkspaceDir } from "../../util/platform.js";
 import { ACTOR_PRINCIPALS, LOCAL_PRINCIPALS } from "../auth/route-policy.js";
 import {
@@ -45,6 +56,18 @@ const MAX_UPLOAD_BODY_BYTES = 150 * 1024 * 1024;
 /** 100 MB — maximum file size for file-backed uploads (matches client memorySafetyLimit). */
 const MAX_FILE_BACKED_UPLOAD_BYTES = 100 * 1024 * 1024;
 
+/** Read the first `length` bytes of a file without loading the rest. */
+function readFileHead(path: string, length: number): Buffer {
+  const fd = openSync(path, "r");
+  try {
+    const head = Buffer.alloc(length);
+    const bytesRead = readSync(fd, head, 0, length, 0);
+    return head.subarray(0, bytesRead);
+  } finally {
+    closeSync(fd);
+  }
+}
+
 function resolveCanonicalPath(filePath: string): string {
   try {
     return realpathSync(filePath);
@@ -315,6 +338,8 @@ function handleJsonUpload(
 
   if (filePath && typeof filePath === "string" && (!data || data === "")) {
     let resolvedPath = resolveAllowedFileBackedAttachmentPath(filePath);
+    let storedFilename = filename;
+    let storedMimeType = mimeType;
 
     if (!resolvedPath) {
       const canonicalSource = resolveCanonicalPath(filePath);
@@ -335,8 +360,34 @@ function handleJsonUpload(
       );
       mkdirSync(workspaceAttachmentsDir, { recursive: true });
       const destFilename = `${Date.now()}-${filename.replace(/[^a-zA-Z0-9._-]/g, "_")}`;
-      const destPath = join(workspaceAttachmentsDir, destFilename);
+      let destPath = join(workspaceAttachmentsDir, destFilename);
       copyFileSync(canonicalSource, destPath);
+      // The staged copy is daemon-owned, so HEIF/HEIC content can be stored
+      // as a JPEG master without mutating the caller's file. Allowlisted
+      // in-place paths (recordings, conversation attachments) are registered
+      // verbatim — the daemon does not own those files. The head sniff keeps
+      // non-HEIF files (e.g. large videos) from being read into memory.
+      try {
+        if (isHeifImage(readFileHead(destPath, 12))) {
+          const norm = normalizeImageBytes(mimeType, readFileSync(destPath));
+          if (
+            norm.converted &&
+            norm.bytes.length <= MAX_FILE_BACKED_UPLOAD_BYTES
+          ) {
+            const convertedPath = join(
+              workspaceAttachmentsDir,
+              jpegFilenameFor(destFilename),
+            );
+            writeFileSync(convertedPath, norm.bytes);
+            unlinkSync(destPath);
+            destPath = convertedPath;
+            storedFilename = jpegFilenameFor(filename);
+            storedMimeType = norm.mimeType;
+          }
+        }
+      } catch {
+        // Conversion is best-effort; the raw copy is registered on failure.
+      }
       resolvedPath = resolveCanonicalPath(destPath);
     }
 
@@ -345,8 +396,8 @@ function handleJsonUpload(
     }
     const sizeBytes = statSync(resolvedPath).size;
     attachment = uploadFileBackedAttachment(
-      filename,
-      mimeType,
+      storedFilename,
+      storedMimeType,
       resolvedPath,
       sizeBytes,
     );

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

@@ -120,7 +120,6 @@ function handleRenderFromTraits({ body, headers }: RouteHandlerArgs) {
     }
   }
 
-  updateIdentityAvatarSection(null, log);
   publishAvatarChanged(headers?.["x-vellum-client-id"]?.trim() || undefined);
   return { ok: true };
 }
@@ -153,7 +152,6 @@ async function handleGenerateAvatar({ body, headers }: RouteHandlerArgs) {
   // character sidecars (traits + ASCII), and records an AI-sourced manifest.
   setImage(result.pngBuffer, "ai");
 
-  updateIdentityAvatarSection(null, log);
   publishAvatarChanged(headers?.["x-vellum-client-id"]?.trim() || undefined);
   return { ok: true, message: result.content };
 }
@@ -202,7 +200,6 @@ function handleUploadAvatarImage({ body, headers }: RouteHandlerArgs) {
   // character sidecars (traits + ASCII), and records an uploaded-image manifest.
   setImage(buffer, "upload");
 
-  updateIdentityAvatarSection(null, log);
   publishAvatarChanged(headers?.["x-vellum-client-id"]?.trim() || undefined);
   return { ok: true };
 }
@@ -235,7 +232,6 @@ function handleSetAvatar({ body, headers }: RouteHandlerArgs) {
   // recorded as an uploaded image atomically (no more stale both-files state).
   setImage(readFileSync(normalized), "upload");
 
-  updateIdentityAvatarSection(null, log);
   publishAvatarChanged(headers?.["x-vellum-client-id"]?.trim() || undefined);
   return { ok: true };
 }

package/src/runtime/routes/background-tool-routes.ts

@@ -11,8 +11,9 @@ import { z } from "zod";
 import {
   cancelBackgroundTool,
   listBackgroundTools,
+  listCompletedBackgroundTools,
 } from "../../tools/background-tool-registry.js";
-import { LOCAL_PRINCIPALS } from "../auth/route-policy.js";
+import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
 import { BadRequestError } from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
@@ -23,6 +24,7 @@ async function handleBackgroundToolList({
 }: RouteHandlerArgs) {
   const conversationId = queryParams.conversationId || undefined;
   const tools = listBackgroundTools(conversationId);
+  const completed = listCompletedBackgroundTools(conversationId);
 
   return {
     tools: tools.map((t) => ({
@@ -32,6 +34,20 @@ async function handleBackgroundToolList({
       command: t.command,
       startedAt: t.startedAt,
     })),
+    // Recently-completed tools let a client that missed the live completion
+    // event (chat unmounted / different conversation active) recover the
+    // terminal status on rehydration instead of wrongly retiring as cancelled.
+    completed: completed.map((t) => ({
+      id: t.id,
+      toolName: t.toolName,
+      conversationId: t.conversationId,
+      command: t.command,
+      startedAt: t.startedAt,
+      status: t.status,
+      exitCode: t.exitCode,
+      output: t.output,
+      completedAt: t.completedAt,
+    })),
   };
 }
 
@@ -55,14 +71,24 @@ const BackgroundToolSchema = z.object({
   startedAt: z.number(),
 });
 
+const CompletedBackgroundToolSchema = BackgroundToolSchema.extend({
+  status: z.enum(["completed", "failed", "cancelled"]),
+  exitCode: z.number().nullable(),
+  output: z.string(),
+  completedAt: z.number(),
+});
+
 export const ROUTES: RouteDefinition[] = [
   {
     operationId: "background_tool_list",
     endpoint: "background-tools",
     method: "GET",
+    // Read path for the chat UI's background-task rehydration, like the ACP
+    // `acp_list_sessions` route — so the web actor (not just a local CLI
+    // caller) can re-seed inline cards on reload.
     policy: {
-      requiredScopes: ["settings.read"],
-      allowedPrincipalTypes: LOCAL_PRINCIPALS,
+      requiredScopes: ["chat.read"],
+      allowedPrincipalTypes: ACTOR_PRINCIPALS,
     },
     handler: handleBackgroundToolList,
     summary: "List active background tools",
@@ -79,15 +105,18 @@ export const ROUTES: RouteDefinition[] = [
     ],
     responseBody: z.object({
       tools: z.array(BackgroundToolSchema),
+      completed: z.array(CompletedBackgroundToolSchema),
     }),
   },
   {
     operationId: "background_tool_cancel",
     endpoint: "background-tools/cancel",
     method: "POST",
+    // Write path for the inline card's Stop button, like ACP `acp_cancel` —
+    // the web actor cancels a running task it can see.
     policy: {
-      requiredScopes: ["settings.write"],
-      allowedPrincipalTypes: LOCAL_PRINCIPALS,
+      requiredScopes: ["chat.write"],
+      allowedPrincipalTypes: ACTOR_PRINCIPALS,
     },
     handler: handleBackgroundToolCancel,
     summary: "Cancel a background tool",

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

@@ -16,6 +16,11 @@ import { z } from "zod";
 
 import { getConfig } from "../../config/loader.js";
 import { getOrCreateConversation } from "../../daemon/conversation-store.js";
+import {
+  canonicalizeTimeZone,
+  formatTurnTimestamp,
+  resolveTurnTimezoneContext,
+} from "../../daemon/date-context.js";
 import { readNowScratchpad } from "../../daemon/now-scratchpad.js";
 import { getConversationByKey } from "../../persistence/conversation-key-store.js";
 import { getAllToolDefinitions } from "../../tools/registry.js";
@@ -64,6 +69,20 @@ async function handleBtw({
   }
 
   const trimmedContent = content.trim();
+  const config = getConfig();
+  const clientTimezone =
+    typeof body?.clientTimezone === "string"
+      ? canonicalizeTimeZone(body.clientTimezone)
+      : null;
+  const timezoneOptions = {
+    configuredUserTimeZone: config.ui?.userTimezone ?? null,
+    clientTimezone,
+    detectedTimezone: config.ui?.detectedTimezone ?? null,
+  };
+  const greetingCacheScope =
+    conversationKey === GREETING_KEY
+      ? resolveTurnTimezoneContext(timezoneOptions).effectiveTimezone
+      : null;
 
   // ----- Empty-state greeting fast-path -----
   // User-authored `## Greetings` win; otherwise replay a cached greeting when
@@ -76,7 +95,7 @@ async function handleBtw({
       log.debug("Returning authored empty-state greeting");
       return streamText(pickRandom(authored));
     }
-    const cached = getCachedEmptyStateGreeting();
+    const cached = getCachedEmptyStateGreeting(greetingCacheScope);
     if (cached) {
       log.debug("Returning cached empty-state greeting");
       return streamText(cached);
@@ -85,13 +104,18 @@ async function handleBtw({
 
   // ----- Greeting context enrichment -----
   let effectiveContent = trimmedContent;
+  if (conversationKey === GREETING_KEY) {
+    effectiveContent = `${effectiveContent}\n\n<turn_context>\ncurrent_time: ${formatTurnTimestamp(
+      timezoneOptions,
+    )}\n</turn_context>`;
+  }
   if (
     conversationKey === GREETING_KEY &&
-    getConfig().memory.retrieval.scratchpadInjection.enabled
+    config.memory.retrieval.scratchpadInjection.enabled
   ) {
     const now = readNowScratchpad();
     if (now) {
-      effectiveContent = `${trimmedContent}\n\n<context>\n${now}\n</context>`;
+      effectiveContent = `${effectiveContent}\n\n<context>\n${now}\n</context>`;
     }
   }
 
@@ -138,7 +162,7 @@ async function handleBtw({
 
           if (isGreeting && result.text) {
             // setCachedEmptyStateGreeting is a no-op when the TTL is 0.
-            setCachedEmptyStateGreeting(result.text);
+            setCachedEmptyStateGreeting(result.text, greetingCacheScope);
             log.debug("Cached empty-state greeting text");
           }
 
@@ -200,6 +224,10 @@ export const ROUTES: RouteDefinition[] = [
         .string()
         .describe("Conversation key to scope the call"),
       content: z.string().describe("User prompt content"),
+      clientTimezone: z
+        .string()
+        .optional()
+        .describe("IANA timezone reported by the active client"),
     }),
     handler: handleBtw,
   },