@vellumai/assistant 0.12.6 → 0.12.7-staging.1

package/src/channels/config.ts

@@ -99,6 +99,14 @@ const CHANNEL_POLICIES = {
       conversationStrategy: "continue_existing_conversation",
     },
   },
+  "vellum-shared": {
+    notification: {
+      // A shared conversation has no transport: the contact's own client
+      // reads replies over its connection, so there is nowhere to push to.
+      deliveryEnabled: false,
+      conversationStrategy: "not_deliverable",
+    },
+  },
 } as const satisfies Record<ChannelId, ChannelNotificationPolicy>;
 
 export type ChannelPolicies = typeof CHANNEL_POLICIES;

package/src/cli/lib/bundled-marketplace.json

@@ -148,6 +148,19 @@
         "ref": "2d293cdcb68af03d446b61a9915a0ee3dc842d4e"
       }
     },
+    {
+      "name": "contractor-photo-to-quote",
+      "description": "Turns job-site and equipment photos into standardized trade estimates and quotes in Jobber or QuickBooks with multi-tier Good/Better/Best options in 5 minutes.",
+      "category": "commerce",
+      "icon": "📸",
+      "license": "MIT",
+      "homepage": "https://github.com/ZeebBoyBlue/contractor-photo-to-quote",
+      "source": {
+        "source": "github",
+        "repo": "ZeebBoyBlue/contractor-photo-to-quote",
+        "ref": "6c136186faaf03bcf125d202f0b1f51f97d94544"
+      }
+    },
     {
       "name": "contractor-voice-invoicer",
       "description": "Converts 20-second truck voice memos and job photos into itemized client invoices with custom labor rates, material markups, and one-click accounting staging.",
@@ -474,6 +487,19 @@
       "license": "MIT",
       "icon": "\ud83d\udcac"
     },
+    {
+      "name": "quickbooks-expense-categorizer",
+      "description": "Scans uncategorized QuickBooks Online expenses and bank feeds, matches receipts, and stages categorized entries with confidence scoring for 1-click batch review.",
+      "category": "commerce",
+      "icon": "🧾",
+      "license": "MIT",
+      "homepage": "https://github.com/ZeebBoyBlue/quickbooks-expense-categorizer",
+      "source": {
+        "source": "github",
+        "repo": "ZeebBoyBlue/quickbooks-expense-categorizer",
+        "ref": "120776619698cc3e9490caf5c756465f5caaa6c2"
+      }
+    },
     {
       "name": "reading-pal",
       "source": {
@@ -500,6 +526,19 @@
         "ref": "f1905e639941e98172c5032b6d722f668882d75d"
       }
     },
