@pithy-sh/support 0.5.1 → 0.6.1

package/src/store/threads.ts

@@ -1,9 +1,9 @@
 // SPDX-FileCopyrightText: 2026 Pithy
 // SPDX-License-Identifier: MIT
 
-import { pithyCommandOf } from "@pithy-sh/core/src/cli/command";
-import type { Logger } from "@pithy-sh/core/src/logger/logger";
-import { type SqlBool, sql } from "kysely";
+import type { DatabaseSchema } from "@pithy-sh/core/src/data/db";
+import type { SelectQueryBuilder } from "kysely";
+import { UNASSIGNED } from "../data/assignment";
 import { SupportAttachment } from "../data/attachment";
 import type { SupportChannel, SupportPriority, SupportSentiment } from "../data/enums";
 import { SupportMessage } from "../data/message";
@@ -11,14 +11,13 @@ import {
   SUPPORT_ATTACHMENTS_TABLE,
   SUPPORT_FLAGS_TABLE,
   SUPPORT_MESSAGES_TABLE,
-  SUPPORT_SEARCH_TABLE,
   SUPPORT_THREADS_TABLE,
   type SupportDatabase,
+  type SupportTables,
 } from "../data/tables";
 import { SupportThread } from "../data/thread";
 import { SupportNotFoundError } from "../error/errors";
 import { DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE } from "./paging";
