@vellumai/assistant 0.12.5-dev.202609281517.719e2bb → 0.12.5-dev.202609281715.b73f696

package/openapi.yaml

@@ -8042,8 +8042,9 @@ paths:
             Filter by conversation type. Pass "background" to list background and scheduled conversations together (the
             back-compat umbrella), "scheduled" to list only scheduled conversations, or "all" for the union of the
             standard listing and that umbrella, so one paginated cursor spans every type. Combine "all" with
-            archiveStatus=all for a whole-history read; rows are recency-ordered (COALESCE(last_message_at, updated_at)
-            descending) like every other list read, and pinned rows are never appended to it.
+            archiveStatus=all for a whole-history read; rows are ordered by last activity (the later of the last message
+            and the time the row was marked done, descending) like every other list read, and pinned rows are never
+            appended to it.
         - name: archiveStatus
           in: query
           required: false
@@ -8083,8 +8084,9 @@ paths:
           description:
             Filter to a single group, so each sidebar section can load independently of the paginated list. Pass
             "system:all" for conversations in no group, "system:pinned" for the Pinned section, or a custom group id. A
-            group-scoped request is recency-ordered like every list read (COALESCE(last_message_at, updated_at)
-            descending) and never has pinned rows appended to it. Omit to span every group.
+            group-scoped request is ordered by last activity like every list read (the later of the last message and the
+            time the row was marked done, descending) and never has pinned rows appended to it. Omit to span every
+            group.
         - name: needsAttention
           in: query
           required: false
@@ -8340,10 +8342,14 @@ paths:
                         - sortPosition
                         - isSystemGroup
                       additionalProperties: false
+                  orderedBy:
+                    type: string
+                    const: lastActivity
                 required:
                   - conversations
                   - nextOffset
                   - hasMore
+                  - orderedBy
                 additionalProperties: false
     post:
       operationId: conversations_post

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.12.5-dev.202609281517.719e2bb",
+  "version": "0.12.5-dev.202609281715.b73f696",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/byok-default-profile-ensure.test.ts