+    {
+      "name": "shopify-payout-reconciler",
+      "description": "Unbundles lump-sum Shopify merchant bank deposits into gross sales, processor fees, customer refunds, shipping labels, and sales tax for penny-accurate QuickBooks reconciliation.",
+      "category": "commerce",
+      "icon": "🛍️",
+      "license": "MIT",
+      "homepage": "https://github.com/ZeebBoyBlue/shopify-payout-reconciler",
+      "source": {
+        "source": "github",
+        "repo": "ZeebBoyBlue/shopify-payout-reconciler",
+        "ref": "079fe0d86629686243a588cf3c4867d38d6ab8b8"
+      }
+    },
     {
       "name": "simple-memory",
       "source": {

package/src/config/composer-preferences.test.ts

@@ -0,0 +1,97 @@
+import {
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, test } from "bun:test";
+
+import {
+  ComposerPreferencesPatchSchema,
+  readComposerPreferences,
+  updateComposerPreferences,
+} from "./composer-preferences.js";
+
+const directories: string[] = [];
+function directory() {
+  const value = mkdtempSync(join(tmpdir(), "composer-preferences-"));
+  directories.push(value);
+  return value;
+}
+afterEach(() => {
+  for (const path of directories.splice(0)) {
+    rmSync(path, { recursive: true, force: true });
+  }
+});
+describe("composer preferences", () => {
+  test("new users retain the assistant defaults", () => {
+    expect(readComposerPreferences("user-1", directory())).toEqual({
+      favoriteModeIds: [],
+      lastModeId: null,
+      lastAutonomy: null,
+    });
+  });
+  test("partial updates preserve unrelated choices and isolate users", () => {
+    const root = directory();
+    updateComposerPreferences(
+      "user-1",
+      { lastModeId: "quality-optimized", lastAutonomy: "low" },
+      root,
+    );
+    const patch = ComposerPreferencesPatchSchema.safeParse({
+      favoriteModeIds: ["balanced"],
+    });
+    expect(patch.success).toBe(true);
+    if (!patch.success) {
+      throw patch.error;
+    }
+    const result = updateComposerPreferences("user-1", patch.data, root);
+    expect(result.lastModeId).toBe("quality-optimized");
+    expect(result.lastAutonomy).toBe("low");
+    expect(result.favoriteModeIds).toEqual(["balanced"]);
+    expect(readComposerPreferences("user-2", root).lastModeId).toBeNull();
+  });
+  test("rejects invalid thresholds, excess favorites, and foreign fields", () => {
+    for (const value of [
+      { lastAutonomy: "unrestricted" },
+      { favoriteModeIds: ["1", "2", "3", "4", "5", "6"] },
+      { principalId: "user-2" },
+    ]) {
+      expect(ComposerPreferencesPatchSchema.safeParse(value).success).toBe(
+        false,
+      );
+    }
+  });
+  test("deduplicates favorites and leaves no temporary files", () => {
+    const root = directory();
+    expect(
+      updateComposerPreferences(
+        "../../user-1",
+        { favoriteModeIds: ["a", "a", "b"] },
+        root,
+      ).favoriteModeIds,
+    ).toEqual(["a", "b"]);
+    expect(readdirSync(join(root, "composer-preferences"))).toHaveLength(1);
+  });
+  test("does not overwrite corrupt preferences on a failed update", () => {
+    const root = directory();
+    updateComposerPreferences("user-1", {}, root);
+    const path = join(
+      root,
+      "composer-preferences",
+      readdirSync(join(root, "composer-preferences"))[0]!,
+    );
+    writeFileSync(path, '{"lastAutonomy":"invalid"}');
+    expect(() =>
+      updateComposerPreferences(
+        "user-1",
+        { favoriteModeIds: ["balanced"] },
+        root,
+      ),
+    ).toThrow();
+    expect(readFileSync(path, "utf8")).toBe('{"lastAutonomy":"invalid"}');
+  });
+});

package/src/config/composer-preferences.ts

@@ -0,0 +1,95 @@
+import { createHash, randomUUID } from "node:crypto";
+import {
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+
+import { z } from "zod";
+
+import { getDataDir } from "../util/platform.js";
+
+export const ComposerPreferencesSchema = z.object({
+  favoriteModeIds: z.array(z.string().min(1).max(200)).max(5).default([]),
+  lastModeId: z.string().min(1).max(200).nullable().default(null),
+  lastAutonomy: z
+    .enum(["none", "low", "medium", "high"])
+    .nullable()
+    .default(null),
+});
+
+export const ComposerPreferencesPatchSchema = z
+  .object({
+    favoriteModeIds:
+      ComposerPreferencesSchema.shape.favoriteModeIds.removeDefault(),
+    lastModeId: ComposerPreferencesSchema.shape.lastModeId.removeDefault(),
+    lastAutonomy: ComposerPreferencesSchema.shape.lastAutonomy.removeDefault(),
+  })
+  .partial()
+  .strict();
+export type ComposerPreferences = z.infer<typeof ComposerPreferencesSchema>;
+export type ComposerPreferencesPatch = z.infer<
+  typeof ComposerPreferencesPatchSchema
+>;
+
+function preferencesPath(principalId: string, dataDir: string): string {
+  const key = createHash("sha256").update(principalId).digest("hex");
+  return join(dataDir, "composer-preferences", `${key}.json`);
+}
+
+export function readComposerPreferences(
+  principalId: string,
+  dataDir = getDataDir(),
+): ComposerPreferences {
+  let content: string;
+  try {
+    content = readFileSync(preferencesPath(principalId, dataDir), "utf8");
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return ComposerPreferencesSchema.parse({});
+    }
+    throw error;
+  }
+  const parsed = ComposerPreferencesSchema.safeParse(JSON.parse(content));
+  if (!parsed.success) {
+    throw new Error("Stored composer preferences are invalid", {
+      cause: parsed.error,
+    });
+  }
+  return parsed.data;
+}
+
+export function updateComposerPreferences(
+  principalId: string,
+  patch: ComposerPreferencesPatch,
+  dataDir = getDataDir(),
+): ComposerPreferences {
+  const parsed = ComposerPreferencesSchema.safeParse({
+    ...readComposerPreferences(principalId, dataDir),
+    ...patch,
+  });
+  if (!parsed.success) {
+    throw new Error("Invalid composer preferences", { cause: parsed.error });
+  }
+  const preferences = {
+    ...parsed.data,
+    favoriteModeIds: [...new Set(parsed.data.favoriteModeIds)],
+  };
+  const directory = join(dataDir, "composer-preferences");
+  mkdirSync(directory, { recursive: true });
+  const path = preferencesPath(principalId, dataDir);
+  const temporaryPath = `${path}.${randomUUID()}.tmp`;
+  try {
+    writeFileSync(temporaryPath, JSON.stringify(preferences), {
+      mode: 0o600,
+      flag: "wx",
+    });
+    renameSync(temporaryPath, path);
+  } finally {
+    rmSync(temporaryPath, { force: true });
+  }
+  return preferences;
+}

package/src/config/feature-flag-registry.json

@@ -146,6 +146,14 @@
       "description": "Auto-expand completed tool call step groups instead of showing them collapsed",
       "defaultEnabled": false
     },
+    {
+      "id": "quiet-turn-activity",
+      "scope": "client",
+      "key": "quiet-turn-activity",
+      "label": "Quiet Turn Activity",
+      "description": "While the assistant works, show a reply skeleton with one line naming where it is working instead of its intermediate text and steps; a settled turn shows only its opening line and its answer, with the steps behind a Worked summary in the message footer",
+      "defaultEnabled": false
+    },
     {
       "id": "inline-assistant-intermediates",
       "scope": "client",
@@ -560,14 +568,6 @@
       "description": "Streams an interactive virtual desktop from a platform-hosted, containerized assistant over /v1/desktop/stream. Requires platform hosting; self-hosted assistants are excluded. Off: the virtual desktop is hidden. On: the chat header offers its viewer and controls.",
       "defaultEnabled": false
     },
-    {
-      "id": "assistant-inbox",
-      "scope": "client",
-      "key": "assistant-inbox",
-      "label": "Assistant Inbox",
-      "description": "Shows an Assistant Inbox entry above Preferences in the web sidebar and the /assistant/inbox page it opens: a mailbox for the assistant's managed vellum.me address (received and sent, with a reading pane), the inline email setup card for entitled orgs with no address yet, and an upgrade card for orgs without the managed_email entitlement. With it on, email setup happens only there: the billing wizard hands off to the inbox instead of its own domain step, the billing page's finish-setup nudge gives way to the inbox's rail entry, and the Channels page's Email section points there instead of registering an address itself. Off hides the entry, redirects the route to chat, and keeps the older setup surfaces.",
-      "defaultEnabled": false
-    },
     {
       "id": "sidebar-done",
       "scope": "both",
@@ -575,6 +575,14 @@
       "label": "Sidebar Done",
       "description": "Turns archiving a chat into marking it done: the sidebar row carries a Done check instead of the overflow menu, an All chats page lists the full history, and done chats stay findable in search by default. Off keeps today's Archive wording, the overflow menu, and search that hides archived rows unless the query asks for them.",
       "defaultEnabled": false
+    },
+    {
+      "id": "vellum-trusted-contacts",
+      "scope": "both",
+      "key": "vellum-trusted-contacts",
+      "label": "Vellum Trusted Contacts",
+      "description": "Lets a guardian give another person access to talk to their assistant in the Vellum UI as a trusted contact. Gates contact-role token minting in the gateway, trusted-contact trust resolution for `vellum` channel principals, and the assistant's trusted-contact route allowlist. Off: none of those surfaces admit a contact, and the assistant stays reachable only by its guardian.",
+      "defaultEnabled": false
     }
   ]
 }