-import { isSearchable, searchPredicate } from "./search";
 
 /**
  * The inbox query — the one read this whole data model was shaped around.
@@ -71,8 +70,12 @@ export function decodeCursor(value: string | undefined): ThreadCursor | undefine
   }
 }
 
-/** What a caller may filter the inbox by. */
-export interface ListThreadsQuery {
+/**
+ * What a caller may narrow threads by — the inbox listing and the search route alike. Search applies
+ * these in D1, after retrieval, never as Vectorize metadata: metadata would go stale the moment a thread is
+ * archived, reassigned or reclassified.
+ */
+export interface ThreadFilters {
   /** Open threads, done threads, or both. Defaults to open. */
   archived?: boolean;
   /** One category key from the effective taxonomy — what the classifier decided. */
@@ -87,8 +90,17 @@ export interface ListThreadsQuery {
   channel?: SupportChannel;
   /** Which inbox address, for a Worker serving more than one. */
   inbox?: string;
-  /** Free text over subjects and bodies. */
-  q?: string;
+  /** Whose threads: one assignee's opaque ref, or {@link UNASSIGNED} for the threads nobody has. */
+  assignee?: string;
+}
+
+/**
+ * What a caller may filter the inbox by, and where to resume.
+ *
+ * **No free text.** Listing lists; `GET {basePath}/threads/search` searches, ranked, with a limit and no
+ * cursor. A `q` here could say whether a thread matched, never how well.
+ */
+export interface ListThreadsQuery extends ThreadFilters {
   /** Where to resume from. */
   cursor?: string;
   /** How many to return. */
@@ -111,6 +123,70 @@ export interface ThreadPage {
   nextCursor: string | null;
 }
 
+type SupportSchema = DatabaseSchema<SupportTables>;
+type ThreadsAndFlags = typeof SUPPORT_THREADS_TABLE | typeof SUPPORT_FLAGS_TABLE;
+
+/**
+ * Threads joined to one viewer's own flags.
+ *
+ * Joined on the viewer as well as the thread, so one operator's snooze never hides a thread from anybody
+ * else — the whole reason these flags are per viewer rather than on the thread.
+ */
+export function viewerThreads(db: SupportDatabase, viewer: string) {
+  return db
+    .selectFrom(SUPPORT_THREADS_TABLE)
+    .leftJoin(SUPPORT_FLAGS_TABLE, (join) =>
+      join
+        .onRef(`${SUPPORT_FLAGS_TABLE}.threadId`, "=", `${SUPPORT_THREADS_TABLE}.id`)
+        .on(`${SUPPORT_FLAGS_TABLE}.viewer`, "=", viewer),
+    )
+    .selectAll(SUPPORT_THREADS_TABLE)
+    .select([`${SUPPORT_FLAGS_TABLE}.read as viewerRead`, `${SUPPORT_FLAGS_TABLE}.snoozedUntil as viewerSnoozedUntil`]);
+}
+
+/** A row out of {@link viewerThreads}, as the listing and the search both return it. */
+export function listedThreadOf(row: Record<string, unknown>): ListedThread {
+  return {
+    ...SupportThread.parse(row),
+    // A viewer with no flag row has read nothing and snoozed nothing, which is the common case and
+    // the right default — not an absence a caller has to interpret.
+    read: row.viewerRead === 1,
+    snoozedUntil: row.viewerSnoozedUntil == null ? null : new Date(Number(row.viewerSnoozedUntil)),
+  };
+}
+
+/** Narrow a {@link viewerThreads} query by every filter the caller set — one statement of them, for both routes. */
+export function applyThreadFilters<O>(
+  builder: SelectQueryBuilder<SupportSchema, ThreadsAndFlags, O>,
+  filters: ThreadFilters,
+): SelectQueryBuilder<SupportSchema, ThreadsAndFlags, O> {
+  // Archived is a filter with a default rather than an optional one: an inbox that showed resolved
+  // threads by default would be an inbox nobody trusts to be a work queue.
+  let filtered = builder.where(`${SUPPORT_THREADS_TABLE}.archived`, "=", filters.archived === true ? 1 : 0);
+  if (filters.category !== undefined)
+    filtered = filtered.where(`${SUPPORT_THREADS_TABLE}.category`, "=", filters.category);
+  // Its own predicate rather than an `OR` with the one above, because the two answer different
+  // questions and an operator asking both is asking for the threads where they agree — which is the
+  // one shape a single conflated filter could never express.
+  if (filters.declaredCategory !== undefined)
+    filtered = filtered.where(`${SUPPORT_THREADS_TABLE}.declaredCategory`, "=", filters.declaredCategory);
+  if (filters.priority !== undefined)
+    filtered = filtered.where(`${SUPPORT_THREADS_TABLE}.priority`, "=", filters.priority);
+  if (filters.sentiment !== undefined)
+    filtered = filtered.where(`${SUPPORT_THREADS_TABLE}.sentiment`, "=", filters.sentiment);
+  if (filters.channel !== undefined)
+    filtered = filtered.where(`${SUPPORT_THREADS_TABLE}.channel`, "=", filters.channel);
+  if (filters.inbox !== undefined)
+    filtered = filtered.where(`${SUPPORT_THREADS_TABLE}.inboxAddress`, "=", filters.inbox);
+  if (filters.assignee !== undefined) {
+    filtered =
+      filters.assignee === UNASSIGNED
+        ? filtered.where(`${SUPPORT_THREADS_TABLE}.assigneeRef`, "is", null)
+        : filtered.where(`${SUPPORT_THREADS_TABLE}.assigneeRef`, "=", filters.assignee);
+  }
+  return filtered;
+}
+
 /**
  * List threads, as one viewer sees them.
  *
@@ -122,91 +198,21 @@ export interface ThreadPage {
 export async function listThreads(
   db: SupportDatabase,
   query: ListThreadsQuery,
-  options: { fts: boolean; viewer: string; now: Date; log?: Logger },
-): Promise<ThreadPage> {
-  try {
-    return await runListThreads(db, query, options);
-  } catch (error) {
-    // **The index being configured on is not the same as the index existing.**
-    //
-    // `search.fts` is a config flag while the virtual table is a provisioned resource, and the two can disagree
-    // in both directions: a project that turned the flag on but has not migrated yet, a database
-    // restored from a snapshot taken before it, a Worker deployed ahead of `pithy migrate`. In every
-    // one of those the flag says FTS and the schema says no such table.
-    //
-    // Falling back to the `LIKE` scan makes that a slower search rather than a 500 on the inbox
-    // route. Narrow on purpose: only a missing-table error is caught, so a genuine query bug still
-    // surfaces instead of silently degrading forever.
-    if (options.fts && isMissingSearchTable(error)) {
-      options.log?.warn("support FTS index is configured but absent — falling back to a LIKE scan", {
-        action: `Run \`${pithyCommandOf("support provision", {}, { runtime: true })}\` to create and backfill it, or set \`search.fts: false\`.`,
-      });
-      return runListThreads(db, query, { ...options, fts: false });
-    }
-    throw error;
-  }
-}
-
-/** Whether an error is SQLite saying the full-text index does not exist. */
-function isMissingSearchTable(error: unknown): boolean {
-  const message = error instanceof Error ? error.message : String(error);
-  return message.includes("no such table") && message.includes(SUPPORT_SEARCH_TABLE);
-}
-
-/** The listing itself, for one chosen search backend. */
-async function runListThreads(
-  db: SupportDatabase,
-  query: ListThreadsQuery,
-  options: { fts: boolean; viewer: string; now: Date },
+  options: { viewer: string; now: Date },
 ): Promise<ThreadPage> {
   const limit = Math.min(Math.max(query.limit ?? DEFAULT_PAGE_SIZE, 1), MAX_PAGE_SIZE);
   const cursor = decodeCursor(query.cursor);
 
-  let builder = db
-    .selectFrom(SUPPORT_THREADS_TABLE)
-    // Joined on the viewer as well as the thread, so one operator's snooze never hides a thread from
-    // anybody else — the whole reason these flags are per viewer rather than on the thread.
-    .leftJoin(SUPPORT_FLAGS_TABLE, (join) =>
-      join
-        .onRef(`${SUPPORT_FLAGS_TABLE}.threadId`, "=", `${SUPPORT_THREADS_TABLE}.id`)
-        .on(`${SUPPORT_FLAGS_TABLE}.viewer`, "=", options.viewer),
-    )
-    .selectAll(SUPPORT_THREADS_TABLE)
-    .select([`${SUPPORT_FLAGS_TABLE}.read as viewerRead`, `${SUPPORT_FLAGS_TABLE}.snoozedUntil as viewerSnoozedUntil`])
+  let builder = applyThreadFilters(viewerThreads(db, options.viewer), query)
     // A snooze that has not expired hides the thread from this viewer. Expiry is evaluated on read
-    // rather than swept, so nothing has to run for a snooze to end.
+    // rather than swept, so nothing has to run for a snooze to end. Listing only: a search finds a
+    // snoozed thread, because a snooze hides work for later and never hides an answer.
     .where((eb) =>
       eb.or([
         eb(`${SUPPORT_FLAGS_TABLE}.snoozedUntil`, "is", null),
         eb(`${SUPPORT_FLAGS_TABLE}.snoozedUntil`, "<=", options.now.getTime()),
       ]),
-    )
-    // Archived is a filter with a default rather than an optional one: an inbox that showed resolved
-    // threads by default would be an inbox nobody trusts to be a work queue.
-    .where(`${SUPPORT_THREADS_TABLE}.archived`, "=", query.archived === true ? 1 : 0);
-
-  if (query.category !== undefined) builder = builder.where(`${SUPPORT_THREADS_TABLE}.category`, "=", query.category);
-  // Its own predicate rather than an `OR` with the one above, because the two answer different
-  // questions and an operator asking both is asking for the threads where they agree — which is the
-  // one shape a single conflated filter could never express.
-  if (query.declaredCategory !== undefined)
-    builder = builder.where(`${SUPPORT_THREADS_TABLE}.declaredCategory`, "=", query.declaredCategory);
-  if (query.priority !== undefined) builder = builder.where(`${SUPPORT_THREADS_TABLE}.priority`, "=", query.priority);
-  if (query.sentiment !== undefined)
-    builder = builder.where(`${SUPPORT_THREADS_TABLE}.sentiment`, "=", query.sentiment);
-  if (query.channel !== undefined) builder = builder.where(`${SUPPORT_THREADS_TABLE}.channel`, "=", query.channel);
-  if (query.inbox !== undefined) builder = builder.where(`${SUPPORT_THREADS_TABLE}.inboxAddress`, "=", query.inbox);
-  if (query.q !== undefined) {
-    if (isSearchable(query.q, options.fts)) {
-      builder = builder.where(searchPredicate(query.q, options));
-    } else {
-      // A term that tokenizes to nothing — `???`, `@@@` — asked a question with no answer, and the
-      // honest answer is none. Dropping the predicate instead would hand back the *entire* unfiltered
-      // inbox rendered as search results, which is the one direction a filter must never fail in:
-      // silently widening reads as "this is what matched" rather than as an error.
-      builder = builder.where(sql<SqlBool>`1 = 0`);
-    }
-  }
+    );
 
   if (cursor) {
     // Strictly after the cursor position in the descending order: an older timestamp, or the same
@@ -231,13 +237,7 @@ async function runListThreads(
     .limit(limit + 1)
     .execute();
 
-  const page: ListedThread[] = rows.slice(0, limit).map((row) => ({
-    ...SupportThread.parse(row),
-    // A viewer with no flag row has read nothing and snoozed nothing, which is the common case and
-    // the right default — not an absence a caller has to interpret.
-    read: row.viewerRead === 1,
-    snoozedUntil: row.viewerSnoozedUntil == null ? null : new Date(Number(row.viewerSnoozedUntil)),
-  }));
+  const page: ListedThread[] = rows.slice(0, limit).map(listedThreadOf);
   const last = page[page.length - 1];
   return {
     threads: page,

package/src/submission/submit.ts

@@ -8,7 +8,7 @@ import { InternalError, ValidationError } from "@pithy-sh/core/src/error/pithyEr
 import type { Logger } from "@pithy-sh/core/src/logger/logger";
 import { attachmentKey, putAttachment, sha256Hex } from "../attachment/store";
 import { SupportAuditActions } from "../audit/actions";
-import type { SupportConfig } from "../config/config";
+import { type SupportConfig, supportSemantic } from "../config/config";
 import { SupportAttachment } from "../data/attachment";
 import { categoryEnum, type SupportCategories } from "../data/categories";
 import { SupportMessage, type SupportSubmissionContext } from "../data/message";
@@ -516,7 +516,8 @@ export async function submitFeedback(deps: SubmitDeps, input: SubmitInput): Prom
 
   // 6. Classification, last and allowed to fail — the same classifier, the same federated taxonomy.
   const classifying = deps.config.ai.enabled;
-  if (classifying) {
+  // The same Workflow embeds the message when semantic search is on.
+  if (classifying || supportSemantic(deps.config.search) !== undefined) {
     try {
       await deps.dispatchClassify(messageId);
     } catch (error) {

package/src/test-utils/seed.ts

@@ -0,0 +1,141 @@
+// SPDX-FileCopyrightText: 2026 Pithy
+// SPDX-License-Identifier: MIT
+
+import type { D1Database } from "@cloudflare/workers-types";
+import { createMigrationRegistry } from "@pithy-sh/core/src/migrations/registry";
+import { runMigrations } from "@pithy-sh/core/src/migrations/runner";
+import { SUPPORT_MIGRATION_ORDER } from "../capability";
+import type { SupportChannel, SupportPriority, SupportSentiment } from "../data/enums";
+import { UNCATEGORIZED } from "../data/enums";
+import { SupportMessage } from "../data/message";
+import { SUPPORT_MESSAGES_TABLE, SUPPORT_THREADS_TABLE, type SupportDatabase } from "../data/tables";
+import { SupportThread } from "../data/thread";
+import { SUPPORT_MIGRATIONS } from "../migrations/set";
+
+/** Rows for Workers tests: a clean support schema, a thread, and a message, each with sensible defaults. */
+
+export const SEED_INBOX = "support@help.example.com";
+
+/** Every table a support test may have left behind, children first. */
+const TABLES = [
+  "pithy_support_search",
+  "pithy_support_embeddings",
+  "pithy_support_assignments",
+  "pithy_support_thread_flags",
+  "pithy_support_classifications",
+  "pithy_support_attachments",
+  "pithy_support_messages",
+  "pithy_support_threads",
+  "pithy_migrations",
+  "pithy_migrations_lock",
+];
+
+/** Drop everything and run the whole chain, so each test starts from today's schema. */
+export async function freshSupportSchema(d1: D1Database): Promise<void> {
+  await d1.exec("DROP TRIGGER IF EXISTS pithy_support_search_ai");
+  await d1.exec("DROP TRIGGER IF EXISTS pithy_support_search_au");
+  await d1.exec("DROP TRIGGER IF EXISTS pithy_support_search_ad");
+  for (const table of TABLES) await d1.exec(`DROP TABLE IF EXISTS ${table}`);
+  const registry = createMigrationRegistry([
+    { database: "app", namespace: "support", order: SUPPORT_MIGRATION_ORDER, migrations: SUPPORT_MIGRATIONS },
+  ]);
+  if (!registry.app) throw new Error('expected a provider for database "app"');
+  await runMigrations(d1, registry.app);
+}
+
+/** Insert one thread. */
+export async function seedThread(
+  db: SupportDatabase,
+  seed: {
+    id: string;
+    lastMessageAt: number;
+    category?: string;
+    declaredCategory?: string;
+    priority?: SupportPriority;
+    sentiment?: SupportSentiment;
+    channel?: SupportChannel;
+    inbox?: string;
+    archived?: boolean;
+    assigneeRef?: string;
+    subject?: string;
+  },
+): Promise<void> {
+  const at = new Date(seed.lastMessageAt);
+  await db
+    .insertInto(SUPPORT_THREADS_TABLE)
+    .values(
+      SupportThread.encode({
+        id: seed.id,
+        channel: seed.channel ?? "email",
+        inboxAddress: seed.inbox ?? SEED_INBOX,
+        subject: seed.subject ?? `Thread ${seed.id}`,
+        fromAddress: "ada@example.com",
+        fromName: null,
+        senderAuthenticated: true,
+        userId: null,
+        declaredCategory: seed.declaredCategory ?? null,
+        category: seed.category ?? UNCATEGORIZED,
+        priority: seed.priority ?? "normal",
+        sentiment: seed.sentiment ?? "neutral",
+        confidence: null,
+        model: null,
+        classifiedAt: null,
+        archived: seed.archived ?? false,
+        archivedAt: null,
+        archivedBy: null,
+        assigneeRef: seed.assigneeRef ?? null,
+        assigneeName: seed.assigneeRef ? `Name ${seed.assigneeRef}` : null,
+        assignedAt: seed.assigneeRef ? at : null,
+        assignedBy: seed.assigneeRef ? "cp-1" : null,
+        messageCount: 1,
+        firstMessageAt: at,
+        lastMessageAt: at,
+        createdAt: at,
+        updatedAt: at,
+      }),
+    )
+    .execute();
+}
+
+/** Insert one message. */
+export async function seedMessage(
+  db: SupportDatabase,
+  seed: {
+    id: string;
+    threadId: string;
+    subject: string;
+    body: string;
+    receivedAt?: number;
+    direction?: "inbound" | "outbound";
+  },
+): Promise<void> {
+  const at = new Date(seed.receivedAt ?? 1_700_000_000_000);
+  await db
+    .insertInto(SUPPORT_MESSAGES_TABLE)
+    .values(
+      SupportMessage.encode({
+        id: seed.id,
+        threadId: seed.threadId,
+        direction: seed.direction ?? "inbound",
+        channel: "email" as const,
+        submittedByUserId: null,
+        context: null,
+        mimeMessageId: `${seed.id}@mail.example.com`,
+        mimeInReplyTo: null,
+        mimeReferences: null,
+        fromAddress: "ada@example.com",
+        fromName: null,
+        toAddress: SEED_INBOX,
+        subject: seed.subject,
+        textBody: seed.body,
+        htmlBody: null,
+        // An outbound mail row names the job it was enqueued as; the schema refuses one that does not.
+        emailJobId: seed.direction === "outbound" ? `job-${seed.id}` : null,
+        rawKey: null,
+        rawBytes: null,
+        receivedAt: at,
+        createdAt: at,
+      }),
+    )
+    .execute();
+}

package/src/test-utils/semantic.ts

@@ -0,0 +1,110 @@
+// SPDX-FileCopyrightText: 2026 Pithy
+// SPDX-License-Identifier: MIT
+
+import type { VectorAi } from "@pithy-sh/vector/src/embed/embed";
+import type { VectorStore, VectorUpsert } from "@pithy-sh/vector/src/index/index";
+
+/**
+ * Stand-ins for Workers AI and Vectorize, for tests only. Cloudflare ships no local emulation of either.
+ *
+ * **The embedder is not random, and that is the point.** It maps words to concepts through a small synonym table
+ * and hashes each concept onto a component, so cosine similarity behaves the way a real model's does for the
+ * cases the tests state: a paraphrase that shares no word with a message still lands near it, and an order
+ * number is just another token. The store scores by cosine and returns ids and scores, as Vectorize does with no
+ * payload requested.
+ */
+
+/** Words that mean the same thing to the fake model. Everything else is its own concept. */
+const CONCEPTS: Record<string, string> = {
+  upload: "upload",
+  uploads: "upload",
+  uploading: "upload",
+  file: "upload",
+  files: "upload",
+  dying: "interrupted",
+  dies: "interrupted",
+  died: "interrupted",
+  timeout: "interrupted",
+  times: "interrupted",
+  timed: "interrupted",
+  halfway: "interrupted",
+  out: "interrupted",
+  refund: "money",
+  charged: "money",
+  money: "money",
+};
+
+function concept(word: string): string {
+  return CONCEPTS[word] ?? word;
+}
+
+function hash(text: string): number {
+  let value = 2166136261;
+  for (const char of text) value = Math.imul(value ^ char.charCodeAt(0), 16777619);
+  return value >>> 0;
+}
+
+/** Embed one text the fake way: concept counts, hashed onto components, unit length. */
+export function fakeEmbedding(text: string, dimensions: number): number[] {
+  const vector = new Array<number>(dimensions).fill(0);
+  const words = text.toLowerCase().match(/[\p{L}\p{N}-]+/gu) ?? [];
+  for (const word of words) {
+    const at = hash(concept(word)) % dimensions;
+    vector[at] = (vector[at] ?? 0) + 1;
+  }
+  const length = Math.hypot(...vector) || 1;
+  return vector.map((component) => component / length);
+}
+
+/** A fake `AI` binding: records every call and answers the shape a text-embedding model does. */
+export function fakeAi(dimensions: number): VectorAi & { calls: { model: string; texts: string[] }[]; fail: boolean } {
+  const ai = {
+    calls: [] as { model: string; texts: string[] }[],
+    fail: false,
+    async run(model: string, input: Record<string, unknown>) {
+      const texts = input.text as string[];
+      ai.calls.push({ model, texts });
+      if (ai.fail) throw new Error("Workers AI is unavailable");
+      return { shape: [texts.length, dimensions], data: texts.map((text) => fakeEmbedding(text, dimensions)) };
+    },
+  };
+  return ai;
+}
+
+/** A fake Vectorize binding: an in-memory map, scored by cosine, with every upsert kept for inspection. */
+export function fakeVectorStore(): VectorStore & {
+  vectors: Map<string, number[]>;
+  upserts: VectorUpsert[][];
+  queries: Record<string, unknown>[];
+} {
+  const vectors = new Map<string, number[]>();
+  const upserts: VectorUpsert[][] = [];
+  const queries: Record<string, unknown>[] = [];
+  let mutation = 0;
+  return {
+    vectors,
+    upserts,
+    queries,
+    async upsert(batch) {
+      upserts.push(batch);
+      for (const vector of batch) vectors.set(vector.id, vector.values);
+      mutation += 1;
+      return { mutationId: `m-${mutation}` };
+    },
+    async query(vector, options = {}) {
+      queries.push(options);
+      const topK = Number(options.topK ?? 10);
+      const matches = [...vectors.entries()]
+        .map(([id, values]) => ({ id, score: values.reduce((sum, value, at) => sum + value * (vector[at] ?? 0), 0) }))
+        .filter((match) => match.score > 0)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, topK);
+      return { count: matches.length, matches };
+    },
+    async deleteByIds(ids) {
+      for (const id of ids) vectors.delete(id);
+      mutation += 1;
+      return { mutationId: `m-${mutation}` };
+    },
+  };
+}

package/src/version.generated.ts

@@ -13,4 +13,4 @@
 export const PACKAGE_NAME = "@pithy-sh/support";
 
 /** This package's version, stamped from its own package.json at generation time. */
-export const PACKAGE_VERSION = "0.5.1";
+export const PACKAGE_VERSION = "0.6.1";

package/src/workflows/specs.ts

@@ -37,6 +37,32 @@ export const SupportClassifyParams = z
   .describe("The instance parameters of the classification Workflow — the one message it runs against.");
 export type SupportClassifyParams = z.infer<typeof SupportClassifyParams>;
 
+/**
+ * One re-embed of the semantic message index, started by `pithy vector reprocess --index support-messages`.
+ *
+ * The parameters are the ones `pithy vector reprocess` sends every index, so the CLI dispatches a capability's
+ * index exactly as it dispatches one `vector()` owns. There is no `filter`: the vectors carry no metadata to
+ * filter on.
+ */
+export const SupportReprocessParams = z
+  .object({
+    index: z.literal("support-messages").describe("The index to re-embed. Support declares one, `support-messages`."),
+    all: z
+      .boolean()
+      .optional()
+      .describe(
+        "Re-embed every inbound message, not only the ones whose stamp differs from the configured model. What a fresh index's backfill runs.",
+      ),
+    pageSize: z
+      .number()
+      .int()
+      .min(1)
+      .optional()
+      .describe("Messages per Workflow step. Defaults to the Vectorize upsert ceiling of 1,000."),
+  })
+  .describe("The instance parameters of a re-embed of the support message index.");
+export type SupportReprocessParams = z.infer<typeof SupportReprocessParams>;
+
 /** Support's durable jobs, keyed by job name. The key is the second segment of the `support/<job>` dispatch key. */
 export const supportWorkflows = {
   classify: {
@@ -45,6 +71,14 @@ export const supportWorkflows = {
     params: SupportClassifyParams,
     optional: true,
   },
+  // Hosted beside classification, in the same prebuilt worker, because it needs the same three things: the
+  // app database, the `AI` binding, and the message index. Optional for the same reason classify is.
+  reprocess: {
+    binding: "SUPPORT_REPROCESS",
+    className: "SupportReprocessWorkflow",
+    params: SupportReprocessParams,
+    optional: true,
+  },
 } as const satisfies WorkflowSpecMap;
 
 /**