@pithy-sh/support 0.5.1 → 0.6.0

package/README.md

@@ -10,8 +10,16 @@ pithy add support
 
 **Documentation: [pithy.sh/docs/capabilities/support](https://pithy.sh/docs/capabilities/support).** Overview, adding it, using it, and the reference: the MX constraint, provisioning, classification, provenance.
 
+**A shared inbox.** Assign a conversation to somebody, filter the inbox by who has it, and see who else has a thread open before you reply: `POST /support/threads/:id/assign` behind `support:threads:assign`, `assignee=<ref>` or `assignee=none` on the listing, every handover kept in the thread's history, and one `support.thread` presence room per thread, with `viewing` and `replying`. Your own signed-in staff reach both through `support({ staff: { readPower, assignPower } })`, on unassignable roles other than the one ownership transfer confers, so only an operator can confer them. The seam is [`docs/CONTROL-PLANE.md`](../../docs/CONTROL-PLANE.md).
+
+**Search, by words and by meaning.** `GET /support/threads/search` takes `q`, a `mode` (`keyword`, `semantic` or `hybrid`), a `limit` (20, at most 50) and the inbox list's filters, and returns ranked threads, each named by its best-matching message with that message's raw `bm25` and similarity. Keyword is FTS5 with `search.fts` on and the `LIKE` scan otherwise; hybrid fuses it with semantic search by rank, so a paraphrase is found and an order number still comes first. The inbox list no longer takes `q`. **Semantic search costs a second inference per inbound message on your own Workers AI binding**, on top of classification — roughly double the per-message AI cost — so `search: { semantic: true }` is off until you turn it on. `pithy support provision` creates the Vectorize index and backfills it once, and `pithy vector reprocess --index support-messages` re-embeds after a model change, with no `vector()` composed. Vectors carry message ids only. See [`docs/commands/support.md`](../../docs/commands/support.md#search).
+
 _Everything else is on the site. `pithy.sh/docs` is canonical — new prose goes there, not here._
 
+## A person's data
+
+**Erased.** When an account is purged, support deletes every thread linked to the account, or sent from its address and linked to no other account, with every message, attachment and raw mail in R2, classification, read state and assignment history, and each message's vector in the semantic index with its model stamp, and an export hands the threads, messages, attachments and assignment history back first. The export leaves out who made each assignment: that is the operator's, and the audit trail keeps it with its actor. A staff member's purge takes their id off every handover they made as a signed-in user on someone else's thread, and their export lists those handovers by thread and time, without the assignee or the note. Who held a thread is kept until the customer's thread goes: an assignee is an opaque reference and a name the assigner chose, and support cannot tell which reference is a person. See [`@pithy-sh/auth`'s account lifecycle](../auth/docs/account-lifecycle.md#what-each-capability-does-with-a-persons-rows).
+
 ## License
 
 MIT.

package/dist/audit/actions.d.ts

@@ -29,6 +29,15 @@ export declare const SupportAuditActions: {
     readonly threadArchived: "support/thread_archived";
     /** A thread was taken back out of the archive. Recorded separately, because undoing is its own decision. */
     readonly threadUnarchived: "support/thread_unarchived";
+    /**
+     * A thread was given to somebody, or handed from one person to another (#816). Audited because who has
+     * a customer's conversation decides who answers them, and the thread keeps only the current answer.
+     * Metadata: the previous assignee, the new one, and the assigner's note — staff words, never mail.
+     * Reassigning the current assignee changes nothing and emits nothing.
+     */
+    readonly threadAssigned: "support/thread_assigned";
+    /** A thread's assignee was cleared. Its own action, because giving a conversation up is its own decision. */
+    readonly threadUnassigned: "support/thread_unassigned";
     /**
      * A reply went out. Audited because it leaves under the adopter's domain and their DKIM: to the
      * recipient it is indistinguishable from the founder writing it, so who actually sent it is a

package/dist/audit/actions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../src/audit/actions.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,mBAAmB;IAC9B;;;;OAIG;aACH,cAAc,EAAE,yBAAyB;IACzC,4GAA4G;aAC5G,gBAAgB,EAAE,2BAA2B;IAC7C;;;;OAIG;aACH,SAAS,EAAE,oBAAoB;IAC/B;;;OAGG;aACH,kBAAkB,EAAE,6BAA6B;IACjD;;;;;;;OAOG;aACH,eAAe,EAAE,0BAA0B;IAC3C;;;;;;;;;;;;;OAaG;aACH,kBAAkB,EAAE,6BAA6B;CACzC,CAAC;AAEX,6CAA6C;AAC7C,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,OAAO,mBAAmB,CAAC,CAAC"}
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../src/audit/actions.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,mBAAmB;IAC9B;;;;OAIG;aACH,cAAc,EAAE,yBAAyB;IACzC,4GAA4G;aAC5G,gBAAgB,EAAE,2BAA2B;IAC7C;;;;;OAKG;aACH,cAAc,EAAE,yBAAyB;IACzC,6GAA6G;aAC7G,gBAAgB,EAAE,2BAA2B;IAC7C;;;;OAIG;aACH,SAAS,EAAE,oBAAoB;IAC/B;;;OAGG;aACH,kBAAkB,EAAE,6BAA6B;IACjD;;;;;;;OAOG;aACH,eAAe,EAAE,0BAA0B;IAC3C;;;;;;;;;;;;;OAaG;aACH,kBAAkB,EAAE,6BAA6B;CACzC,CAAC;AAEX,6CAA6C;AAC7C,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/audit/actions.js

@@ -31,6 +31,15 @@ const SupportAuditActions = {
 	/** A thread was taken back out of the archive. Recorded separately, because undoing is its own decision. */
 	threadUnarchived: "support/thread_unarchived",
 	/**
+	* A thread was given to somebody, or handed from one person to another (#816). Audited because who has
+	* a customer's conversation decides who answers them, and the thread keeps only the current answer.
+	* Metadata: the previous assignee, the new one, and the assigner's note — staff words, never mail.
+	* Reassigning the current assignee changes nothing and emits nothing.
+	*/
+	threadAssigned: "support/thread_assigned",
+	/** A thread's assignee was cleared. Its own action, because giving a conversation up is its own decision. */
+	threadUnassigned: "support/thread_unassigned",
+	/**
 	* A reply went out. Audited because it leaves under the adopter's domain and their DKIM: to the
 	* recipient it is indistinguishable from the founder writing it, so who actually sent it is a
 	* security-relevant fact with no other record.

package/dist/capability.d.ts

@@ -80,7 +80,8 @@ export interface SupportCapability extends Capability<DatabaseSpecMap, KvNamespa
  * The support capability — an inbound support inbox in the adopter's own D1, classified on their own
  * Workers AI binding.
  *
- * It contributes five tables (and optionally a full-text index) to the app `DB`, an `email()` handler
+ * It contributes its tables (and optionally a full-text index, and a semantic message index in Vectorize) to the
+ * app `DB`, an `email()` handler
  * that claims the configured addresses out of the Worker's single inbound entry, the classification
  * Workflow that handler dispatches to, and a control-plane admin surface for a dashboard to read and
  * act on.

package/dist/capability.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"capability.d.ts","sourceRoot":"","sources":["../src/capability.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mCAAmC,CAAC;AAGnE,OAAO,EAAE,KAAK,UAAU,EAAoB,MAAM,0CAA0C,CAAC;AAC7F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACzE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AAE3E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AAItE,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,kBAAkB,EAGxB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAqB,KAAK,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAO9E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD,OAAO,EAAkB,KAAK,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAI7E,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAErD;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB,OAAO,CAAC;AAE5C,+FAA+F;AAC/F,MAAM,MAAM,cAAc,GAAG,kBAAkB,GAAG;IAChD,6EAA6E;IAC7E,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,2BAA2B;IAC3B,MAAM,EAAE,aAAa,CAAC;IACtB,8BAA8B;IAC9B,UAAU,EAAE,iBAAiB,CAAC;IAC9B,0CAA0C;IAC1C,QAAQ,EAAE,oBAAoB,CAAC;IAC/B;;;;;OAKG;IACH,YAAY,EAAE,eAAe,CAAC,SAAS,CAAC,GAAG,SAAS,CAAC;IACrD;;;OAGG;IACH,KAAK,EAAE,WAAW,CAAC;IACnB;;;;;;;;OAQG;IACH,IAAI,EAAE,SAAS,CAAC;CACjB;AA4ED;;;;;GAKG;AACH,MAAM,WAAW,iBACf,SAAQ,UAAU,CAAC,eAAe,EAAE,kBAAkB,EAAE,SAAS,EAAE,OAAO,gBAAgB,CAAC;IAC3F,mCAAmC;IACnC,aAAa,EAAE,aAAa,CAAC;IAC7B,wGAAwG;IACxG,UAAU,EAAE,iBAAiB,CAAC;IAC9B,0CAA0C;IAC1C,QAAQ,EAAE,oBAAoB,CAAC;IAC/B,iFAAiF;IACjF,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,OAAO,CAAC,OAAO,GAAE,cAAmB,GAAG,iBAAiB,CA0GvE;AAED,2GAA2G;AAC3G,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,UAAU,GAAG,UAAU,IAAI,iBAAiB,CAE3F"}
+{"version":3,"file":"capability.d.ts","sourceRoot":"","sources":["../src/capability.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mCAAmC,CAAC;AAGnE,OAAO,EAAE,KAAK,UAAU,EAAoB,MAAM,0CAA0C,CAAC;AAC7F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACzE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AAE3E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AAItE,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,kBAAkB,EAGxB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAqB,KAAK,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAO9E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAIjD,OAAO,EAAkB,KAAK,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAW7E,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAErD;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB,OAAO,CAAC;AAE5C,+FAA+F;AAC/F,MAAM,MAAM,cAAc,GAAG,kBAAkB,GAAG;IAChD,6EAA6E;IAC7E,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,2BAA2B;IAC3B,MAAM,EAAE,aAAa,CAAC;IACtB,8BAA8B;IAC9B,UAAU,EAAE,iBAAiB,CAAC;IAC9B,0CAA0C;IAC1C,QAAQ,EAAE,oBAAoB,CAAC;IAC/B;;;;;OAKG;IACH,YAAY,EAAE,eAAe,CAAC,SAAS,CAAC,GAAG,SAAS,CAAC;IACrD;;;OAGG;IACH,KAAK,EAAE,WAAW,CAAC;IACnB;;;;;;;;OAQG;IACH,IAAI,EAAE,SAAS,CAAC;CACjB;AA4ED;;;;;GAKG;AACH,MAAM,WAAW,iBACf,SAAQ,UAAU,CAAC,eAAe,EAAE,kBAAkB,EAAE,SAAS,EAAE,OAAO,gBAAgB,CAAC;IAC3F,mCAAmC;IACnC,aAAa,EAAE,aAAa,CAAC;IAC7B,wGAAwG;IACxG,UAAU,EAAE,iBAAiB,CAAC;IAC9B,0CAA0C;IAC1C,QAAQ,EAAE,oBAAoB,CAAC;IAC/B,iFAAiF;IACjF,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,OAAO,CAAC,OAAO,GAAE,cAAmB,GAAG,iBAAiB,CAuIvE;AAED,2GAA2G;AAC3G,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,UAAU,GAAG,UAAU,IAAI,iBAAiB,CAE3F"}

package/dist/capability.js

@@ -5,13 +5,17 @@ import { SupportConfig, supportNeedsBucket } from "./config/config.js";
 import { resolveCategories } from "./data/categories.js";
 import { supportTables } from "./data/tables.js";
 import { SUPPORT_BUCKET_BINDING, inapplicableAttachmentSecrets, supportSecretsRegistry } from "./secret/registry.js";
+import { SUPPORT_MESSAGES_INDEX, SUPPORT_VECTORIZE_BINDING, supportMessageIndex } from "./semantic/messageIndex.js";
 import { supportWorkflows } from "./workflows/specs.js";
 import { makeResolveDeps } from "./http/resolve.js";
+import { assertStaffComposition } from "./staff/staff.js";
 import { supportAdminRoutes } from "./http/scopes.js";
 import { registerSupportRoutes } from "./http/routes.js";
 import { createSupportEmailHandler } from "./inbound/handler.js";
 import { senderPeers } from "./link/peers.js";
-import { support_0001_threads } from "./migrations/0001_threads.js";
+import { SUPPORT_MIGRATIONS } from "./migrations/set.js";
+import { supportPresence } from "./presence/room.js";
+import { supportUserPurge } from "./purge/contribution.js";
 import { supportExampleSeed } from "./seeds/example.js";
 import { PACKAGE_NAME, PACKAGE_VERSION } from "./version.generated.js";
 import { noopEmit } from "@pithy-sh/core/src/audit/recorder";
@@ -98,7 +102,8 @@ function clientProjection(config, basePath) {
 * The support capability — an inbound support inbox in the adopter's own D1, classified on their own
 * Workers AI binding.
 *
-* It contributes five tables (and optionally a full-text index) to the app `DB`, an `email()` handler
+* It contributes its tables (and optionally a full-text index, and a semantic message index in Vectorize) to the
+* app `DB`, an `email()` handler
 * that claims the configured addresses out of the Worker's single inbound entry, the classification
 * Workflow that handler dispatches to, and a control-plane admin surface for a dashboard to read and
 * act on.
@@ -127,7 +132,7 @@ function support(options = {}) {
 		peers: {},
 		emit: noopEmit
 	};
-	const migrations = { "0001_threads": support_0001_threads };
+	const migrations = SUPPORT_MIGRATIONS;
 	const requiredBindings = [
 		{
 			type: "d1",
@@ -138,7 +143,17 @@ function support(options = {}) {
 			name: SUPPORT_BUCKET_BINDING,
 			optional: true
 		}] : [],
-		...workflowBindings(supportWorkflows)
+		...workflowBindings(supportWorkflows),
+		...supportMessageIndex(resolved.search) ? [{
+			type: "vectorize",
+			name: SUPPORT_VECTORIZE_BINDING,
+			optional: true,
+			remote: true
+		}, {
+			type: "ai",
+			name: "AI",
+			remote: true
+		}] : []
 	];
 	const capability = defineCapability({
 		name: "support",
@@ -164,20 +179,29 @@ function support(options = {}) {
 		* able to answer is a coherent and useful thing, so a missing email capability degrades one
 		* route instead of refusing to boot.
 		*/
+		...resolved.staff ? { powers: [resolved.staff.readPower, resolved.staff.assignPower] } : {},
 		compose: ({ capabilities }) => {
+			assertStaffComposition(resolved.staff, capabilities);
 			const email = capabilities.find(isEmailCapability);
 			wiring.enqueueEmail = email?.enqueue;
 			wiring.peers = senderPeers(capabilities, resolved);
 		},
 		client: () => clientProjection(resolved, mountPath),
 		adminRoutes: supportAdminRoutes(mountPath),
+		...supportMessageIndex(resolved.search) ? { vectorIndexes: [{
+			name: SUPPORT_MESSAGES_INDEX,
+			reprocessJob: "reprocess"
+		}] } : {},
+		presence: supportPresence(mountPath, wiring),
 		routes: registerSupportRoutes({
 			basePath: mountPath,
 			submission: resolved.submission.enabled,
-			resolveDeps: makeResolveDeps(wiring)
+			resolveDeps: makeResolveDeps(wiring),
+			staff: resolved.staff
 		}),
 		email: createSupportEmailHandler(wiring),
-		seeds: [supportExampleSeed]
+		seeds: [supportExampleSeed],
+		purge: [supportUserPurge("DB", { semantic: supportMessageIndex(resolved.search) !== void 0 })]
 	});
 	return Object.assign(capability, {
 		supportConfig: resolved,

package/dist/config/config.d.ts

@@ -136,17 +136,70 @@ export declare const SupportReplyConfig: z.ZodObject<{
     }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type SupportReplyConfig = z.output<typeof SupportReplyConfig>;
+/**
+ * The default embedding model for semantic search — the kit's own default (`DEFAULT_EMBEDDING_MODEL` in
+ * `@pithy-sh/cloudflare/src/ai/aiManager.ts`), restated rather than imported because a Worker cannot reach
+ * the REST client package and should not.
+ *
+ * **Multilingual, and that is why.** An inbox takes mail in whatever language the customer writes, and an
+ * English-only model would embed a Spanish complaint into the wrong neighborhood with no error.
+ */
+export declare const DEFAULT_EMBEDDING_MODEL = "@cf/baai/bge-m3";
+/**
+ * How many components `bge-m3` produces. It is not a Vectorize preset, so the index states its own shape;
+ * a model override that produces another width states its `dimensions` beside it.
+ */
+export declare const DEFAULT_EMBEDDING_DIMENSIONS = 1024;
+/** The `{ model }` form of `search.semantic`: semantic search on, with a model of your choosing. */
+export declare const SupportSemanticConfig: z.ZodObject<{
+    model: z.ZodDefault<z.ZodString>;
+    dimensions: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type SupportSemanticConfig = z.output<typeof SupportSemanticConfig>;
 /**
  * How text search is answered.
  *
- * The one setting here has a cost an adopter must opt into knowingly, which is why it is a setting
- * at all rather than a decision this package made for them.
+ * FTS5 by default, with the `LIKE` scan kept for a project that wants no virtual table at all. Semantic
+ * search is off by default because it costs a second inference per inbound message.
  */
 export declare const SupportSearchConfig: z.ZodObject<{
+    semantic: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+        model: z.ZodDefault<z.ZodString>;
+        dimensions: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>]>>;
     fts: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>;
 export type SupportSearchConfig = z.output<typeof SupportSearchConfig>;
+/**
+ * The semantic model and width this configuration asks for, or `undefined` when semantic search is off.
+ *
+ * The one reading of the three-shaped flag — `false`, `true`, `{ model }` — so the capability's bindings,
+ * the search route, the classification Workflow and provisioning cannot each decide what `true` means.
+ */
+export declare function supportSemantic(search: SupportSearchConfig): SupportSemanticConfig | undefined;
 /** The full support configuration. */
+/**
+ * **Who of the app's own signed-in users works the inbox (#816).** Off until named.
+ *
+ * The inbox holds every customer's correspondence, so a signed-in user reaches it only through a power the
+ * adopter names in their own role catalog, held in the organization the request acts for — the same seam
+ * `media:manage` and `storage:manage` ask, and the same rule `artifacts({ managePower })` follows: a
+ * capability never reserves a power name in a catalog that is the adopter's.
+ *
+ * **Both powers must sit only on roles no organization can hand itself** — listed in
+ * `defineRoles({ unassignable })`, and not the role `organization({ ownership })` confers — and `support()`
+ * refuses the composition otherwise. A role is the catalog's, not one organization's, and an organization's
+ * own administrator may give any assignable role to their own members — so a support power on an assignable
+ * role would let any customer's administrator make themselves staff and read every other customer's mail.
+ * The ownership role is unassignable and still self-served: anybody may found an organization, nominate
+ * themselves its owner, and accept. On any other unassignable role it is conferred by an operator alone,
+ * through the control plane.
+ */
+export declare const SupportStaffConfig: z.ZodObject<{
+    readPower: z.ZodString;
+    assignPower: z.ZodString;
+}, z.core.$strip>;
+export type SupportStaffConfig = z.output<typeof SupportStaffConfig>;
 export declare const SupportConfig: z.ZodObject<{
     inboundAddresses: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
     categories: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
@@ -193,8 +246,16 @@ export declare const SupportConfig: z.ZodObject<{
         }, z.core.$strip>>>;
     }, z.core.$strip>>;
     search: z.ZodPrefault<z.ZodObject<{
+        semantic: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+            model: z.ZodDefault<z.ZodString>;
+            dimensions: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>]>>;
         fts: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strip>>;
+    staff: z.ZodOptional<z.ZodObject<{
+        readPower: z.ZodString;
+        assignPower: z.ZodString;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type SupportConfig = z.output<typeof SupportConfig>;
 export type SupportConfigInput = z.input<typeof SupportConfig>;

package/dist/config/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/config/config.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;;;;;GAUG;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,mCAAmC,CAAC;AAEvE,0DAA0D;AAC1D,eAAO,MAAM,eAAe;;;;;iBA+BkF,CAAC;AAC/G,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,eAAe,CAAC,CAAC;AAE/D,+DAA+D;AAC/D,eAAO,MAAM,wBAAwB;;;;;iBA6BkF,CAAC;AACxH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAEjF;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB;;;;;;;iBA8C8D,CAAC;AAC9F,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAErE;;;;;;;;;;;;;;;GAeG;AACH;;;;;;;GAOG;AACH,eAAO,MAAM,0BAA0B,KAAK,CAAC;AAE7C,eAAO,MAAM,kCAAkC;;;;;iBAkC5C,CAAC;AACJ,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kCAAkC,CAAC,CAAC;AAErG;;;;;;;;;GASG;AACH,eAAO,MAAM,4BAA4B,MAAM,CAAC;AAChD,2FAA2F;AAC3F,eAAO,MAAM,yBAAyB,SAAU,CAAC;AAEjD;;;;;;;;;;;;;GAaG;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;iBAwCjC,CAAC;AACJ,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE/E,uCAAuC;AACvC,eAAO,MAAM,kBAAkB;;;;;;;;;iBAmC5B,CAAC;AACJ,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAErE;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;;iBAS8D,CAAC;AAC/F,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEvE,sCAAsC;AACtC,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiCvB,CAAC;AACJ,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,aAAa,CAAC,CAAC;AAC3D,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAE/D;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAEjE"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/config/config.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;;;;;GAUG;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,mCAAmC,CAAC;AAEvE,0DAA0D;AAC1D,eAAO,MAAM,eAAe;;;;;iBA+BkF,CAAC;AAC/G,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,eAAe,CAAC,CAAC;AAE/D,+DAA+D;AAC/D,eAAO,MAAM,wBAAwB;;;;;iBA6BkF,CAAC;AACxH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAEjF;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB;;;;;;;iBA8C8D,CAAC;AAC9F,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAErE;;;;;;;;;;;;;;;GAeG;AACH;;;;;;;GAOG;AACH,eAAO,MAAM,0BAA0B,KAAK,CAAC;AAE7C,eAAO,MAAM,kCAAkC;;;;;iBAkC5C,CAAC;AACJ,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kCAAkC,CAAC,CAAC;AAErG;;;;;;;;;GASG;AACH,eAAO,MAAM,4BAA4B,MAAM,CAAC;AAChD,2FAA2F;AAC3F,eAAO,MAAM,yBAAyB,SAAU,CAAC;AAEjD;;;;;;;;;;;;;GAaG;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;iBAwCjC,CAAC;AACJ,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE/E,uCAAuC;AACvC,eAAO,MAAM,kBAAkB;;;;;;;;;iBAmC5B,CAAC;AACJ,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAErE;;;;;;;GAOG;AACH,eAAO,MAAM,uBAAuB,oBAAoB,CAAC;AAEzD;;;GAGG;AACH,eAAO,MAAM,4BAA4B,OAAO,CAAC;AAEjD,oGAAoG;AACpG,eAAO,MAAM,qBAAqB;;;iBAmB2B,CAAC;AAC9D,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAE3E;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;;;;;;iBAiB7B,CAAC;AACJ,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEvE;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,mBAAmB,GAAG,qBAAqB,GAAG,SAAS,CAI9F;AAED,sCAAsC;AACtC;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,kBAAkB;;;iBAiB5B,CAAC;AACJ,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAErE,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoCvB,CAAC;AACJ,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,aAAa,CAAC,CAAC;AAC3D,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAE/D;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAEjE"}

package/dist/config/config.js

@@ -132,13 +132,70 @@ const SupportReplyConfig = z.object({
 	snippets: z.record(z.string(), SupportReplySnippet).default({}).describe("Your own canned replies, merged over the ones Pithy ships and winning on a key collision. These are *starting points a human picks and edits* in the dashboard, not automatic replies — nothing here is ever sent without somebody pressing send. Author them with `defineSupportReplies` so a malformed one fails where it is written.")
 }).describe("Reply settings — whether replies are allowed, where the answer goes, and what to offer as a starting point.");
 /**
+* The default embedding model for semantic search — the kit's own default (`DEFAULT_EMBEDDING_MODEL` in
+* `@pithy-sh/cloudflare/src/ai/aiManager.ts`), restated rather than imported because a Worker cannot reach
+* the REST client package and should not.
+*
+* **Multilingual, and that is why.** An inbox takes mail in whatever language the customer writes, and an
+* English-only model would embed a Spanish complaint into the wrong neighborhood with no error.
+*/
+const DEFAULT_EMBEDDING_MODEL = "@cf/baai/bge-m3";
+/**
+* How many components `bge-m3` produces. It is not a Vectorize preset, so the index states its own shape;
+* a model override that produces another width states its `dimensions` beside it.
+*/
+const DEFAULT_EMBEDDING_DIMENSIONS = 1024;
+/** The `{ model }` form of `search.semantic`: semantic search on, with a model of your choosing. */
+const SupportSemanticConfig = z.object({
+	model: z.string().min(1).default(DEFAULT_EMBEDDING_MODEL).describe("The Workers AI embedding model the message index is built and queried with. Pinned: change it and `pithy vector reprocess --index support-messages` re-embeds what the old one wrote."),
+	dimensions: z.number().int().min(1).max(1536).default(DEFAULT_EMBEDDING_DIMENSIONS).describe("How many components the model produces — 1024 for `bge-m3`, 768 for `bge-base-en-v1.5`. Fixed when the index is created, so a model of another width needs the index dropped and recreated.")
+}).describe("Semantic search with a chosen embedding model.");
+/**
 * How text search is answered.
 *
-* The one setting here has a cost an adopter must opt into knowingly, which is why it is a setting
-* at all rather than a decision this package made for them.
+* FTS5 by default, with the `LIKE` scan kept for a project that wants no virtual table at all. Semantic
+* search is off by default because it costs a second inference per inbound message.
 */
-const SupportSearchConfig = z.object({ fts: z.boolean().default(false).describe("Build a SQLite FTS5 index over message subjects and bodies. **Off by default, and the reason is not performance.** `wrangler d1 export` refuses to dump any database containing an FTS5 virtual table — it fails outright rather than skipping the table — and the check runs server-side across the whole database before `--table` filtering, so turning this on takes your **entire app database's** export with it. A failed attempt has also been reported to leave the database inaccessible until it clears. If you do not use `wrangler d1 export`, none of that reaches you and FTS5 is the better search. Safe to toggle either way: the index is derived rather than migrated, so `pithy support provision` creates or drops it to match — and until you re-provision, search falls back to the `LIKE` scan rather than failing.") }).describe("Text search settings — the `LIKE` scan by default, FTS5 as a deliberate opt-in.");
+const SupportSearchConfig = z.object({
+	semantic: z.union([z.boolean(), SupportSemanticConfig]).default(false).describe("Search by meaning as well as by words: `true` for the default model (`@cf/baai/bge-m3`), or `{ model }` for your own. **Off by default, and the reason is cost.** Every inbound message is embedded once, on your own Workers AI binding, in the classification Workflow — a second inference per message on top of classification, which roughly doubles this capability's per-message AI cost. The volume guard bounds messages, not spend. On, `pithy support provision` creates a Vectorize index and backfills it once; off, it drops the index. Vectors carry message ids and nothing else."),
+	fts: z.boolean().default(true).describe("Build a SQLite FTS5 index over message subjects and bodies — a ranked word search instead of an unindexed `LIKE` scan. **On by default.** A plain `wrangler d1 export` of a database holding an FTS5 table fails outright, so `pithy backup` leaves the index and its triggers out and `pithy restore` rebuilds them from `pithy_support_messages`; the bare `wrangler` route has to skip it by hand. The index is derived rather than migrated, so `pithy support provision` creates or drops it to match this flag, and until a project re-provisions, search falls back to the `LIKE` scan and `pithy doctor` names the environment.")
+}).describe("Search settings — FTS5 by default, the `LIKE` scan when it is off or not yet provisioned, and semantic search an opt-in priced in resources you own.");
+/**
+* The semantic model and width this configuration asks for, or `undefined` when semantic search is off.
+*
+* The one reading of the three-shaped flag — `false`, `true`, `{ model }` — so the capability's bindings,
+* the search route, the classification Workflow and provisioning cannot each decide what `true` means.
+*/
+function supportSemantic(search) {
+	if (search.semantic === false) return void 0;
+	if (search.semantic === true) return {
+		model: DEFAULT_EMBEDDING_MODEL,
+		dimensions: DEFAULT_EMBEDDING_DIMENSIONS
+	};
+	return search.semantic;
+}
 /** The full support configuration. */
+/**
+* **Who of the app's own signed-in users works the inbox (#816).** Off until named.
+*
+* The inbox holds every customer's correspondence, so a signed-in user reaches it only through a power the
+* adopter names in their own role catalog, held in the organization the request acts for — the same seam
+* `media:manage` and `storage:manage` ask, and the same rule `artifacts({ managePower })` follows: a
+* capability never reserves a power name in a catalog that is the adopter's.
+*
+* **Both powers must sit only on roles no organization can hand itself** — listed in
+* `defineRoles({ unassignable })`, and not the role `organization({ ownership })` confers — and `support()`
+* refuses the composition otherwise. A role is the catalog's, not one organization's, and an organization's
+* own administrator may give any assignable role to their own members — so a support power on an assignable
+* role would let any customer's administrator make themselves staff and read every other customer's mail.
+* The ownership role is unassignable and still self-served: anybody may found an organization, nominate
+* themselves its owner, and accept. On any other unassignable role it is conferred by an operator alone,
+* through the control plane.
+*/
+const SupportStaffConfig = z.object({
+	readPower: z.string().min(1).describe("The power that lets a signed-in user see who else has a thread open — what the `support.thread` presence room's session ticket asks. Your own name, declared in your role catalog on unassignable roles only, and not on the role ownership transfer confers, e.g. `support:read`."),
+	assignPower: z.string().min(1).describe("The power that lets a signed-in user assign a thread, to themselves or to somebody else, at `POST {basePath}/staff/threads/:id/assign`. Your own name, declared in your role catalog on unassignable roles only, and not on the role ownership transfer confers, e.g. `support:assign`.")
+}).describe("Who of your app's own signed-in users works the inbox, by the organization powers their role holds. Requires `organization`, and both powers on unassignable roles other than the one ownership transfer confers. Absent, no signed-in user can assign a thread or join a thread's presence room — management clients still can, through the control plane.");
 const SupportConfig = z.object({
 	inboundAddresses: z.array(z.string().min(3).describe("One address this inbox accepts mail for, e.g. `support@help.example.com`.").transform((address) => parseAddress(address) ?? normalizeAddress(address))).default([]).describe("The addresses this capability claims. Every capability's `email()` handler sees every message the Worker receives, so this list is how support tells its mail apart from the bounce handler's — and it is a claim, not a route: the routing rule that delivers to this Worker is created by `pithy support provision`. **Use a subdomain, never your apex**: Email Routing takes over the zone's MX, and enabling it on the apex moves your real mail off your provider. Empty means the inbox is inert."),
 	categories: z.record(z.string(), z.string()).default({}).describe("Your own categories, merged over the eight Pithy ships and winning on a key collision. A key is `snake_case`; the value is the instruction a model reads when deciding whether this is the one, and it lands in the prompt verbatim. Author it with `defineSupportCategories` so a typo fails where it is written."),
@@ -147,7 +204,8 @@ const SupportConfig = z.object({
 	guard: SupportGuardConfig.prefault({}).describe("Inbound mail size and rate bounds."),
 	submission: SupportSubmissionConfig.prefault({}).describe("The in-app submission channel."),
 	reply: SupportReplyConfig.prefault({}).describe("Reply settings."),
-	search: SupportSearchConfig.prefault({}).describe("How text search is answered.")
+	search: SupportSearchConfig.prefault({}).describe("How text search is answered."),
+	staff: SupportStaffConfig.optional().describe("Who of your app's signed-in users works the inbox, by organization power. Absent, the staff session routes refuse everyone.")
 }).describe("Configuration for the support capability — which addresses it claims, and how it classifies and bounds them.");
 /**
 * Would this configuration ever put a byte in `SUPPORT_BUCKET`?
@@ -168,4 +226,4 @@ function supportNeedsBucket(config) {
 	return config.attachments.enabled || config.attachments.retainRaw || config.submission.attachments.enabled;
 }
 //#endregion
-export { DEFAULT_CLASSIFY_MODEL, MAX_SUBMISSION_ATTACHMENTS, MAX_SUBMISSION_BODY_CHARS, MAX_SUBMISSION_SUBJECT_CHARS, SupportAiConfig, SupportAttachmentsConfig, SupportConfig, SupportGuardConfig, SupportReplyConfig, SupportSearchConfig, SupportSubmissionAttachmentsConfig, SupportSubmissionConfig, supportNeedsBucket };
+export { DEFAULT_CLASSIFY_MODEL, DEFAULT_EMBEDDING_DIMENSIONS, DEFAULT_EMBEDDING_MODEL, MAX_SUBMISSION_ATTACHMENTS, MAX_SUBMISSION_BODY_CHARS, MAX_SUBMISSION_SUBJECT_CHARS, SupportAiConfig, SupportAttachmentsConfig, SupportConfig, SupportGuardConfig, SupportReplyConfig, SupportSearchConfig, SupportSemanticConfig, SupportStaffConfig, SupportSubmissionAttachmentsConfig, SupportSubmissionConfig, supportNeedsBucket, supportSemantic };

package/dist/data/assignment.d.ts

@@ -0,0 +1,43 @@
+// SPDX-FileCopyrightText: 2026 Pithy
+// SPDX-License-Identifier: MIT
+import { z } from "zod";
+/**
+ * The `assignee` filter value meaning *nobody has it*. Reserved: an assignment to a ref spelled this way is
+ * refused at the boundary (`http/schemas.ts`), so the filter can never mean two things.
+ */
+export declare const UNASSIGNED = "none";
+/**
+ * Who assigned a thread: a management client through the control plane, or a signed-in user of the app
+ * through support's staff power. Recorded per change, because the two are different evidence about who
+ * acted, exactly as the audit trail's `actorType` is.
+ */
+export declare const SupportAssignmentActorType: z.ZodEnum<{
+    "control-plane": "control-plane";
+    user: "user";
+}>;
+export type SupportAssignmentActorType = z.output<typeof SupportAssignmentActorType>;
+/**
+ * One change of a thread's assignee in `pithy_support_assignments` — append-only, one row per change.
+ *
+ * The thread carries the **current** assignee because that is what the inbox filters on; this carries
+ * **every** change, the same split the classification table has with the thread. Nothing here is updated
+ * and nothing is deleted while the thread stands. A change that changed nothing — the current assignee
+ * assigned again — writes no row, so every row here is a real handover.
+ */
+export declare const SupportAssignment: z.ZodObject<{
+    id: z.ZodString;
+    threadId: z.ZodString;
+    assigneeRef: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    assigneeName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    previousRef: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    previousName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    actorType: z.ZodEnum<{
+        "control-plane": "control-plane";
+        user: "user";
+    }>;
+    assignedBy: z.ZodString;
+    note: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    createdAt: z.ZodCodec<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodDate]>, z.ZodDate>;
+}, z.core.$strip>;
+export type SupportAssignment = z.output<typeof SupportAssignment>;
+//# sourceMappingURL=assignment.d.ts.map

package/dist/data/assignment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assignment.d.ts","sourceRoot":"","sources":["../../src/data/assignment.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;GAGG;AACH,eAAO,MAAM,UAAU,SAAS,CAAC;AAEjC;;;;GAIG;AACH,eAAO,MAAM,0BAA0B;;;EAIpC,CAAC;AACJ,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAErF;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;iBAqBsE,CAAC;AACrG,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/data/assignment.js

@@ -0,0 +1,38 @@
+// SPDX-FileCopyrightText: 2026 Pithy
+// SPDX-License-Identifier: MIT
+import { z } from "zod";
+import { SQLiteDate } from "@pithy-sh/core/src/data/codecs";
+//#region src/data/assignment.ts
+/**
+* The `assignee` filter value meaning *nobody has it*. Reserved: an assignment to a ref spelled this way is
+* refused at the boundary (`http/schemas.ts`), so the filter can never mean two things.
+*/
+const UNASSIGNED = "none";
+/**
+* Who assigned a thread: a management client through the control plane, or a signed-in user of the app
+* through support's staff power. Recorded per change, because the two are different evidence about who
+* acted, exactly as the audit trail's `actorType` is.
+*/
+const SupportAssignmentActorType = z.enum(["control-plane", "user"]).describe("How the assigner was verified: `control-plane` for a management client's scoped credential, `user` for a signed-in user of the app holding support's staff power.");
+/**
+* One change of a thread's assignee in `pithy_support_assignments` — append-only, one row per change.
+*
+* The thread carries the **current** assignee because that is what the inbox filters on; this carries
+* **every** change, the same split the classification table has with the thread. Nothing here is updated
+* and nothing is deleted while the thread stands. A change that changed nothing — the current assignee
+* assigned again — writes no row, so every row here is a real handover.
+*/
+const SupportAssignment = z.object({
+	id: z.string().describe("UUID primary key."),
+	threadId: z.string().describe("The `pithy_support_threads.id` whose assignee changed."),
+	assigneeRef: z.string().nullish().describe("Who has the thread after this change, as an opaque reference, or null when it was unassigned."),
+	assigneeName: z.string().nullish().describe("How that assignee was shown at the time, or null when unassigned."),
+	previousRef: z.string().nullish().describe("Who had the thread before this change, or null when nobody did."),
+	previousName: z.string().nullish().describe("How the previous assignee was shown, or null when nobody had it."),
+	actorType: SupportAssignmentActorType.describe("How the person or client making the change was verified."),
+	assignedBy: z.string().describe("Who made the change — the control-plane subject, or the signed-in user's id."),
+	note: z.string().nullish().describe("Why, in the assigner's own words, when they gave a reason. Staff-written, never customer text, and shown to anybody who can read the thread."),
+	createdAt: SQLiteDate.describe("When the change was made.")
+}).describe("One append-only change of a support thread's assignee in `pithy_support_assignments`.");
+//#endregion
+export { SupportAssignment, SupportAssignmentActorType, UNASSIGNED };

package/dist/data/embedding.d.ts

@@ -0,0 +1,21 @@
+// SPDX-FileCopyrightText: 2026 Pithy
+// SPDX-License-Identifier: MIT
+import { z } from "zod";
+/**
+ * Which model embedded a message into the semantic index, in `pithy_support_embeddings`.
+ *
+ * **Its own table, not a column on the message**, for two reasons. A released migration is never edited, and
+ * a stamp belongs to a derived index rather than to the mail: drop the index and every stamp is a lie, so they
+ * go together, and nothing about a message changes. It is what `pithy vector reprocess --index
+ * support-messages` reads to re-embed exactly the rows whose model differs from the configured one — the same
+ * job `pithy_vector_documents.model` does for an index `vector()` owns.
+ *
+ * A message with no row was never embedded, which is the set a backfill and a repair both pick up.
+ */
+export declare const SupportEmbedding: z.ZodObject<{
+    messageId: z.ZodString;
+    model: z.ZodString;
+    embeddedAt: z.ZodCodec<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodDate]>, z.ZodDate>;
+}, z.core.$strip>;
+export type SupportEmbedding = z.output<typeof SupportEmbedding>;
+//# sourceMappingURL=embedding.d.ts.map

package/dist/data/embedding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedding.d.ts","sourceRoot":"","sources":["../../src/data/embedding.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB;;;;iBAQiD,CAAC;AAC/E,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/dist/data/embedding.js

@@ -0,0 +1,23 @@
+// SPDX-FileCopyrightText: 2026 Pithy
+// SPDX-License-Identifier: MIT
+import { z } from "zod";
+import { SQLiteDate } from "@pithy-sh/core/src/data/codecs";
+//#region src/data/embedding.ts
+/**
+* Which model embedded a message into the semantic index, in `pithy_support_embeddings`.
+*
+* **Its own table, not a column on the message**, for two reasons. A released migration is never edited, and
+* a stamp belongs to a derived index rather than to the mail: drop the index and every stamp is a lie, so they
+* go together, and nothing about a message changes. It is what `pithy vector reprocess --index
+* support-messages` reads to re-embed exactly the rows whose model differs from the configured one — the same
+* job `pithy_vector_documents.model` does for an index `vector()` owns.
+*
+* A message with no row was never embedded, which is the set a backfill and a repair both pick up.
+*/
+const SupportEmbedding = z.object({
+	messageId: z.string().describe("The `pithy_support_messages.id` this stamp is for — also the vector's id in the index."),
+	model: z.string().describe("The Workers AI embedding model that produced the vector now in the index."),
+	embeddedAt: SQLiteDate.describe("When the vector was written.")
+}).describe("The model stamp for one message's vector in the semantic index.");
+//#endregion
+export { SupportEmbedding };

package/dist/data/tables.d.ts

@@ -18,6 +18,10 @@ export declare const SUPPORT_ATTACHMENTS_TABLE = "pithySupportAttachments";
 export declare const SUPPORT_CLASSIFICATIONS_TABLE = "pithySupportClassifications";
 /** Per-viewer read/snooze state. `pithy_support_thread_flags`. */
 export declare const SUPPORT_FLAGS_TABLE = "pithySupportThreadFlags";
+/** Append-only assignee history. `pithy_support_assignments`. */
+export declare const SUPPORT_ASSIGNMENTS_TABLE = "pithySupportAssignments";
+/** The semantic index's per-message model stamps. `pithy_support_embeddings`. */
+export declare const SUPPORT_EMBEDDINGS_TABLE = "pithySupportEmbeddings";
 /**
  * The FTS5 full-text index. Not a Kysely table and deliberately not in {@link supportTables}: it is a
  * virtual table with no Zod schema and no rows of its own worth typing, reached through raw `sql`
@@ -64,6 +68,10 @@ export declare const supportTables: {
         archived: z.ZodCodec<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodBoolean, z.ZodString]>, z.ZodBoolean>;
         archivedAt: z.ZodOptional<z.ZodNullable<z.ZodCodec<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodDate]>, z.ZodDate>>>;
         archivedBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        assigneeRef: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        assigneeName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        assignedAt: z.ZodOptional<z.ZodNullable<z.ZodCodec<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodDate]>, z.ZodDate>>>;
+        assignedBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         messageCount: z.ZodNumber;
         firstMessageAt: z.ZodCodec<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodDate]>, z.ZodDate>;
         lastMessageAt: z.ZodCodec<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodDate]>, z.ZodDate>;
@@ -146,6 +154,26 @@ export declare const supportTables: {
         createdAt: z.ZodCodec<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodDate]>, z.ZodDate>;
         updatedAt: z.ZodCodec<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodDate]>, z.ZodDate>;
     }, z.core.$strip>;
+    pithySupportAssignments: z.ZodObject<{
+        id: z.ZodString;
+        threadId: z.ZodString;
+        assigneeRef: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        assigneeName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        previousRef: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        previousName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        actorType: z.ZodEnum<{
+            "control-plane": "control-plane";
+            user: "user";
+        }>;
+        assignedBy: z.ZodString;
+        note: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        createdAt: z.ZodCodec<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodDate]>, z.ZodDate>;
+    }, z.core.$strip>;
+    pithySupportEmbeddings: z.ZodObject<{
+        messageId: z.ZodString;
+        model: z.ZodString;
+        embeddedAt: z.ZodCodec<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodDate]>, z.ZodDate>;
+    }, z.core.$strip>;
 };
 /** The support tables, as a type. */
 export type SupportTables = typeof supportTables;

package/dist/data/tables.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tables.d.ts","sourceRoot":"","sources":["../../src/data/tables.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,EAAkB,KAAK,cAAc,EAAE,MAAM,4BAA4B,CAAC;AACjF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AACrC,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAO7B;;;GAGG;AAEH,8CAA8C;AAC9C,eAAO,MAAM,qBAAqB,wBAAwB,CAAC;AAC3D,gEAAgE;AAChE,eAAO,MAAM,sBAAsB,yBAAyB,CAAC;AAC7D,wDAAwD;AACxD,eAAO,MAAM,yBAAyB,4BAA4B,CAAC;AACnE,2EAA2E;AAC3E,eAAO,MAAM,6BAA6B,gCAAgC,CAAC;AAC3E,kEAAkE;AAClE,eAAO,MAAM,mBAAmB,4BAA4B,CAAC;AAE7D;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,yBAAyB,CAAC;AAE3D,oEAAoE;AACpE,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMa,CAAC;AAExC,qCAAqC;AACrC,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC;AAEjD,gFAAgF;AAChF,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,cAAc,CAAC,aAAa,CAAC,CAAC,CAAC;AAEpE,sDAAsD;AACtD,wBAAgB,eAAe,CAAC,EAAE,EAAE,UAAU,GAAG,eAAe,CAE/D"}
+{"version":3,"file":"tables.d.ts","sourceRoot":"","sources":["../../src/data/tables.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,EAAkB,KAAK,cAAc,EAAE,MAAM,4BAA4B,CAAC;AACjF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AACrC,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAS7B;;;GAGG;AAEH,8CAA8C;AAC9C,eAAO,MAAM,qBAAqB,wBAAwB,CAAC;AAC3D,gEAAgE;AAChE,eAAO,MAAM,sBAAsB,yBAAyB,CAAC;AAC7D,wDAAwD;AACxD,eAAO,MAAM,yBAAyB,4BAA4B,CAAC;AACnE,2EAA2E;AAC3E,eAAO,MAAM,6BAA6B,gCAAgC,CAAC;AAC3E,kEAAkE;AAClE,eAAO,MAAM,mBAAmB,4BAA4B,CAAC;AAC7D,iEAAiE;AACjE,eAAO,MAAM,yBAAyB,4BAA4B,CAAC;AACnE,iFAAiF;AACjF,eAAO,MAAM,wBAAwB,2BAA2B,CAAC;AAEjE;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,yBAAyB,CAAC;AAE3D,oEAAoE;AACpE,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQa,CAAC;AAExC,qCAAqC;AACrC,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC;AAEjD,gFAAgF;AAChF,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,cAAc,CAAC,aAAa,CAAC,CAAC,CAAC;AAEpE,sDAAsD;AACtD,wBAAgB,eAAe,CAAC,EAAE,EAAE,UAAU,GAAG,eAAe,CAE/D"}

package/dist/data/tables.js

@@ -1,7 +1,9 @@
 // SPDX-FileCopyrightText: 2026 Pithy
 // SPDX-License-Identifier: MIT
+import { SupportAssignment } from "./assignment.js";
 import { SupportAttachment } from "./attachment.js";
 import { SupportClassification } from "./classification.js";
+import { SupportEmbedding } from "./embedding.js";
 import { SupportThreadFlag } from "./flag.js";
 import { SupportMessage } from "./message.js";
 import { SupportThread } from "./thread.js";
@@ -21,6 +23,10 @@ const SUPPORT_ATTACHMENTS_TABLE = "pithySupportAttachments";
 const SUPPORT_CLASSIFICATIONS_TABLE = "pithySupportClassifications";
 /** Per-viewer read/snooze state. `pithy_support_thread_flags`. */
 const SUPPORT_FLAGS_TABLE = "pithySupportThreadFlags";
+/** Append-only assignee history. `pithy_support_assignments`. */
+const SUPPORT_ASSIGNMENTS_TABLE = "pithySupportAssignments";
+/** The semantic index's per-message model stamps. `pithy_support_embeddings`. */
+const SUPPORT_EMBEDDINGS_TABLE = "pithySupportEmbeddings";
 /**
 * The FTS5 full-text index. Not a Kysely table and deliberately not in {@link supportTables}: it is a
 * virtual table with no Zod schema and no rows of its own worth typing, reached through raw `sql`
@@ -36,11 +42,13 @@ const supportTables = {
 	[SUPPORT_MESSAGES_TABLE]: SupportMessage,
 	[SUPPORT_ATTACHMENTS_TABLE]: SupportAttachment,
 	[SUPPORT_CLASSIFICATIONS_TABLE]: SupportClassification,
-	[SUPPORT_FLAGS_TABLE]: SupportThreadFlag
+	[SUPPORT_FLAGS_TABLE]: SupportThreadFlag,
+	[SUPPORT_ASSIGNMENTS_TABLE]: SupportAssignment,
+	[SUPPORT_EMBEDDINGS_TABLE]: SupportEmbedding
 };
 /** Build the support database from a `DB` binding. */
 function supportDatabase(d1) {
 	return createDatabase(d1, supportTables);
 }
 //#endregion
-export { SUPPORT_ATTACHMENTS_TABLE, SUPPORT_CLASSIFICATIONS_TABLE, SUPPORT_FLAGS_TABLE, SUPPORT_MESSAGES_TABLE, SUPPORT_SEARCH_TABLE, SUPPORT_THREADS_TABLE, supportDatabase, supportTables };
+export { SUPPORT_ASSIGNMENTS_TABLE, SUPPORT_ATTACHMENTS_TABLE, SUPPORT_CLASSIFICATIONS_TABLE, SUPPORT_EMBEDDINGS_TABLE, SUPPORT_FLAGS_TABLE, SUPPORT_MESSAGES_TABLE, SUPPORT_SEARCH_TABLE, SUPPORT_THREADS_TABLE, supportDatabase, supportTables };