@@ -302,6 +302,13 @@ describe("ensureByokDefaultProfiles", () => {
       "cost-optimized",
       "accounts/fireworks/models/deepseek-v4-flash",
     ],
+    [
+      "fireworks",
+      "cost-optimized",
+      "accounts/fireworks/models/deepseek-v4-flash-0731",
+    ],
+    ["fireworks", "balanced", "accounts/fireworks/models/deepseek-v4p1-flash"],
+    ["fireworks", "quality-optimized", "accounts/fireworks/models/kimi-k2p6"],
   ] as const)(
     "a historical intent-era copy converts (%s %s pinned to %s)",
     (provider, key, model) => {

package/src/__tests__/openai-provider.test.ts

@@ -1960,10 +1960,10 @@ describe("FireworksProvider reasoning_effort ceiling", () => {
     lastCreateParams = null;
   });
 
-  test('DeepSeek V4 Pro accepts "max" unclamped', async () => {
+  test('DeepSeek V4.1 Flash accepts "max" unclamped', async () => {
     const fw = new FireworksProvider(
       "fw-key",
-      "accounts/fireworks/models/deepseek-v4-pro-0813",
+      "accounts/fireworks/models/deepseek-v4p1-flash",
     );
     await fw.sendMessage([userMsg("hi")], {
       systemPrompt: "system",
@@ -1972,10 +1972,10 @@ describe("FireworksProvider reasoning_effort ceiling", () => {
     expect(lastCreateParams!.reasoning_effort).toBe("max");
   });
 
-  test('DeepSeek V4 Pro accepts "xhigh" unclamped', async () => {
+  test('DeepSeek V4.1 Flash accepts "xhigh" unclamped', async () => {
     const fw = new FireworksProvider(
       "fw-key",
-      "accounts/fireworks/models/deepseek-v4-pro-0813",
+      "accounts/fireworks/models/deepseek-v4p1-flash",
     );
     await fw.sendMessage([userMsg("hi")], {
       systemPrompt: "system",
@@ -1984,10 +1984,10 @@ describe("FireworksProvider reasoning_effort ceiling", () => {
     expect(lastCreateParams!.reasoning_effort).toBe("xhigh");
   });
 
-  test('Kimi K2.6 clamps "xhigh"/"max" down to "high"', async () => {
+  test('MiniMax M3 clamps "xhigh"/"max" down to "high"', async () => {
     const fw = new FireworksProvider(
       "fw-key",
-      "accounts/fireworks/models/kimi-k2p6",
+      "accounts/fireworks/models/minimax-m3",
     );
     await fw.sendMessage([userMsg("hi")], {
       systemPrompt: "system",
@@ -2016,7 +2016,7 @@ describe("FireworksProvider reasoning_effort ceiling", () => {
   test("effort below ceiling is forwarded verbatim", async () => {
     const fw = new FireworksProvider(
       "fw-key",
-      "accounts/fireworks/models/deepseek-v4-pro-0813",
+      "accounts/fireworks/models/deepseek-v4p1-flash",
     );
     await fw.sendMessage([userMsg("hi")], {
       systemPrompt: "system",
@@ -2028,7 +2028,7 @@ describe("FireworksProvider reasoning_effort ceiling", () => {
   test('effort: "none" passes through regardless of ceiling', async () => {
     const fw = new FireworksProvider(
       "fw-key",
-      "accounts/fireworks/models/kimi-k2p6",
+      "accounts/fireworks/models/minimax-m3",
     );
     await fw.sendMessage([userMsg("hi")], {
       systemPrompt: "system",
@@ -2040,13 +2040,13 @@ describe("FireworksProvider reasoning_effort ceiling", () => {
   test("model override picks ceiling from runtime model, not constructor model", async () => {
     const fw = new FireworksProvider(
       "fw-key",
-      "accounts/fireworks/models/kimi-k2p6",
+      "accounts/fireworks/models/minimax-m3",
     );
     await fw.sendMessage([userMsg("hi")], {
       systemPrompt: "system",
       config: {
         effort: "max",
-        model: "accounts/fireworks/models/deepseek-v4-pro-0813",
+        model: "accounts/fireworks/models/deepseek-v4p1-flash",
       },
     });
     expect(lastCreateParams!.reasoning_effort).toBe("max");
@@ -2111,7 +2111,7 @@ describe("FireworksProvider sparse reasoning_effort support (GLM 5.3)", () => {
 
   test("models without supportedEfforts are unaffected", async () => {
     expect(
-      await send("accounts/fireworks/models/deepseek-v4-pro-0813", "medium"),
+      await send("accounts/fireworks/models/deepseek-v4p1-flash", "medium"),
     ).toBe("medium");
   });
 });

package/src/__tests__/workspace-migration-160-repair-retired-fireworks-model-ids.test.ts

@@ -0,0 +1,262 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Database } from "bun:sqlite";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { repairRetiredFireworksModelIdsMigration } from "../workspace/migrations/160-repair-retired-fireworks-model-ids.js";
+import { WORKSPACE_MIGRATIONS } from "../workspace/migrations/registry.js";
+import { assertNotLiveDb } from "./assert-not-live-db.js";
+
+const STALE = "accounts/fireworks/models/deepseek-v4-flash-0731";
+const REPLACEMENT = "accounts/fireworks/models/deepseek-v4p1-flash";
+
+let workspaceDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-160-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+}
+
+function writeConfig(data: Record<string, unknown>): void {
+  writeFileSync(
+    join(workspaceDir, "config.json"),
+    JSON.stringify(data, null, 2) + "\n",
+  );
+}
+
+function readConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(join(workspaceDir, "config.json"), "utf-8"));
+}
+
+function seedRows(rows: Array<{ name: string; provider: string }>): void {
+  mkdirSync(join(workspaceDir, "data", "db"), { recursive: true });
+  const db = new Database(join(workspaceDir, "data", "db", "assistant.db"));
+  db.run(`CREATE TABLE IF NOT EXISTS provider_connections (
+    name TEXT PRIMARY KEY,
+    provider TEXT NOT NULL,
+    auth TEXT NOT NULL,
+    created_at INTEGER NOT NULL,
+    updated_at INTEGER NOT NULL
+  )`);
+  for (const row of rows) {
+    db.query(
+      `INSERT INTO provider_connections (name, provider, auth, created_at, updated_at) VALUES (?, ?, '{"type":"api_key"}', 1, 1)`,
+    ).run(row.name, row.provider);
+  }
+  db.close();
+}
+
+beforeEach(() => {
+  freshWorkspace();
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    assertNotLiveDb(workspaceDir);
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("160-repair-retired-fireworks-model-ids migration", () => {
+  test("has correct migration id and is registered", () => {
+    expect(repairRetiredFireworksModelIdsMigration.id).toBe(
+      "160-repair-retired-fireworks-model-ids",
+    );
+    expect(WORKSPACE_MIGRATIONS.map((m) => m.id)).toContain(
+      "160-repair-retired-fireworks-model-ids",
+    );
+  });
+
+  test("repairs the stale ID in default, call sites, and profiles", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "fireworks", model: STALE },
+        callSites: {
+          recall: { model: STALE, maxTokens: 4096 },
+          heartbeat: { model: `${STALE}-tuned` },
+          malformed: STALE,
+        },
+        profiles: {
+          "cost-optimized": { provider: "vellum", model: STALE },
+          legacy: { model: STALE },
+        },
+      },
+    });
+
+    repairRetiredFireworksModelIdsMigration.run(workspaceDir);
+
+    const llm = readConfig().llm as Record<string, any>;
+    expect(llm.default.model).toBe(REPLACEMENT);
+    expect(llm.callSites.recall.model).toBe(REPLACEMENT);
+    expect(llm.callSites.recall.maxTokens).toBe(4096);
+    // Non-exact matches and malformed leaves are untouched.
+    expect(llm.callSites.heartbeat.model).toBe(`${STALE}-tuned`);
+    expect(llm.callSites.malformed).toBe(STALE);
+    // Managed profiles stamped provider "vellum" carry Fireworks model IDs.
+    expect(llm.profiles["cost-optimized"].model).toBe(REPLACEMENT);
+    expect(llm.profiles.legacy.model).toBe(REPLACEMENT);
+  });
+
+  test.each([
+    [
+      "accounts/fireworks/models/deepseek-v4-pro-0813",
+      "accounts/fireworks/models/deepseek-v4p1-flash",
+    ],
+    [
+      "accounts/fireworks/models/kimi-k2p6",
+      "accounts/fireworks/models/kimi-k3",
+    ],
+  ])("repairs %s to %s", (stale, replacement) => {
+    writeConfig({
+      llm: {
+        default: { provider: "fireworks", model: stale },
+        profiles: {
+          managed: { provider: "vellum", model: stale },
+          other: { provider: "openai-compatible", model: stale },
+        },
+      },
+    });
+
+    repairRetiredFireworksModelIdsMigration.run(workspaceDir);
+
+    const llm = readConfig().llm as Record<string, unknown>;
+    const profiles = llm.profiles as Record<string, Record<string, unknown>>;
+    expect((llm.default as Record<string, unknown>).model).toBe(replacement);
+    expect(profiles.managed.model).toBe(replacement);
+    expect(profiles.other.model).toBe(stale);
+  });
+
+  test("repairs entry-bound fragments whose row kind is fireworks or vellum", () => {
+    seedRows([
+      { name: "my-fireworks", provider: "fireworks" },
+      { name: "managed-alt", provider: "vellum" },
+    ]);
+    writeConfig({
+      llm: {
+        profiles: {
+          bound: { provider: "my-fireworks", model: STALE },
+          managed: { provider: "managed-alt", model: STALE },
+        },
+      },
+    });
+
+    repairRetiredFireworksModelIdsMigration.run(workspaceDir);
+
+    const llm = readConfig().llm as Record<string, any>;
+    expect(llm.profiles.bound.model).toBe(REPLACEMENT);
+    expect(llm.profiles.managed.model).toBe(REPLACEMENT);
+  });
+
+  test("leaves fragments with an explicit other provider untouched", () => {
+    seedRows([{ name: "byo-compat", provider: "openai-compatible" }]);
+    writeConfig({
+      llm: {
+        default: { provider: "openai-compatible", model: STALE },
+        profiles: {
+          byo: { provider: "openai-compatible", model: STALE },
+          // Entry-bound profile whose row kind is not repairable.
+          compatBound: { provider: "byo-compat", model: STALE },
+          // Entry name with no row: dangling, so nothing proves it is a
+          // fireworks-kind route.
+          dangling: { provider: "ghost", model: STALE },
+        },
+      },
+    });
+
+    repairRetiredFireworksModelIdsMigration.run(workspaceDir);
+
+    const llm = readConfig().llm as Record<string, any>;
+    expect(llm.default.model).toBe(STALE);
+    expect(llm.profiles.byo.model).toBe(STALE);
+    expect(llm.profiles.compatBound.model).toBe(STALE);
+    expect(llm.profiles.dangling.model).toBe(STALE);
+  });
+
+  test("leaves entry-name providers untouched when no DB file exists", () => {
+    writeConfig({
+      llm: {
+        profiles: { bound: { provider: "my-fireworks", model: STALE } },
+      },
+    });
+
+    repairRetiredFireworksModelIdsMigration.run(workspaceDir);
+
+    const llm = readConfig().llm as Record<string, any>;
+    expect(llm.profiles.bound.model).toBe(STALE);
+  });
+
+  test("throws when an entry-name provider needs rows and the DB is unreadable", () => {
+    // A DB file without the provider_connections table is unqueryable, so
+    // the run must fail (and retry later) instead of skipping the profile.
+    mkdirSync(join(workspaceDir, "data", "db"), { recursive: true });
+    writeFileSync(join(workspaceDir, "data", "db", "assistant.db"), "");
+    writeConfig({
+      llm: {
+        profiles: { bound: { provider: "my-fireworks", model: STALE } },
+      },
+    });
+
+    expect(() =>
+      repairRetiredFireworksModelIdsMigration.run(workspaceDir),
+    ).toThrow();
+    const llm = readConfig().llm as Record<string, any>;
+    expect(llm.profiles.bound.model).toBe(STALE);
+
+    // Vendor and absent providers never need the rows, so the same broken
+    // DB does not block their repair.
+    writeConfig({
+      llm: {
+        default: { provider: "fireworks", model: STALE },
+        profiles: { legacy: { model: STALE } },
+      },
+    });
+    repairRetiredFireworksModelIdsMigration.run(workspaceDir);
+    const repaired = readConfig().llm as Record<string, any>;
+    expect(repaired.default.model).toBe(REPLACEMENT);
+    expect(repaired.profiles.legacy.model).toBe(REPLACEMENT);
+  });
+
+  test("is idempotent and a no-op without the stale ID", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "fireworks", model: STALE },
+        profiles: { fine: { provider: "fireworks", model: REPLACEMENT } },
+      },
+    });
+
+    repairRetiredFireworksModelIdsMigration.run(workspaceDir);
+    const first = readConfig();
+    repairRetiredFireworksModelIdsMigration.run(workspaceDir);
+    expect(readConfig()).toEqual(first);
+
+    const llm = first.llm as Record<string, any>;
+    expect(llm.default.model).toBe(REPLACEMENT);
+    expect(llm.profiles.fine.model).toBe(REPLACEMENT);
+  });
+
+  test("handles missing config, missing llm block, and invalid JSON", () => {
+    // No config.json at all.
+    expect(() =>
+      repairRetiredFireworksModelIdsMigration.run(workspaceDir),
+    ).not.toThrow();
+
+    writeConfig({ theme: "dark" });
+    repairRetiredFireworksModelIdsMigration.run(workspaceDir);
+    expect(readConfig()).toEqual({ theme: "dark" });
+
+    writeFileSync(join(workspaceDir, "config.json"), "{not json");
+    expect(() =>
+      repairRetiredFireworksModelIdsMigration.run(workspaceDir),
+    ).not.toThrow();
+  });
+});

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

@@ -117,7 +117,7 @@ const VELLUM_PROFILE_IMPLS: ProfileImpls = {
     },
   },
   "cost-optimized": {
-    model: "accounts/fireworks/models/deepseek-v4-flash-0731",
+    model: "accounts/fireworks/models/deepseek-v4p1-flash",
     provider: "vellum",
     source: "managed",
     label: "Budget",

package/src/persistence/conversation-queries.ts

@@ -137,6 +137,19 @@ function archiveStatusClause(status: ArchiveStatusFilter) {
   }
 }
 
+/**
+ * A conversation's last activity, the key every list read is ordered on: its
+ * latest message (its last update, for a row with no messages yet) or the
+ * moment it was marked done, whichever is later. Marking a chat done is
+ * something the user did to it, so a done chat files under the day it was
+ * marked done rather than the day it was last written to. An active row has
+ * no `archived_at`, so for every active listing this is plain message recency.
+ *
+ * SQLite's multi-argument `MAX` is NULL when any argument is, hence the
+ * `COALESCE` on each side.
+ */
+const lastActivitySql = sql`MAX(COALESCE(${conversations.lastMessageAt}, ${conversations.updatedAt}), COALESCE(${conversations.archivedAt}, 0))`;
+
 /**
  * Raw SQL predicate for "visible in the standard (Recents) listing".
  *
@@ -532,9 +545,7 @@ export function listConversations(
   ensureGroupMigration();
   const db = getDb();
   const { limit, offset = 0, ...filter } = query;
-  const recency = desc(
-    sql`COALESCE(${conversations.lastMessageAt}, ${conversations.updatedAt})`,
-  );
+  const recency = desc(lastActivitySql);
   // `id` closes the ordering so the sort is a total order. Rows tied on every
   // preceding key would otherwise have no defined relative order, which
   // becomes duplicated and skipped rows once a cursor pages across a tie
@@ -654,11 +665,7 @@ export function listPinnedConversations(
         ...(archiveCond ? [archiveCond] : []),
       ),
     )
-    .orderBy(
-      desc(
-        sql`COALESCE(${conversations.lastMessageAt}, ${conversations.updatedAt})`,
-      ),
-    );
+    .orderBy(desc(lastActivitySql));
   return query.all().map(parseConversation);
 }
 

package/src/plugin-api/vision-support.test.ts

@@ -162,7 +162,7 @@ describe("doesSupportVision", () => {
       managed: { provider: "vellum", model: "claude-fable-5" },
       "managed-text": {
         provider: "vellum",
-        model: "accounts/fireworks/models/deepseek-v4-flash-0731",
+        model: "accounts/fireworks/models/glm-5p3",
       },
     });
     expect(doesSupportVision(profile("managed"))).toBe(true);
@@ -237,19 +237,19 @@ describe("doesSupportVision", () => {
 
 describe("doesSupportVision with a BYO default provider", () => {
   test("judges a default profile against the default provider's column model", () => {
-    // Managed/vellum column: cost-optimized → deepseek-v4-flash (text-only,
-    // supportsVision: false). Anthropic column: cost-optimized carries
-    // intent "latency-optimized" → claude-haiku-4-5 (supportsVision: true).
+    // Managed/vellum column: cost-optimized → deepseek-v4p1-flash
+    // (supportsVision: true). OpenRouter column: cost-optimized →
+    // deepseek/deepseek-v4-flash (text-only, supportsVision: false).
     // The judged model must be the one the BYO install actually runs.
-    setMockConfig({}, { provider: "anthropic" });
-    expect(doesSupportVision(profile("cost-optimized"))).toBe(true);
+    setMockConfig({}, { provider: "openrouter" });
+    expect(doesSupportVision(profile("cost-optimized"))).toBe(false);
   });
 
   test("without a default provider, a default profile judges the managed column", () => {
     // Null-reduction: no defaultProvider resolves cost-optimized through the
-    // vellum column (deepseek-v4-flash, text-only).
+    // vellum column (deepseek-v4p1-flash, vision-capable).
     setMockConfig({});
-    expect(doesSupportVision(profile("cost-optimized"))).toBe(false);
+    expect(doesSupportVision(profile("cost-optimized"))).toBe(true);
   });
 
   test("mix arms naming a default profile resolve through the same column", () => {
@@ -266,11 +266,11 @@ describe("doesSupportVision with a BYO default provider", () => {
           model: "accounts/fireworks/models/glm-5p2",
         },
       },
-      { provider: "anthropic" },
+      { provider: "openrouter" },
     );
-    // The "cost-optimized" arm resolves to the anthropic column's
-    // vision-capable model, so the mix can route to vision.
-    expect(doesSupportVision(profile("mix-profile"))).toBe(true);
+    // The "cost-optimized" arm resolves to the openrouter column's
+    // text-only model, so no arm of the mix can route to vision.
+    expect(doesSupportVision(profile("mix-profile"))).toBe(false);
   });
 
   test("a user-owned profile is unaffected by the default provider", () => {

package/src/providers/model-catalog.ts

@@ -1062,22 +1062,9 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           cacheReadPer1mTokens: 0.3,
         },
       },
-      {
-        id: "accounts/fireworks/models/kimi-k2p6",
-        displayName: "Kimi K2.6",
-        contextWindowTokens: 262144,
-        maxOutputTokens: 32768,
-        supportsThinking: true,
-        supportsCaching: true,
-        supportsVision: true,
-        supportsToolUse: true,
-        maxEffort: "high",
-        pricing: {
-          inputPer1mTokens: 0.95,
-          outputPer1mTokens: 4.0,
-          cacheReadPer1mTokens: 0.16,
-        },
-      },
+      // Kimi K2.6 (accounts/fireworks/models/kimi-k2p6) is intentionally
+      // absent: Fireworks has no serverless deployment for it (the serving
+      // API returns 404). Kimi K3 is its successor.
       {
         id: "accounts/fireworks/models/glm-5p3",
         displayName: "GLM 5.3",
@@ -1160,40 +1147,30 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
       // intentionally absent: Fireworks has no serverless deployment for
       // it (the model page claims serverless support, but the serving API
       // returns 404).
-      {
-        id: "accounts/fireworks/models/deepseek-v4-pro-0813",
-        displayName: "DeepSeek V4 Pro",
-        contextWindowTokens: 1040000,
-        maxOutputTokens: 131072,
-        supportsThinking: true,
-        supportsCaching: true,
-        supportsVision: false,
-        supportsToolUse: true,
-        maxEffort: "max",
-        pricing: {
-          inputPer1mTokens: 1.32,
-          outputPer1mTokens: 3.96,
-          cacheReadPer1mTokens: 0.044,
-        },
-      },
-      {
-        id: "accounts/fireworks/models/deepseek-v4-flash-0731",
-        displayName: "DeepSeek V4 Flash",
-        contextWindowTokens: 1040000,
+      // DeepSeek V4 Pro (accounts/fireworks/models/deepseek-v4-pro-0813)
+      // and DeepSeek V4 Flash
+      // (accounts/fireworks/models/deepseek-v4-flash-0731) are intentionally
+      // absent: Fireworks has no serverless deployment for them (the
+      // serving API returns 404). DeepSeek V4.1 Flash is the serverless
+      // successor Fireworks names for both.
+      {
+        id: "accounts/fireworks/models/deepseek-v4p1-flash",
+        displayName: "DeepSeek V4.1 Flash",
+        contextWindowTokens: 1048576,
         maxOutputTokens: 131072,
         supportsThinking: true,
         supportsCaching: true,
-        supportsVision: false,
+        supportsVision: true,
         supportsToolUse: true,
         maxEffort: "max",
         pricing: {
-          inputPer1mTokens: 0.14,
-          outputPer1mTokens: 0.28,
-          cacheReadPer1mTokens: 0.028,
+          inputPer1mTokens: 0.3,
+          outputPer1mTokens: 1.2,
+          cacheReadPer1mTokens: 0.006,
         },
       },
     ],
-    defaultModel: "accounts/fireworks/models/deepseek-v4-flash-0731",
+    defaultModel: "accounts/fireworks/models/deepseek-v4p1-flash",
     apiKeyUrl: "https://fireworks.ai/account/api-keys",
     apiKeyPlaceholder: "fw_...",
   },
@@ -1911,32 +1888,6 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
         },
       },
       // DeepSeek
-      {
-        id: "deepseek/deepseek-r1-0528",
-        displayName: "DeepSeek R1",
-        contextWindowTokens: 163840,
-        maxOutputTokens: 32000,
-        supportsThinking: true,
-        supportsCaching: true,
-        supportsVision: false,
-        supportsToolUse: true,
-        pricing: {
-          inputPer1mTokens: 0.5,
-          outputPer1mTokens: 2.15,
-          cacheReadPer1mTokens: 0.35,
-        },
-      },
-      {
-        id: "deepseek/deepseek-chat-v3-0324",
-        displayName: "DeepSeek V3",
-        contextWindowTokens: 163840,
-        maxOutputTokens: 32000,
-        supportsThinking: false,
-        supportsCaching: false,
-        supportsVision: false,
-        supportsToolUse: true,
-        pricing: { inputPer1mTokens: 0.25, outputPer1mTokens: 1.0 },
-      },
       {
         id: "deepseek/deepseek-v4-pro",
         displayName: "DeepSeek V4 Pro",
@@ -1971,6 +1922,32 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           cacheReadPer1mTokens: 0.028,
         },
       },
+      {
+        id: "deepseek/deepseek-r1-0528",
+        displayName: "DeepSeek R1",
+        contextWindowTokens: 163840,
+        maxOutputTokens: 32000,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: false,
+        supportsToolUse: true,
+        pricing: {
+          inputPer1mTokens: 0.5,
+          outputPer1mTokens: 2.15,
+          cacheReadPer1mTokens: 0.35,
+        },
+      },
+      {
+        id: "deepseek/deepseek-chat-v3-0324",
+        displayName: "DeepSeek V3",
+        contextWindowTokens: 163840,
+        maxOutputTokens: 32000,
+        supportsThinking: false,
+        supportsCaching: false,
+        supportsVision: false,
+        supportsToolUse: true,
+        pricing: { inputPer1mTokens: 0.25, outputPer1mTokens: 1.0 },
+      },
       // Qwen
       {
         id: "qwen/qwen3.5-plus-02-15",

package/src/providers/model-intents.ts

@@ -51,10 +51,10 @@ const PROVIDER_MODEL_INTENTS: Record<string, Record<ModelIntent, string>> = {
   },
   fireworks: {
     balanced: "accounts/fireworks/models/minimax-m3",
-    "cost-optimized": "accounts/fireworks/models/deepseek-v4-flash-0731",
-    "latency-optimized": "accounts/fireworks/models/deepseek-v4-flash-0731",
-    "quality-optimized": "accounts/fireworks/models/kimi-k2p6",
-    "vision-optimized": "accounts/fireworks/models/kimi-k2p6",
+    "cost-optimized": "accounts/fireworks/models/deepseek-v4p1-flash",
+    "latency-optimized": "accounts/fireworks/models/deepseek-v4p1-flash",
+    "quality-optimized": "accounts/fireworks/models/kimi-k3",
+    "vision-optimized": "accounts/fireworks/models/kimi-k3",
   },
   openrouter: {
     balanced: "anthropic/claude-sonnet-4.6",

package/src/runtime/routes/__tests__/conversation-list-routes.test.ts

@@ -71,6 +71,7 @@ interface ListResponse {
   nextOffset: number;
   hasMore: boolean;
   groups?: unknown[];
+  orderedBy: string;
 }
 
 function findHandler(routes: RouteDefinition[], operationId: string) {
@@ -1380,6 +1381,41 @@ describe("GET /v1/conversations, conversationType=all", () => {
     ]);
   });
 
+  test("files a done row by when it was marked done when that is later than its last message", async () => {
+    const recent = createConversation("recent-foreground");
+    const doneLater = createConversation("old-chat-marked-done-later");
+    const doneEarlier = createConversation("old-chat-done-before-a-reply");
+    setLastMessageAt(recent.id, 2000);
+    setLastMessageAt(doneLater.id, 1000);
+    setLastMessageAt(doneEarlier.id, 1500);
+    rawRun(
+      "test:markDone",
+      "UPDATE conversations SET archived_at = ? WHERE id = ?",
+      3000,
+      doneLater.id,
+    );
+    rawRun(
+      "test:markDone",
+      "UPDATE conversations SET archived_at = ? WHERE id = ?",
+      500,
+      doneEarlier.id,
+    );
+
+    const result = (await invoke({
+      conversationType: "all",
+      archiveStatus: "all",
+    })) as ListResponse;
+
+    expect(result.conversations.map((c) => c.title)).toEqual([
+      "old-chat-marked-done-later",
+      "recent-foreground",
+      "old-chat-done-before-a-reply",
+    ]);
+    // A client paging done rows relies on this to know the order is not
+    // message recency.
+    expect(result.orderedBy).toBe("lastActivity");
+  });
+
   test("excludes legacy private rows and subagent runs", async () => {
     createConversation("foreground-1");
     const legacyPrivate = createConversation("legacy-private");

package/src/runtime/routes/__tests__/inference-send-routes.test.ts

@@ -252,7 +252,7 @@ describe("inference_send profile usability", () => {
     const err = await rejection({ ...hermes, status: "disabled" });
     expect(err).toBeInstanceOf(BadRequestError);
     expect(err.message).toContain("disabled");
-    expect(err.message).toContain("deepseek-v4-flash");
+    expect(err.message).toContain("deepseek-v4p1-flash");
   });
 
   test("rejects a profile that lost its provider", async () => {

package/src/runtime/routes/__tests__/user-route-dispatcher.test.ts

@@ -106,6 +106,18 @@ describe("path traversal", () => {
     );
     expect(res.status).toBe(400);
   });
+
+  test("rejects backslashes in the route path", async () => {
+    // Some URL normalizers treat a backslash as a separator, so a
+    // backslash-carrying routePath is refused outright regardless of dots.
+    const dispatcher = makeDispatcher();
+    for (const routePath of ["..\\config", "foo\\bar", "x\\..\\config"]) {
+      const res = await dispatcher.dispatch(routePath, makeRequest("GET"));
+      expect(res.status).toBe(400);
+      const body = await readErrorBody(res);
+      expect(body.error.message).toContain("Path traversal");
+    }
+  });
 });
 
 // ---------------------------------------------------------------------------

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

@@ -150,6 +150,13 @@ const listConversationsResponseSchema = z.object({
   nextOffset: z.number(),
   hasMore: z.boolean(),
   groups: z.array(groupSummarySchema).optional(),
+  /**
+   * The key the rows are ordered on: last activity, the later of a row's
+   * last message and the time it was marked done. Stated so a client that
+   * pages a list including done rows can tell this order from message
+   * recency, which an assistant that omits the field pages by.
+   */
+  orderedBy: z.literal("lastActivity"),
 });
 
 const conversationDetailResponseSchema = z.object({
@@ -376,6 +383,7 @@ function handleListConversations({
     ),
     nextOffset,
     hasMore: nextOffset < totalCount,
+    orderedBy: "lastActivity",
   };
 
   // Include groups array on first page only
@@ -632,7 +640,7 @@ export const ROUTES: RouteDefinition[] = [
         type: "string",
         required: false,
         description:
-          'Filter by conversation type. Pass "background" to list background and scheduled conversations together (the back-compat umbrella), "scheduled" to list only scheduled conversations, or "all" for the union of the standard listing and that umbrella, so one paginated cursor spans every type. Combine "all" with archiveStatus=all for a whole-history read; rows are recency-ordered (COALESCE(last_message_at, updated_at) descending) like every other list read, and pinned rows are never appended to it.',
+          'Filter by conversation type. Pass "background" to list background and scheduled conversations together (the back-compat umbrella), "scheduled" to list only scheduled conversations, or "all" for the union of the standard listing and that umbrella, so one paginated cursor spans every type. Combine "all" with archiveStatus=all for a whole-history read; rows are ordered by last activity (the later of the last message and the time the row was marked done, descending) like every other list read, and pinned rows are never appended to it.',
         schema: {
           type: "string",
           enum: ["background", "scheduled", "all"],
@@ -662,7 +670,7 @@ export const ROUTES: RouteDefinition[] = [
         type: "string",
         required: false,
         description:
-          'Filter to a single group, so each sidebar section can load independently of the paginated list. Pass "system:all" for conversations in no group, "system:pinned" for the Pinned section, or a custom group id. A group-scoped request is recency-ordered like every list read (COALESCE(last_message_at, updated_at) descending) and never has pinned rows appended to it. Omit to span every group.',
+          'Filter to a single group, so each sidebar section can load independently of the paginated list. Pass "system:all" for conversations in no group, "system:pinned" for the Pinned section, or a custom group id. A group-scoped request is ordered by last activity like every list read (the later of the last message and the time the row was marked done, descending) and never has pinned rows appended to it. Omit to span every group.',
       },
       {
         name: "needsAttention",

package/src/runtime/routes/user-route-dispatcher.ts

@@ -135,7 +135,11 @@ export class UserRouteDispatcher {
    * @returns A Response from the handler, or an error response (404, 405, 500).
    */
   async dispatch(routePath: string, request: Request): Promise<Response> {
-    if (routePath.includes("..")) {
+    // ".." covers classic dot-segment traversal. "\" is rejected alongside it
+    // because some URL normalizers treat a backslash as a path separator, so
+    // a routePath that looks in-namespace after percent-decoding can still
+    // resolve outside the routes directory once such a normalizer runs.
+    if (routePath.includes("..") || routePath.includes("\\")) {
       return httpError("BAD_REQUEST", "Path traversal is not allowed", 400);
     }
 

package/src/workspace/byok-default-profile-ensure.ts

@@ -187,6 +187,8 @@ const HISTORICAL_INTENT_MODELS: Record<
       "accounts/fireworks/models/deepseek-v4-flash",
       // the ID migration 146 writes over stale deepseek-v4-flash pins.
       "accounts/fireworks/models/deepseek-v4-flash-0731",
+      // the ID migration 160 writes over stale deepseek-v4-flash-0731 pins.
+      "accounts/fireworks/models/deepseek-v4p1-flash",
     ],
   },
   "quality-optimized": {
@@ -209,10 +211,15 @@ const HISTORICAL_INTENT_MODELS: Record<
     fireworks: [
       // quality intent 2026-05-05 (#29755) to 2026-05-19 (#31068).
       "accounts/fireworks/models/kimi-k2p5",
+      // quality intent 2026-05-19 (#31068) to the 2026-09-28 kimi-k3
+      // repoint.
+      "accounts/fireworks/models/kimi-k2p6",
       // migration 136's in-place rewrite of a kimi-k2p5 pin.
       "accounts/fireworks/models/deepseek-v4-flash",
       // the ID migration 146 writes over stale deepseek-v4-flash pins.
       "accounts/fireworks/models/deepseek-v4-flash-0731",
+      // the ID migration 160 writes over stale deepseek-v4-flash-0731 pins.
+      "accounts/fireworks/models/deepseek-v4p1-flash",
     ],
   },
   "cost-optimized": {
@@ -234,6 +241,10 @@ const HISTORICAL_INTENT_MODELS: Record<
       // 146 rewrites it to the dated ID, so this survives only in pre-146
       // backups.
       "accounts/fireworks/models/deepseek-v4-flash",
+      // latency intent 2026-08-17 to the 2026-09-28 deepseek-v4p1-flash
+      // repoint. On live configs migration 160 rewrites it, so this
+      // survives only in pre-160 backups.
+      "accounts/fireworks/models/deepseek-v4-flash-0731",
     ],
   },
 };

package/src/workspace/migrations/160-repair-retired-fireworks-model-ids.ts

@@ -0,0 +1,209 @@
+import { existsSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { Database } from "bun:sqlite";
+
+import type { WorkspaceMigration } from "./types.js";
+
+/**
+ * Repair the retired Fireworks model IDs in workspace LLM config.
+ *
+ * Fireworks has no serverless deployment of DeepSeek V4 Flash 0731,
+ * DeepSeek V4 Pro 0813 or Kimi K2.6: chat/completions calls fail with a
+ * 404 "Model not found, inaccessible, and/or not deployed". Existing
+ * configs can pin any of these IDs in `llm.default`, `llm.callSites.*`, and `llm.profiles.*`.
+ *
+ * Repair those leaves only on an exact stale match, replacing with the
+ * successor Fireworks names (see `REPLACEMENT_BY_STALE_MODEL_ID`). Kimi
+ * K2.6 has two named successors; Kimi K3 is the one that accepts image
+ * input, which Kimi K2.6 does.
+ *
+ * A replacement can also be an intent template's model, so a repaired
+ * hand-edited `custom-*` profile can read as unedited to
+ * `ensureByokDefaultProfiles` and collapse into that default. That is
+ * acceptable: the collapsed copy routes to the same model this migration
+ * writes.
+ *
+ * Provider guard: the stale IDs belong to the `fireworks` provider and also
+ * appear in managed profiles stamped `provider: "vellum"` (which route
+ * Fireworks-account model IDs through the managed proxy). Under the entries
+ * model (migration 145) `provider` can also hold a `provider_connections`
+ * entry name whose row kind drives dispatch. A fragment is repaired when
+ * its `provider` is `"fireworks"`, `"vellum"`, absent, or an entry name
+ * whose row kind is one of those. Any other provider is left untouched: an
+ * `openai-compatible` endpoint may legitimately serve a model by the stale
+ * name.
+ */
+export const repairRetiredFireworksModelIdsMigration: WorkspaceMigration = {
+  id: "160-repair-retired-fireworks-model-ids",
+  description: "Repair retired Fireworks model IDs in workspace LLM config",
+  run(workspaceDir: string): void {
+    const configPath = join(workspaceDir, "config.json");
+    if (!existsSync(configPath)) {
+      return;
+    }
+
+    // Read outside the parse catch: a transient filesystem error (EIO,
+    // EACCES) must reach the runner so the migration retries, while
+    // malformed JSON is a permanent state this migration cannot repair.
+    const rawText = readFileSync(configPath, "utf-8");
+
+    let config: Record<string, unknown>;
+    try {
+      const raw = JSON.parse(rawText);
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        return;
+      }
+      config = raw as Record<string, unknown>;
+    } catch {
+      return;
+    }
+
+    const llm = readObject(config.llm);
+    if (llm === null) {
+      return;
+    }
+
+    // Entry rows load lazily: only a stale fragment whose provider is
+    // neither a repairable vendor nor absent needs them. An unreadable DB
+    // then fails the run (retried next boot) rather than checkpointing a
+    // pass that skips entry-bound profiles.
+    let rows: Map<string, string> | null | undefined;
+    const isRepairableProvider = (provider: unknown): boolean => {
+      if (provider === undefined) {
+        return true;
+      }
+      if (typeof provider !== "string") {
+        return false;
+      }
+      if (REPAIRABLE_PROVIDERS.has(provider)) {
+        return true;
+      }
+      if (rows === undefined) {
+        rows = readConnectionRows(workspaceDir);
+      }
+      if (rows === null) {
+        throw new Error(
+          "provider_connections is not readable; retrying the model-ID repair on the next run",
+        );
+      }
+      const kind = rows.get(provider);
+      return kind !== undefined && REPAIRABLE_PROVIDERS.has(kind);
+    };
+
+    let changed = false;
+
+    changed =
+      repairFragment(readObject(llm.default), isRepairableProvider) || changed;
+
+    const callSites = readObject(llm.callSites);
+    if (callSites !== null) {
+      for (const rawConfig of Object.values(callSites)) {
+        changed =
+          repairFragment(readObject(rawConfig), isRepairableProvider) ||
+          changed;
+      }
+    }
+
+    const profiles = readObject(llm.profiles);
+    if (profiles !== null) {
+      for (const rawProfile of Object.values(profiles)) {
+        changed =
+          repairFragment(readObject(rawProfile), isRepairableProvider) ||
+          changed;
+      }
+    }
+
+    if (!changed) {
+      return;
+    }
+
+    // Write-then-rename so an interrupted write cannot leave config.json
+    // truncated: a torn in-place write would parse as invalid JSON on the
+    // retry, which the catch above treats as "nothing to do", letting the
+    // runner checkpoint the migration as completed against a corrupt file.
+    const tmpPath = `${configPath}.migration-160.tmp`;
+    writeFileSync(tmpPath, JSON.stringify(config, null, 2) + "\n");
+    renameSync(tmpPath, configPath);
+  },
+  // The exact-match rewrite is idempotent, so a transient failure (full
+  // disk, I/O error) is safe to retry on later startups.
+  retryFailedCheckpoint: true,
+  down(_workspaceDir: string): void {
+    // Forward-only: reintroducing a retired model ID would break
+    // Fireworks calls.
+  },
+};
+
+// ---------------------------------------------------------------------------
+// Helpers: self-contained per workspace migrations AGENTS.md
+// ---------------------------------------------------------------------------
+
+const REPLACEMENT_BY_STALE_MODEL_ID = new Map([
+  [
+    "accounts/fireworks/models/deepseek-v4-flash-0731",
+    "accounts/fireworks/models/deepseek-v4p1-flash",
+  ],
+  [
+    "accounts/fireworks/models/deepseek-v4-pro-0813",
+    "accounts/fireworks/models/deepseek-v4p1-flash",
+  ],
+  ["accounts/fireworks/models/kimi-k2p6", "accounts/fireworks/models/kimi-k3"],
+]);
+const REPAIRABLE_PROVIDERS = new Set(["fireworks", "vellum"]);
+
+function repairFragment(
+  fragment: Record<string, unknown> | null,
+  isRepairableProvider: (provider: unknown) => boolean,
+): boolean {
+  if (fragment === null) {
+    return false;
+  }
+  if (typeof fragment.model !== "string") {
+    return false;
+  }
+  const replacement = REPLACEMENT_BY_STALE_MODEL_ID.get(fragment.model);
+  if (replacement === undefined) {
+    return false;
+  }
+  if (!isRepairableProvider(fragment.provider)) {
+    return false;
+  }
+  fragment.model = replacement;
+  return true;
+}
+
+/**
+ * Connection name -> provider kind, or null when the DB or table is not
+ * readable. The caller fails the run on null: entry-name providers must be
+ * judged against real rows, never guessed. An absent DB file is a real
+ * state (no rows, so every entry name is dangling and stays untouched).
+ */
+function readConnectionRows(workspaceDir: string): Map<string, string> | null {
+  const dbPath = join(workspaceDir, "data", "db", "assistant.db");
+  if (!existsSync(dbPath)) {
+    return new Map();
+  }
+  let db: Database;
+  try {
+    db = new Database(dbPath);
+  } catch {
+    return null;
+  }
+  try {
+    const rows = db
+      .query(`SELECT name, provider FROM provider_connections`)
+      .all() as Array<{ name: string; provider: string }>;
+    return new Map(rows.map((r) => [r.name, r.provider]));
+  } catch {
+    return null;
+  } finally {
+    db.close();
+  }
+}
+
+function readObject(value: unknown): Record<string, unknown> | null {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value as Record<string, unknown>;
+}

package/src/workspace/migrations/registry.ts

@@ -157,6 +157,7 @@ import { extractWorkspaceMcpJsonMigration } from "./156-extract-workspace-mcp-js
 import { addDesktopFilesLauncherMigration } from "./157-add-desktop-files-launcher.js";
 import { repointOpencodeHostProviderFragmentsMigration } from "./158-repoint-opencode-host-provider-fragments.js";
 import { renameCollidingJevProfileNameMigration } from "./159-rename-colliding-jev-profile-name.js";
+import { repairRetiredFireworksModelIdsMigration } from "./160-repair-retired-fireworks-model-ids.js";
 import { migrateToWorkspaceVolumeMigration } from "./migrate-to-workspace-volume.js";
 import type { WorkspaceMigration } from "./types.js";
 
@@ -329,4 +330,5 @@ export const WORKSPACE_MIGRATIONS: WorkspaceMigration[] = [
   addDesktopFilesLauncherMigration,
   repointOpencodeHostProviderFragmentsMigration,
   renameCollidingJevProfileNameMigration,
+  repairRetiredFireworksModelIdsMigration,
 ];