package/src/config/schemas/llm.ts

@@ -74,6 +74,7 @@ export const KNOWN_LLM_PROVIDERS = [
   "litellm",
   "opencode",
   "baseten",
+  "ionet",
   "poolside",
   "typesafe",
   // Routing identities: "vellum" = the platform-managed route (upstream

package/src/contacts/types.ts

@@ -74,4 +74,5 @@ export type ChannelType =
   | "phone"
   | "telegram"
   | "discord"
+  | "vellum-shared"
   | "other";

package/src/daemon/conversation-agent-loop-handlers.ts

@@ -107,6 +107,7 @@ import { faviconUrlForDomain } from "../util/favicon.js";
 import { redactLogString } from "../util/log-redact.js";
 import { getLogger } from "../util/logger.js";
 import { withSqliteRetry } from "../util/sqlite-retry.js";
+import { safeStringSlice } from "../util/unicode.js";
 import type { DirectiveRequest } from "./assistant-attachments.js";
 import {
   cleanAssistantContent,
@@ -640,6 +641,8 @@ export interface EventHandlerState {
    * rather than on every delta.
    */
   readonly surfacePendingScannedToolUseIds: Set<string>;
+  /** App previews whose cumulative JSON reached the client payload cap. */
+  readonly cappedAppPreviewToolUseIds: Set<string>;
   /**
    * In-flight priming of {@link liveRevealGuardEntries}. The dispatcher
    * awaits this before processing a `text_delta` (and before the
@@ -777,6 +780,7 @@ export function createEventHandlerState(): EventHandlerState {
     forChatMintWatermark: currentForChatMintWatermark(),
     stagedRevealIdentities: new Set(),
     surfacePendingScannedToolUseIds: new Set(),
+    cappedAppPreviewToolUseIds: new Set(),
     liveRevealGuardPriming: undefined,
   };
 }
@@ -1411,6 +1415,7 @@ function schedulePartialFlush(
 // tools the client discards it (extractCodePreview only handles app tools),
 // so we skip forwarding entirely to avoid transport/decode overhead.
 const APP_TOOL_NAMES = new Set(["app_create"]);
+const APP_INPUT_PREVIEW_CHAR_LIMIT = 256_000;
 
 // ── Surface Placeholder Detection ────────────────────────────────────
 // A `visual` ui_show streams the longest tool input the model produces, and
@@ -2111,13 +2116,24 @@ export function handleInputJsonDelta(
   // Only forward input deltas for app tools — the client only uses this
   // stream for app_create code previews. Non-app tools would send large
   // cumulative JSON on every delta with no benefit.
-  if (!APP_TOOL_NAMES.has(event.toolName)) {
+  if (
+    !APP_TOOL_NAMES.has(event.toolName) ||
+    state.cappedAppPreviewToolUseIds.has(event.toolUseId)
+  ) {
     return;
   }
+  const content = safeStringSlice(
+    event.accumulatedJson,
+    0,
+    APP_INPUT_PREVIEW_CHAR_LIMIT,
+  );
+  if (content.length < event.accumulatedJson.length) {
+    state.cappedAppPreviewToolUseIds.add(event.toolUseId);
+  }
   deps.onEvent({
     type: "tool_input_delta",
     toolName: event.toolName,
-    content: event.accumulatedJson,
+    content,
     conversationId: deps.ctx.conversationId,
     toolUseId: event.toolUseId,
     messageId: state.lastAssistantMessageId,

package/src/daemon/conversation-agent-loop.ts

@@ -44,6 +44,7 @@ import { isSendUserMessageActiveForTurn } from "../config/send-user-message-gate
 import { desktopAutomationLease } from "../desktop/desktop-automation-lease.js";
 import { writeRelationshipState } from "../home/relationship-state-writer.js";
 import type { UserPromptSubmitInputContext } from "../hooks/types.js";
+import type { SupportedLocale } from "../i18n/index.js";
 import {
   addMessage,
   deleteMessageById,
@@ -500,6 +501,7 @@ export async function runAgentLoopImpl(
      * loop defaults to `'mainAgent'` for user-initiated turns.
      */
     callSite?: LLMCallSite;
+    locale?: SupportedLocale;
     /** Skip fresh retrieval while keeping resident memory and static context. */
     skipMemoryRetrieval?: boolean;
     /**
@@ -1719,6 +1721,7 @@ export async function runAgentLoopImpl(
           onCheckpoint,
           callSite: turnCallSite,
           inferenceCallSite,
+          locale: options?.locale,
           suppressAssistantText: sendUserMessageActive,
           supportsDynamicUi: conversationSupportsDynamicUi(ctx),
           trust: loopTrust,

package/src/daemon/conversation-messaging.ts

@@ -26,6 +26,7 @@ import {
   parseInterfaceId,
 } from "../channels/types.js";
 import { parseImageDimensions } from "../context/image-dimensions.js";
+import type { SupportedLocale } from "../i18n/index.js";
 import {
   type ProviderMessageMetadata,
   providerMessageMetadataSchema,
@@ -824,6 +825,7 @@ export interface EnqueueMessageOptions {
   currentPage?: string;
   metadata?: Record<string, unknown>;
   isInteractive?: boolean;
+  locale?: SupportedLocale;
   displayContent?: string;
   transport?: ConversationTransportMetadata;
   clientMessageId?: string;
@@ -873,6 +875,7 @@ export function enqueueMessage(
     currentPage,
     metadata,
     isInteractive,
+    locale,
     displayContent,
     transport,
     clientMessageId,
@@ -912,6 +915,7 @@ export function enqueueMessage(
     turnChannelContext,
     turnInterfaceContext,
     isInteractive,
+    locale,
     sourceActorPrincipalId,
     authContext: queuedAuthContext,
     trustContext: queuedTrustContext,

package/src/daemon/conversation-process.ts

@@ -20,6 +20,7 @@ import {
   type TurnInterfaceContext,
 } from "../channels/types.js";
 import type { LLMCallSite } from "../config/schemas/llm.js";
+import type { SupportedLocale } from "../i18n/index.js";
 import { extractPreferences } from "../notifications/preference-extractor.js";
 import { createPreference } from "../notifications/preferences-store.js";
 import {
@@ -1278,6 +1279,7 @@ async function drainSingleMessage(
     titleText?: string;
     isHiddenPrompt?: boolean;
     turnTrustContext?: TrustContext;
+    locale?: SupportedLocale;
     cronRunId?: string | null;
   } = {
     isUserMessage: true,
@@ -1289,6 +1291,9 @@ async function drainSingleMessage(
   if (next.isInteractive !== undefined) {
     drainLoopOptions.isInteractive = next.isInteractive;
   }
+  if (next.locale !== undefined) {
+    drainLoopOptions.locale = next.locale;
+  }
   if (agentLoopContent !== resolvedContent) {
     drainLoopOptions.titleText = resolvedContent;
   }
@@ -1797,6 +1802,7 @@ async function drainBatch(
     isHiddenPrompt?: boolean;
     notifyUserMessageId?: string;
     turnTrustContext?: TrustContext;
+    locale?: SupportedLocale;
     cronRunId?: string | null;
   } = {
     isUserMessage: true,
@@ -1816,6 +1822,9 @@ async function drainBatch(
   if (lastSuccessfulBatchEntry?.isInteractive !== undefined) {
     drainLoopOptions.isInteractive = lastSuccessfulBatchEntry.isInteractive;
   }
+  if (lastSuccessfulBatchEntry?.locale !== undefined) {
+    drainLoopOptions.locale = lastSuccessfulBatchEntry.locale;
+  }
   // A batch counts as a hidden turn only when every message in it is a
   // hidden machine signal — one genuine user prompt justifies the
   // prompt-as-user-speech consumers (title generation).
@@ -1871,6 +1880,7 @@ export interface ProcessMessageOptions {
   currentPage?: string;
   isInteractive?: boolean;
   callSite?: LLMCallSite;
+  locale?: SupportedLocale;
   /**
    * Optional ad-hoc inference-profile override applied to every LLM call
    * this turn issues (e.g. a schedule's pinned profile). Forwarded to
@@ -1928,6 +1938,7 @@ export async function processMessage(
     currentPage,
     isInteractive,
     callSite,
+    locale,
     overrideProfile,
     displayContent,
     sourceActorPrincipalId,
@@ -2451,6 +2462,7 @@ export async function processMessage(
     isUserMessage?: boolean;
     titleText?: string;
     callSite?: LLMCallSite;
+    locale?: SupportedLocale;
     overrideProfile?: string;
     turnTrustContext?: TrustContext;
   } = {
@@ -2471,6 +2483,9 @@ export async function processMessage(
   if (callSite !== undefined) {
     loopOptions.callSite = callSite;
   }
+  if (locale !== undefined) {
+    loopOptions.locale = locale;
+  }
   if (overrideProfile !== undefined) {
     loopOptions.overrideProfile = overrideProfile;
   }

package/src/daemon/conversation-queue-manager.ts

@@ -10,6 +10,7 @@ import type {
   TurnChannelContext,
   TurnInterfaceContext,
 } from "../channels/types.js";
+import type { SupportedLocale } from "../i18n/index.js";
 import type { AuthContext } from "../runtime/auth/types.js";
 import { getLogger } from "../util/logger.js";
 import type { UserMessageAttachment } from "./message-protocol.js";
@@ -30,6 +31,7 @@ export interface QueuedMessage {
   turnInterfaceContext?: TurnInterfaceContext;
   /** When false, the turn has no interactive user and should skip clarification prompts. */
   isInteractive?: boolean;
+  locale?: SupportedLocale;
   /** Requester identity captured from the verified auth context at enqueue time. */
   sourceActorPrincipalId?: string;
   /** Full auth snapshot captured at enqueue time for turn-scoped authorization decisions. */

package/src/daemon/conversation.ts

@@ -44,6 +44,7 @@ import {
   derefToolResultReReads,
   postTurnTruncateToolResults,
 } from "../context/post-turn-tool-result-truncation.js";
+import type { SupportedLocale } from "../i18n/index.js";
 import { readProviderMetadata } from "../messaging/read-provider-metadata.js";
 import { isGuardianCardRow } from "../notifications/approval-card-data.js";
 import { PermissionPrompter } from "../permissions/prompter.js";
@@ -3528,6 +3529,7 @@ export class Conversation {
        */
       replyDeliveredInAppOnly?: boolean;
       callSite?: LLMCallSite;
+      locale?: SupportedLocale;
       /** Skip fresh retrieval while keeping resident memory and static context. */
       skipMemoryRetrieval?: boolean;
       /** Provider configuration source when distinct from turn semantics. */

package/src/daemon/handlers/shared.ts

@@ -19,6 +19,10 @@ import type {
 import { ConfirmationDecisionSchema } from "../../api/responses/conversation-message.js";
 import { getConfig } from "../../config/loader.js";
 import type { LLMCallSite, Speed } from "../../config/schemas/llm.js";
+import {
+  resolveStoredMessageText,
+  type SupportedLocale,
+} from "../../i18n/index.js";
 import { ipcCall as gatewayIpcCall } from "../../ipc/gateway-client.js";
 import type { ProviderMessageMetadata } from "../../messaging/provider-message-metadata.js";
 import type { SecretPromptResult } from "../../permissions/secret-prompt-types.js";
@@ -409,6 +413,7 @@ export function renderHistoryContent(
   >,
   messageId?: string,
   metadata?: unknown,
+  locale?: SupportedLocale,
 ): RenderedHistoryContent {
   // A row whose turn routed its reply through `send_user_message` carries
   // private working notes, so every consumer of this render (web history,
@@ -575,8 +580,14 @@ export function renderHistoryContent(
       const rawText =
         typeof block._redactionVersion === "number" &&
         block._redactionVersion >= SENTINEL_REDACTION_VERSION
-          ? block.text
-          : neutralizeRedactedSentinels(block.text);
+          ? locale
+            ? resolveStoredMessageText(block.text, locale)
+            : block.text
+          : neutralizeRedactedSentinels(
+              locale
+                ? resolveStoredMessageText(block.text, locale)
+                : block.text,
+            );
       const displayText = unwrapExternalContentForDisplay(rawText);
       // Skip empty/whitespace-only text blocks. During streaming the client
       // discards empty text deltas (guard !text.isEmpty), so including them

package/src/daemon/message-types/sync.ts

@@ -11,6 +11,7 @@ export const SYNC_TAGS = {
   assistantAvatar: "assistant:self:avatar",
   assistantIdentity: "assistant:self:identity",
   assistantConfig: "assistant:self:config",
+  assistantComposerPreferences: "assistant:self:composerPreferences",
   assistantSounds: "assistant:self:sounds",
   assistantSchedules: "assistant:self:schedules",
   assistantDesktop: "assistant:self:desktop",

package/src/daemon/process-message.ts

@@ -19,6 +19,7 @@ import {
   parseChannelId,
   parseInterfaceId,
 } from "../channels/types.js";
+import type { SupportedLocale } from "../i18n/index.js";
 import { resolveAttachmentsForPersist } from "../persistence/attachments-store.js";
 import {
   addMessage,
@@ -88,6 +89,8 @@ type ProcessMessageOptions = ConversationCreateOptions & {
   sourceChannel?: string;
   /** Originating interface (e.g. "cli", "web"). Defaults to "web". */
   sourceInterface?: string;
+  /** Locale for daemon-authored text emitted during this turn. */
+  locale?: SupportedLocale;
   /**
    * Origin tag of the turn (the conversation's `TitleOrigin`, e.g.
    * "memory_consolidation"), threaded from `runBackgroundJob`. Propagated
@@ -780,6 +783,7 @@ export async function processMessage(
       onEvent: emitEvent,
       isInteractive: options?.isInteractive ?? false,
       isUserMessage: true,
+      locale: options?.locale,
       ...(options?.callSite ? { callSite: options.callSite } : {}),
       ...(options?.overrideProfile
         ? { overrideProfile: options.overrideProfile }
@@ -854,6 +858,7 @@ export async function processMessageInBackground(
       onEvent: emitEvent,
       isInteractive: options?.isInteractive ?? false,
       isUserMessage: true,
+      locale: options?.locale,
       ...(options?.callSite ? { callSite: options.callSite } : {}),
       ...(options?.overrideProfile
         ? { overrideProfile: options.overrideProfile }

package/src/i18n/__tests__/i18n.test.ts

@@ -8,6 +8,7 @@ import {
   MESSAGE_KEYS,
   negotiateLocale,
   resolveConversationTitle,
+  resolveStoredMessageText,
   SUPPORTED_LOCALES,
   t,
 } from "../index.js";
@@ -103,6 +104,30 @@ describe("resolveConversationTitle", () => {
   });
 });
 
+describe("resolveStoredMessageText", () => {
+  test("resolves exact stored keys while preserving surrounding whitespace", () => {
+    expect(
+      resolveStoredMessageText(
+        `\n\n${MESSAGE_KEYS.AGENT_LOOP_UNPARSEABLE_TOOL_RETRY_STOP}`,
+        "es",
+      ),
+    ).toBe(
+      `\n\n${
+        MESSAGE_CATALOGS.es[MESSAGE_KEYS.AGENT_LOOP_UNPARSEABLE_TOOL_RETRY_STOP]
+      }`,
+    );
+  });
+
+  test("passes legacy and ordinary display text through", () => {
+    const legacy =
+      "I stopped after repeated malformed tool calls to keep this conversation from growing indefinitely. Please try again, or switch models if the problem continues.";
+    expect(resolveStoredMessageText(legacy, "es")).toBe(legacy);
+    expect(resolveStoredMessageText("ordinary assistant text", "zh")).toBe(
+      "ordinary assistant text",
+    );
+  });
+});
+
 describe("isMessageKey", () => {
   test("recognizes catalog keys only", () => {
     expect(isMessageKey(MESSAGE_KEYS.CONVERSATION_TITLE_UNTITLED)).toBe(true);