@vellumai/assistant 0.12.3 → 0.12.4-staging.2

package/src/config/default-profile-catalog.ts

@@ -15,12 +15,14 @@ import {
   type DefaultProfileKey,
   type DefaultProfileProvider,
   FALLBACK_PROFILE_BY_KEY,
-  isBackupProfileKey,
   isDefaultProfileKey,
   isDefaultProfileProvider,
+  isManagedOnlyProfileKey,
+  JEV_MANAGED_PROFILE_KEY,
   OS_BETA_PROFILE_KEY,
 } from "./default-profile-names.js";
 import { resolveDefaultConnectionName } from "./default-provider-resolution.js";
+import { profileSupportsTextGeneration } from "./profile-text-generation.js";
 import {
   backupProfilesResolveUnderDefaultProvider,
   DEFAULT_CONTEXT_WINDOW_MAX_INPUT_TOKENS,
@@ -385,18 +387,39 @@ export const PROFILE_IMPLS: Record<
   Record<DefaultProfileProvider, DefaultProfileTemplate>
 >;
 
+/**
+ * The managed Jev profile: TypeSafe's System One decision model through the
+ * platform proxy. Managed column only, because the platform is the only
+ * route the catalog offers for it here, and never a conversation profile,
+ * because `jev-latest` returns structured answers rather than chat text
+ * (`supportsText: false` on the `typesafe` catalog entry). Its budget is
+ * TypeSafe's published request limit rather than the default context window.
+ */
+export const JEV_MANAGED_PROFILE_TEMPLATE: DefaultProfileTemplate = {
+  model: "jev-latest",
+  provider: "vellum",
+  source: "managed",
+  label: "Jev",
+  description:
+    "TypeSafe decision model for yes/no verdicts, for the voice judges and memory selection",
+  maxTokens: 4096,
+  thinking: { enabled: false, streamThinking: false },
+  contextWindow: { maxInputTokens: 32_000 },
+};
+
 /**
  * Managed profiles, i.e. the `vellum` column keyed by profile name, plus the
- * managed backup profiles. Backups come after the primaries, which is what
- * places them after the primaries in the seeded `profileOrder`: the seeder
- * inserts missing managed keys in this record's order. Keyed by the
- * user-facing defaults only: an internal profile is code-resolved and never
- * listed or ordered.
+ * managed backup profiles and the managed Jev profile. Backups come after the
+ * primaries, which is what places them after the primaries in the seeded
+ * `profileOrder`: the seeder inserts missing managed keys in this record's
+ * order. Keyed by the user-facing defaults only: an internal profile is
+ * code-resolved and never listed or ordered.
  */
 export const MANAGED_PROFILE_TEMPLATES: Record<string, DefaultProfileTemplate> =
   Object.fromEntries([
     ...DEFAULT_PROFILE_KEYS.map((key) => [key, PROFILE_IMPLS[key].vellum]),
     ...BACKUP_PROFILE_KEYS.map((key) => [key, BACKUP_PROFILE_IMPLS[key]]),
+    [JEV_MANAGED_PROFILE_KEY, JEV_MANAGED_PROFILE_TEMPLATE],
   ]);
 
 /**
@@ -484,6 +507,9 @@ export const OS_BETA_PROFILE_TEMPLATE: DefaultProfileTemplate = {
 export const CODE_OWNED_PROFILE_NAMES = new Set<string>([
   "latency-optimized",
   ...BACKUP_PROFILE_KEYS,
+  // A shadow could repoint the judges at a chat model, which answers a
+  // yes/no question with prose the verdict parser cannot read.
+  JEV_MANAGED_PROFILE_KEY,
 ]);
 
 // All managed profiles, including the flag-gated os-beta, are invariant:
@@ -494,6 +520,7 @@ export const CODE_OWNED_PROFILE_NAMES = new Set<string>([
 export const INVARIANT_PROFILE_NAMES = new Set<string>([
   ...DEFAULT_PROFILE_KEYS,
   ...BACKUP_PROFILE_KEYS,
+  JEV_MANAGED_PROFILE_KEY,
   OS_BETA_PROFILE_KEY,
 ]);
 
@@ -507,6 +534,7 @@ export const INVARIANT_PROFILE_NAMES = new Set<string>([
 export const MANAGED_PROFILE_NAMES = new Set<string>([
   ...DEFAULT_PROFILE_KEYS,
   ...BACKUP_PROFILE_KEYS,
+  JEV_MANAGED_PROFILE_KEY,
   OS_BETA_PROFILE_KEY,
 ]);
 
@@ -590,6 +618,19 @@ for (const key of BACKUP_PROFILE_KEYS) {
   }
 }
 
+// The managed Jev profile pins a model the platform proxy must front, and the
+// judges depend on it being the non-text TypeSafe model rather than a chat
+// model that happens to share the id.
+if (
+  getManagedUpstream(JEV_MANAGED_PROFILE_TEMPLATE.model ?? "") !== "typesafe"
+) {
+  throw new Error(
+    `JEV_MANAGED_PROFILE_TEMPLATE references model "${JEV_MANAGED_PROFILE_TEMPLATE.model ?? ""}" ` +
+      `which the managed route does not serve through typesafe. ` +
+      `Update model-catalog.ts, platform-proxy/constants.ts, or default-profile-catalog.ts.`,
+  );
+}
+
 // Provider choices without a named column materialize from the shared BYOK
 // templates; verify each one's resolved model lands in the catalog.
 for (const provider of DEFAULT_PROVIDER_CHOICES) {
@@ -621,6 +662,10 @@ function buildDefaultProfileEntries(): Record<string, ProfileEntry> {
     const impl = BACKUP_PROFILE_IMPLS[key];
     entries[key] = materializeProfile(impl, impl.provider);
   }
+  entries[JEV_MANAGED_PROFILE_KEY] = materializeProfile(
+    JEV_MANAGED_PROFILE_TEMPLATE,
+    JEV_MANAGED_PROFILE_TEMPLATE.provider,
+  );
   entries[OS_BETA_PROFILE_KEY] = materializeProfile(
     OS_BETA_PROFILE_TEMPLATE,
     OS_BETA_PROFILE_TEMPLATE.provider,
@@ -697,12 +742,13 @@ function resolveAgainstBody(
   if (body == null) {
     // A managed stub is the workspace's slot for a code-owned profile, never
     // a profile of its own, so with no body behind it there is nothing to
-    // resolve. Only a backup name reaches this branch with a stub (the
-    // default keys always have a body), and it reaches it on the columns
-    // where the backups do not exist. Resolving to the stub would list a
-    // profile with no provider or model and let a reference to it look
-    // valid, which is precisely what `LLMSchema` rejects on those columns.
-    if (isBackupProfileKey(name) && workspace?.source === "managed") {
+    // resolve. Only a managed-only name (a backup, the Jev profile) reaches
+    // this branch with a stub (the default keys always have a body), and it
+    // reaches it on the columns where those profiles do not exist. Resolving
+    // to the stub would list a profile with no provider or model and let a
+    // reference to it look valid, which is precisely what `LLMSchema` rejects
+    // on those columns.
+    if (isManagedOnlyProfileKey(name) && workspace?.source === "managed") {
       return undefined;
     }
     return workspace;
@@ -787,14 +833,14 @@ function defaultProfileBodyForProvider(
   defaultProvider: DefaultProviderConfig | null,
 ): ProfileEntry | undefined {
   if (!isDefaultProfileKey(name)) {
-    // Backup profiles are companions of the managed (`vellum`) column only:
-    // under a BYOK or chatgpt default provider the primaries carry no
-    // `fallbackProfile` pointers, and the backups must not materialize
-    // either, since the install may hold no credential for the backup's
+    // Backup profiles and the managed Jev profile exist on the managed
+    // (`vellum`) column only: under a BYOK or chatgpt default provider the
+    // primaries carry no `fallbackProfile` pointers, and neither may
+    // materialize, since the install may hold no credential for their
     // provider. A null defaultProvider predates `llm.defaultProvider` and
-    // resolves to the managed column, so it keeps its backups.
+    // resolves to the managed column, so it keeps them.
     if (
-      isBackupProfileKey(name) &&
+      isManagedOnlyProfileKey(name) &&
       !backupProfilesResolveUnderDefaultProvider(defaultProvider)
     ) {
       return undefined;
@@ -923,3 +969,27 @@ export function getUserSelectableProfilesForProvider(
   }
   return selectable;
 }
+
+/**
+ * The profiles a conversation can run on: the user-selectable view minus any
+ * profile whose model returns structured answers rather than chat text (the
+ * managed Jev profile). Every surface that picks or validates a conversation
+ * profile (the `/model` command, a per-conversation pin, the plugin and
+ * workflow listings) reads this view; the call-site override pickers keep
+ * the wider selectable view, since the verdict sites are what Jev is for.
+ */
+export function getConversationProfilesForProvider(
+  workspaceProfiles: Record<string, ProfileEntry> | undefined,
+  defaultProvider: DefaultProviderConfig | null,
+): Record<string, ProfileEntry> {
+  const selectable = getUserSelectableProfilesForProvider(
+    workspaceProfiles,
+    defaultProvider,
+  );
+  for (const [name, entry] of Object.entries(selectable)) {
+    if (!profileSupportsTextGeneration(entry, selectable)) {
+      delete selectable[name];
+    }
+  }
+  return selectable;
+}

package/src/config/default-profile-names.ts

@@ -67,6 +67,41 @@ export function isBackupProfileKey(value: string): value is BackupProfileKey {
   return (BACKUP_PROFILE_KEYS as readonly string[]).includes(value);
 }
 
+/**
+ * Managed profile for the TypeSafe decision model (Jev). Deliberately NOT
+ * part of `DEFAULT_PROFILE_KEYS`: it has no BYOK column, because the
+ * platform serves Jev only through the managed route, and its model returns
+ * structured answers rather than chat text, so it can never be the active
+ * or conversation profile. It exists as a pin target for the call sites
+ * that consume a yes/no verdict (the voice judges, the memory selector).
+ */
+export const JEV_MANAGED_PROFILE_KEY = "jev-managed";
+
+/**
+ * The call sites that consume a structured verdict and so may be pinned to
+ * the Jev profile. Every other site expects chat text or a tool call, which
+ * the decision model never produces.
+ */
+export const JEV_MANAGED_PROFILE_CALL_SITES = [
+  "voiceEscalationJudge",
+  "voiceContinuationJudge",
+  "memoryV3SelectL2",
+] as const;
+
+/**
+ * Keys whose profile exists on the managed (`vellum`) column only: the
+ * backups and the Jev profile. Under a BYOK or ChatGPT default provider
+ * these names have no body to resolve to.
+ */
+export const MANAGED_ONLY_PROFILE_KEYS = [
+  ...BACKUP_PROFILE_KEYS,
+  JEV_MANAGED_PROFILE_KEY,
+] as const;
+
+export function isManagedOnlyProfileKey(value: string): boolean {
+  return (MANAGED_ONLY_PROFILE_KEYS as readonly string[]).includes(value);
+}
+
 /**
  * Flag-gated default profile: only available while the `os-beta` feature
  * flag has reconciled it into the workspace (see `sync-gated-profiles.ts`).

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

@@ -170,14 +170,6 @@
       "description": "Enable Anthropic fast mode for Opus models (4.6, 4.7, 4.8), delivering up to 2.5x higher output tokens per second at premium pricing",
       "defaultEnabled": false
     },
-    {
-      "id": "teleport",
-      "scope": "client",
-      "key": "teleport",
-      "label": "Teleport",
-      "description": "Enable the local-to-platform teleport UI in General settings. Platform-to-local teleport is GA and not gated by this flag",
-      "defaultEnabled": false
-    },
     {
       "id": "apple-container",
       "scope": "client",
@@ -559,6 +551,14 @@
       "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. Off hides the entry and redirects the route to chat.",
       "defaultEnabled": false
+    },
+    {
+      "id": "sidebar-done",
+      "scope": "both",
+      "key": "sidebar-done",
+      "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 Old 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
     }
   ]
 }

package/src/config/inference-profile-validation.ts

@@ -1,4 +1,4 @@
-import { getUserSelectableProfilesForProvider } from "./default-profile-catalog.js";
+import { getConversationProfilesForProvider } from "./default-profile-catalog.js";
 import { getConfigReadOnly } from "./loader.js";
 
 /**
@@ -6,17 +6,18 @@ import { getConfigReadOnly } from "./loader.js";
  * (code-defined defaults + workspace `llm.profiles`). Returns a user-facing
  * error message when the key is empty or unknown, or `null` when valid.
  *
- * Resolved through the `llm.defaultProvider`-aware user-selectable view so
- * availability matches what a direct profile pin can choose. Managed backup
- * routes remain available to automatic fallback resolution but are not
- * reported as selectable profiles.
+ * Resolved through the `llm.defaultProvider`-aware conversation view, since
+ * every caller (schedules, subagent spawns, per-conversation pins) runs chat
+ * turns on the result. Managed backup routes remain available to automatic
+ * fallback resolution, and the managed Jev profile to the verdict call
+ * sites, but neither is reported as a selectable profile here.
  */
 export function validateInferenceProfileKey(profile: string): string | null {
   if (!profile.trim()) {
     return "inferenceProfile must be a non-empty string";
   }
   const llm = getConfigReadOnly().llm;
-  const profiles = getUserSelectableProfilesForProvider(
+  const profiles = getConversationProfilesForProvider(
     llm?.profiles,
     llm?.defaultProvider ?? null,
   );

package/src/config/llm-resolver.ts

@@ -627,6 +627,22 @@ export function resolveDefaultProfileKey(
   return selectWinningProfile(callSite, llm, {}).profileName ?? undefined;
 }
 
+/**
+ * Returns the code-owned profile tier for catalog display when that tier is
+ * available through the workspace's default provider. Workspace call-site
+ * pins do not affect this value. A managed-only tier on a BYOK install returns
+ * undefined so clients do not report a profile that cannot run there.
+ */
+export function resolveShippedDefaultProfileKey(
+  callSite: LLMCallSite,
+  llm: z.infer<typeof LLMSchema>,
+): string | undefined {
+  const intent = CALL_SITE_DEFAULTS[callSite]?.profile ?? "balanced";
+  return usableDefaultIntent(intent, llm, {}, () => undefined) == null
+    ? undefined
+    : intent;
+}
+
 /**
  * Returns the profile key that `resolveCallSiteConfig` treats as the winning
  * (highest-precedence) profile for a turn — the profile whose fragment supplies

package/src/config/profile-text-generation.test.ts

@@ -15,6 +15,15 @@ describe("profileSupportsTextGeneration", () => {
     ).toBe(false);
   });
 
+  test("false for the managed Jev profile shape", () => {
+    expect(
+      profileSupportsTextGeneration(
+        { provider: "vellum", model: "jev-latest" },
+        {},
+      ),
+    ).toBe(false);
+  });
+
   test("true for a chat model and for unlisted custom ids", () => {
     expect(
       profileSupportsTextGeneration(

package/src/config/schemas/call-site-catalog.ts

@@ -307,7 +307,7 @@ const CATALOG_RECORD: CatalogRecord = {
     id: "voiceEscalationJudge",
     displayName: "Voice Escalation Judge",
     description:
-      "Second opinion on the voice front door's escalate decision. Runs only when pinned to a TypeSafe profile; a confident 'needs tools' verdict hands the turn to the escalated leg.",
+      "Second opinion on the voice front door's escalate decision. Uses managed Jev when Vellum-managed inference is available, or an explicitly configured TypeSafe profile; a confident 'needs tools' verdict hands the turn to the escalated leg.",
     domain: "agentLoop",
   },
   voiceContinuationJudge: {

package/src/config/schemas/llm.ts

@@ -14,12 +14,14 @@ import {
   parseVellumModel,
 } from "../../providers/vellum-model-routing.js";
 import {
-  BACKUP_PROFILE_KEYS,
   DEFAULT_PROFILE_KEYS,
   DEFAULT_PROFILE_PROVIDERS,
   FALLBACK_PROFILE_BY_KEY,
-  isBackupProfileKey,
   isDefaultProfileKey,
+  isManagedOnlyProfileKey,
+  JEV_MANAGED_PROFILE_CALL_SITES,
+  JEV_MANAGED_PROFILE_KEY,
+  MANAGED_ONLY_PROFILE_KEYS,
 } from "../default-profile-names.js";
 import { InputModalitiesSchema } from "../input-modalities.js";
 
@@ -766,10 +768,12 @@ function unresolvableProfileReason(
   name: string,
   backupsResolve: boolean,
 ): string {
-  return !backupsResolve &&
-    (BACKUP_PROFILE_KEYS as readonly string[]).includes(name)
-    ? "is a managed backup profile, which resolves only while llm.defaultProvider is the managed provider"
-    : "is not defined in llm.profiles";
+  if (backupsResolve || !isManagedOnlyProfileKey(name)) {
+    return "is not defined in llm.profiles";
+  }
+  return name === JEV_MANAGED_PROFILE_KEY
+    ? "is the managed Jev profile, which resolves only while llm.defaultProvider is the managed provider"
+    : "is a managed backup profile, which resolves only while llm.defaultProvider is the managed provider";
 }
 
 /**
@@ -800,7 +804,7 @@ function referenceableProfileKeys(
 ): string[] {
   return Object.entries(profiles ?? {})
     .filter(([name, value]) => {
-      if (backupsResolve || !isBackupProfileKey(name)) {
+      if (backupsResolve || !isManagedOnlyProfileKey(name)) {
         return true;
       }
       const entry =
@@ -854,7 +858,7 @@ export function collectFallbackProfileIssues(
   const profileNames = new Set([
     ...referenceableProfileKeys(profiles, backupsResolve),
     ...DEFAULT_PROFILE_KEYS,
-    ...(backupsResolve ? BACKUP_PROFILE_KEYS : []),
+    ...(backupsResolve ? MANAGED_ONLY_PROFILE_KEYS : []),
   ]);
   const mixProfileNames = new Set(
     entries
@@ -1004,6 +1008,8 @@ export const LLMSchema = z
     // they join the set only under a managed `llm.defaultProvider`: on a BYOK
     // or ChatGPT default provider they have no body to resolve to, and
     // keeping the reference would strand a selection the picker cannot show.
+    // The managed Jev profile (`JEV_MANAGED_PROFILE_KEY`) is scoped the same
+    // way, as a pin target for the judge call sites.
     // The flag-gated `os-beta` is excluded: it resolves only while a
     // workspace entry exists, so a reference to it is valid only when that
     // entry is present in `config.profiles`. A backup name materialized as a
@@ -1018,9 +1024,23 @@ export const LLMSchema = z
         backupsResolve,
       ),
       ...DEFAULT_PROFILE_KEYS,
-      ...(backupsResolve ? BACKUP_PROFILE_KEYS : []),
+      ...(backupsResolve ? MANAGED_ONLY_PROFILE_KEYS : []),
     ]);
     for (const [siteId, siteConfig] of Object.entries(config.callSites ?? {})) {
+      // The Jev profile answers with structured verdicts, so only the sites
+      // built to read one may pin it; a text-producing site would receive
+      // output it cannot use. (Mix arms are covered by the profile-level
+      // mix validation below, which bars the profile from any mix.)
+      if (
+        siteConfig?.profile === JEV_MANAGED_PROFILE_KEY &&
+        !(JEV_MANAGED_PROFILE_CALL_SITES as readonly string[]).includes(siteId)
+      ) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["callSites", siteId, "profile"],
+          message: `Profile "${JEV_MANAGED_PROFILE_KEY}" returns structured answers rather than chat text, so it can only be pinned to ${JEV_MANAGED_PROFILE_CALL_SITES.join(", ")}`,
+        });
+      }
       if (siteConfig?.profile == null) {
         continue;
       }
@@ -1052,6 +1072,20 @@ export const LLMSchema = z
         message: `Profile "${config.advisorProfile}" referenced by llm.advisorProfile ${unresolvableProfileReason(config.advisorProfile, backupsResolve)}`,
       });
     }
+    // The managed Jev profile is a valid reference target for call-site pins
+    // only. Its model returns structured verdicts rather than chat text, so
+    // the conversation positions reject it here as well as at the write
+    // routes, which keeps a raw config write from handing the main agent or
+    // the advisor a model that cannot answer in prose.
+    for (const field of ["activeProfile", "advisorProfile"] as const) {
+      if (config[field] === JEV_MANAGED_PROFILE_KEY) {
+        ctx.addIssue({
+          code: "custom",
+          path: [field],
+          message: `Profile "${JEV_MANAGED_PROFILE_KEY}" referenced by llm.${field} returns structured answers rather than chat text, so it cannot be the conversation or advisor profile`,
+        });
+      }
+    }
 
     // --- Mix profile validation --------------------------------------------
     // Config keys a mix profile must NOT also set (a mix only references other
@@ -1105,6 +1139,17 @@ export const LLMSchema = z
           });
           continue;
         }
+        // A mix is a conversation profile, so an arm that returns structured
+        // verdicts rather than text would hand a chat turn to the decision
+        // model whenever the seeded pick lands on it.
+        if (arm.profile === JEV_MANAGED_PROFILE_KEY) {
+          ctx.addIssue({
+            code: "custom",
+            path: ["profiles", name, "mix", index, "profile"],
+            message: `Mix profile "${name}" references "${JEV_MANAGED_PROFILE_KEY}", which returns structured answers rather than chat text and cannot be a mix constituent.`,
+          });
+          continue;
+        }
         // (b) No nesting — a mix arm must be a standard (non-mix) profile.
         if (mixProfileNames.has(arm.profile)) {
           ctx.addIssue({

package/src/config/sidebar-done-gate.ts

@@ -0,0 +1,27 @@
+import { isAssistantFeatureFlagEnabled } from "./assistant-feature-flags.js";
+import type { AssistantConfig } from "./schema.js";
+
+export const SIDEBAR_DONE_FLAG_KEY = "sidebar-done" as const;
+
+/**
+ * Whether archiving a chat means marking it done.
+ *
+ * The flag is `both`-scoped: clients gate the Done affordances and the Old
+ * chats page on it, and the daemon gates the halves the feature needs. Done is
+ * `archived_at`, so no row changes shape in either state.
+ *
+ * On the daemon side there are two. The first is search reach: off, an
+ * archived conversation is hidden from search unless the query names it
+ * (`is:archived`); on, a done chat is findable by default and `is:unarchived`
+ * is the opt-out, because a chat the user marked done is filed, not deleted,
+ * and search is how they get back to it.
+ *
+ * The second is that a done chat keeps working. Off, an archived conversation
+ * rejects every wake and nothing but the unarchive route clears the column, so
+ * marking a chat done silently kills its schedule or its channel thread. On, a
+ * wake still runs on it, and a message the user reads landing in it brings the
+ * conversation back to the list.
+ */
+export function isSidebarDoneEnabled(config?: AssistantConfig): boolean {
+  return isAssistantFeatureFlagEnabled(SIDEBAR_DONE_FLAG_KEY, config);
+}

package/src/daemon/conversation-slash.ts

@@ -1,5 +1,5 @@
 import type { InterfaceId } from "../channels/types.js";
-import { getUserSelectableProfilesForProvider } from "../config/default-profile-catalog.js";
+import { getConversationProfilesForProvider } from "../config/default-profile-catalog.js";
 import { resolveEffectiveContextWindow } from "../config/llm-context-resolution.js";
 import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import {
@@ -148,7 +148,7 @@ async function resolveModelCommand(
   parse: ModelCommandParse,
 ): Promise<SlashResolution> {
   const config = getConfig();
-  const profiles = getUserSelectableProfilesForProvider(
+  const profiles = getConversationProfilesForProvider(
     config.llm.profiles,
     config.llm.defaultProvider ?? null,
   );

package/src/daemon/conversation-turn-finalize.ts

@@ -40,6 +40,7 @@ import {
   getConversation,
   getMessageById,
   parseMessageMetadata,
+  resurfaceArchivedConversation,
 } from "../persistence/conversation-crud.js";
 import { getResolvedConversationDirPath } from "../persistence/conversation-directories.js";
 import { syncMessageToDisk } from "../persistence/conversation-disk-view.js";
@@ -150,6 +151,17 @@ export function buildDeferredFinalizeEffect(params: {
         "Failed to project assistant message for attention tracking (non-fatal)",
       );
     }
+    // The row this turn reserved was empty at insert, so this is where its
+    // content becomes readable and a Done conversation earns its way back to
+    // the list. A run that never got this far produced nothing to read.
+    try {
+      resurfaceArchivedConversation(conversationId, finalizedRow.createdAt);
+    } catch (err) {
+      rlog.warn(
+        { err, conversationId, messageId: assistantMessageId },
+        "Failed to resurface Done conversation after finalize (non-fatal)",
+      );
+    }
   };
 }
 

package/src/daemon/dictation-text-processing.ts

@@ -1,8 +1,8 @@
 /**
  * Pure text-processing functions for dictation profiles.
  *
- * - expandSnippets: pre-LLM, dictation mode only
- * - applyDictionary: post-LLM, dictation + command modes (including fallback paths)
+ * - expandSnippets: dictation mode only
+ * - applyDictionary: dictation and selected-text edits (including fallback paths)
  */
 
 import type {
@@ -33,7 +33,7 @@ function wrapWordBoundary(
 }
 
 /**
- * Expand snippet triggers in text before sending to the LLM.
+ * Expand user-configured snippet triggers in dictated text.
  *
  * - Only enabled snippets are considered
  * - Sorted by trigger length descending (longest match wins)
@@ -80,7 +80,7 @@ export function expandSnippets(
 }
 
 /**
- * Apply dictionary normalization to text after LLM processing (or on raw fallback).
+ * Apply user-configured dictionary replacements to dictated or edited text.
  *
  * - Sorted by spoken length descending
  * - Respects wholeWord (default true) and caseSensitive (default false) per entry

package/src/daemon/handlers/__tests__/conversation-history-search.test.ts

@@ -0,0 +1,61 @@
+/**
+ * Tests for the `includeArchived` option on the agent-facing conversation
+ * history search.
+ *
+ * The `"*"` wildcard takes its own branch (FTS reads `*` as a literal), so it
+ * has to honor the option through the list read rather than through
+ * `searchConversations`, which has its own coverage in
+ * `persistence/__tests__/conversation-queries-search.test.ts`.
+ */
+
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { createConversation } from "../../../persistence/conversation-crud.js";
+import { getDb } from "../../../persistence/db-connection.js";
+import { initializeDb } from "../../../persistence/db-init.js";
+import { rawRun } from "../../../persistence/raw-query.js";
+import { conversations } from "../../../persistence/schema/index.js";
+import { performConversationSearch } from "../conversation-history.js";
+
+await initializeDb();
+
+function seedArchived(title: string): string {
+  const conv = createConversation({ title });
+  rawRun(
+    "test:archiveConversation",
+    "UPDATE conversations SET archived_at = ? WHERE id = ?",
+    Date.now(),
+    conv.id,
+  );
+  return conv.id;
+}
+
+describe("performConversationSearch · wildcard listing", () => {
+  beforeEach(() => {
+    getDb().delete(conversations).run();
+  });
+
+  test("omits archived conversations by default", async () => {
+    createConversation("live-1");
+    seedArchived("archived-1");
+
+    const results = await performConversationSearch({ query: "*" });
+
+    expect(results.map((r) => r.conversationTitle)).toEqual(["live-1"]);
+  });
+
+  test("includeArchived reaches archived conversations", async () => {
+    createConversation("live-1");
+    seedArchived("archived-1");
+
+    const results = await performConversationSearch({
+      query: "*",
+      includeArchived: true,
+    });
+
+    expect(results.map((r) => r.conversationTitle).sort()).toEqual([
+      "archived-1",
+      "live-1",
+    ]);
+  });
+});

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

@@ -156,7 +156,9 @@ export async function createInboundChallenge(
       success: false,
       error: "already_bound",
       message:
-        "A guardian is already bound for this channel. Revoke the existing binding first, or set rebind: true to replace.",
+        resolvedChannel === "phone"
+          ? "A guardian is already bound for this channel. On phone, verify through an outbound call with rebind: true. To a new number, it replaces the bound number once the code is entered. To the bound number, it confirms that number again and leaves the binding as it is. An inbound challenge cannot be completed by phone: a call collects a six-digit code, which an inbound challenge does not issue."
+          : "A guardian is already bound for this channel. To verify a different account, revoke the existing binding first. Set rebind: true only to verify the same account again.",
       channel: resolvedChannel,
     };
   }