create-freeholder 0.0.0-bootstrap.0 → 0.2.0-beta.2

package/dist/template/src/modules/assessments/tables.ts

@@ -0,0 +1,9 @@
+// Copyright (C) 2026 Tony Aly
+// SPDX-License-Identifier: Apache-2.0
+// The tables this module owns, as its manifest declares them (MASTER.md §11).
+export {
+  assessments,
+  assessmentBands,
+  assessmentEscalations,
+  assessmentResponses,
+} from "./schema";

package/dist/template/src/modules/assistant/actions.ts

@@ -0,0 +1,191 @@
+// Copyright (C) 2026 Tony Aly
+// SPDX-License-Identifier: Apache-2.0
+// What the assistant may ask to *do* (MASTER.md §31, C9.21).
+//
+// §31: the assistant "can *act* within tight, owner-granted scopes (start a
+// booking, capture a lead, request a quote) via the same permission-scoped
+// service layer as everything else."
+//
+// Two words in that sentence do the work, and this file is where they become
+// mechanism rather than intention.
+//
+// **Tight.** The catalogue below is the ceiling. A model cannot reach a
+// service that is not in it, cannot supply an argument the entry does not
+// declare, and cannot supply an argument the entry fills in itself. That last
+// one matters most: `request_quote` takes the visitor's name and email from
+// the chat session, never from the model, so no arrangement of words in a chat
+// window can file a quote request in somebody else's name. The model chooses
+// *whether*; the module decides *for whom*.
+//
+// **Owner-granted.** Everything here is off until an owner switches it on, one
+// action at a time, in admin. The catalogue is what may be offered; the grants
+// are what is offered. An instance that never opens that screen has an
+// assistant that can only talk.
+//
+// The catalogue is short on purpose. Actions that need to know what the
+// business sells, when it is free, or what it charges are not safe to offer
+// until the assistant is grounded in that data — that is C9.22, and adding
+// `check_availability` here before then would be inviting a model to invent an
+// appointment. What is here needs no knowledge of the catalogue or the diary:
+// one asks a person to take over, and one records that somebody wants a price.
+import { z } from "zod";
+import { getService, type Service, type ServiceContext } from "@/core/service";
+
+/** Everything the module knows about the visitor, without asking the model. */
+export interface AssistantActionContext {
+  conversationId: string;
+  contactName: string;
+  contactEmail: string;
+  /** What the visitor just said, for actions that need to carry it forward. */
+  question: string;
+}
+
+export interface AssistantAction {
+  /** Stable key: stored in grants, named in the prompt, shown in admin. */
+  id: string;
+  /** The service it calls. Resolved by name so an uninstalled module is absent. */
+  service: string;
+  /** Whether taking it changes anything. Shown in admin beside the switch. */
+  writes: boolean;
+  /** One line, in the prompt, telling the model when this is the right ask. */
+  description: string;
+  /** Exactly what the model may fill in. Anything else is refused. */
+  arguments: z.ZodType;
+  /** The service input, assembled from model arguments *and* known facts. */
+  build: (args: never, context: AssistantActionContext) => unknown;
+}
+
+function action<A extends z.ZodType>(entry: {
+  id: string;
+  service: string;
+  writes: boolean;
+  description: string;
+  arguments: A;
+  build: (args: z.output<A>, context: AssistantActionContext) => unknown;
+}): AssistantAction {
+  return entry;
+}
+
+export const ASSISTANT_ACTIONS: readonly AssistantAction[] = [
+  action({
+    id: "hand_to_a_person",
+    service: "messaging.escalateAssistantChat",
+    writes: true,
+    description:
+      "Ask a person at the business to take over this conversation. Use it whenever you are not sure, or the visitor asks for a human.",
+    arguments: z.object({
+      reason: z.string().trim().min(1).max(300),
+    }),
+    build: (args, context) => ({
+      conversationId: context.conversationId,
+      reason: args.reason,
+    }),
+  }),
+  action({
+    id: "request_quote",
+    service: "cms.submitQuoteRequest",
+    writes: true,
+    description:
+      "Record that this visitor wants a price. Use it only when they have said what they want quoted.",
+    arguments: z.object({
+      summary: z.string().trim().min(1).max(2_000),
+    }),
+    // Name and email come from the chat session's contact. The model is not
+    // offered them, so it cannot file this against anybody else.
+    build: (args, context) => ({
+      name: context.contactName,
+      email: context.contactEmail,
+      message: args.summary,
+    }),
+  }),
+];
+
+export const ASSISTANT_ACTION_IDS: readonly string[] = ASSISTANT_ACTIONS.map(
+  (entry) => entry.id,
+);
+
+export function assistantAction(id: string): AssistantAction | undefined {
+  return ASSISTANT_ACTIONS.find((entry) => entry.id === id);
+}
+
+/**
+ * Whether the service an action needs is installed on this instance.
+ *
+ * An action whose module is switched off is not an error — it is simply not on
+ * offer, the same way the admin screen does not advertise it.
+ */
+export function actionService(entry: AssistantAction): Service | undefined {
+  try {
+    return getService(entry.service);
+  } catch {
+    return undefined;
+  }
+}
+
+export type ActionVerdict =
+  | { allowed: true; entry: AssistantAction; input: unknown }
+  | { allowed: false; reason: string };
+
+/**
+ * The gate. Four ways to be refused, all decided here rather than in a prompt.
+ *
+ * Returns a verdict instead of throwing, because a refusal has to be recorded
+ * and a throw inside the caller's transaction would roll the record back — the
+ * refusal would then leave no trace, which is the one thing an owner asking
+ * "why did it not do that" cannot work around.
+ */
+export function verdictFor(
+  id: unknown,
+  args: unknown,
+  granted: ReadonlySet<string>,
+  context: AssistantActionContext,
+): ActionVerdict {
+  if (typeof id !== "string" || !id) {
+    return { allowed: false, reason: "The assistant asked for an action with no name." };
+  }
+  const entry = assistantAction(id);
+  if (!entry) {
+    return {
+      allowed: false,
+      reason: `"${id.slice(0, 60)}" is not something this assistant can ever do.`,
+    };
+  }
+  if (!granted.has(entry.id)) {
+    return {
+      allowed: false,
+      reason: `"${entry.id}" is not switched on for this assistant.`,
+    };
+  }
+  const parsed = entry.arguments.safeParse(args ?? {});
+  if (!parsed.success) {
+    return {
+      allowed: false,
+      reason: `"${entry.id}" was asked for with details this action does not accept.`,
+    };
+  }
+  return {
+    allowed: true,
+    entry,
+    input: entry.build(parsed.data as never, context),
+  };
+}
+
+/**
+ * Run an allowed action inside the caller's transaction.
+ *
+ * `callAsSystem` because the visitor is anonymous and the effect is one the
+ * platform performs on their behalf — the same elevation an anonymous form
+ * submission uses to reach `contacts.resolve`. Both audit rows are still
+ * written, so the chain from a chat message to a quote request stays readable.
+ */
+export async function runAction(
+  ctx: ServiceContext,
+  entry: AssistantAction,
+  input: unknown,
+): Promise<void> {
+  const service = actionService(entry);
+  if (!service) {
+    throw new Error(`"${entry.id}" needs ${entry.service}, which is not installed.`);
+  }
+  await ctx.callAsSystem(service, input);
+}

package/dist/template/src/modules/assistant/contract.ts

@@ -0,0 +1,48 @@
+// Copyright (C) 2026 Tony Aly
+// SPDX-License-Identifier: Apache-2.0
+// The assistant's public vocabulary (C9.21).
+//
+// Separate from `schema.ts` so a screen can name a provider or an outcome
+// without importing a Drizzle table — `app/**` is barred from module schemas
+// (§15.5), and a value list is not a database.
+export const ASSISTANT_PROVIDERS = ["none", "anthropic", "openai"] as const;
+export type AssistantProvider = (typeof ASSISTANT_PROVIDERS)[number];
+
+export const ASSISTANT_SPEND_PERIODS = ["day", "week", "month"] as const;
+export type AssistantSpendPeriod = (typeof ASSISTANT_SPEND_PERIODS)[number];
+
+/**
+ * Every way one attempted answer can end.
+ *
+ * Named rather than a boolean because "the assistant did not reply" has half a
+ * dozen causes and an owner has to act differently on each: raise a budget,
+ * grant a scope, set a key, or nothing at all.
+ */
+export const ASSISTANT_TURN_OUTCOMES = [
+  "answered",
+  "refused_scope",
+  "refused_spend",
+  "refused_rate",
+  "refused_conversation_cap",
+  "refused_topic",
+  "refused_invention",
+  "unconfigured",
+  "failed",
+] as const;
+export type AssistantTurnOutcome = (typeof ASSISTANT_TURN_OUTCOMES)[number];
+
+/** Tone is a setting, not a prompt the model is trusted to obey (C9.23). */
+export const ASSISTANT_TONES = ["professional", "friendly", "brief"] as const;
+export type AssistantTone = (typeof ASSISTANT_TONES)[number];
+
+export const KNOWLEDGE_KINDS = ["qa", "fact", "policy"] as const;
+export type KnowledgeKind = (typeof KNOWLEDGE_KINDS)[number];
+
+export const GAP_REASONS = ["unknown", "invented"] as const;
+export type GapReason = (typeof GAP_REASONS)[number];
+
+export const GAP_STATUSES = ["open", "saved", "dismissed"] as const;
+export type GapStatus = (typeof GAP_STATUSES)[number];
+
+export const CHUNK_SOURCES = ["page", "help", "product", "location", "knowledge"] as const;
+export type ChunkSource = (typeof CHUNK_SOURCES)[number];

package/dist/template/src/modules/assistant/corpus.ts

@@ -0,0 +1,137 @@
+// Copyright (C) 2026 Tony Aly
+// SPDX-License-Identifier: Apache-2.0
+// What the retrieval index is built from (MASTER.md §31, C9.22).
+//
+// Published pages, help articles (which are pages with a category), the
+// catalog, locations and hours, and owner-written knowledge rows. A draft,
+// a hidden location or a switched-off knowledge entry is not a fact the
+// assistant may quote.
+import { and, eq } from "drizzle-orm";
+import type { Tx } from "@/core/service";
+import { businessLocations, openingHours } from "@/core/locations/schema";
+import { pages } from "@/modules/cms/schema";
+import { products } from "@/modules/catalog/schema";
+import type { ChunkSource } from "./contract";
+import { knowledgeEntries } from "./schema";
+import { clip, textFromBlocks } from "./text";
+
+export interface CorpusDocument {
+  sourceType: ChunkSource;
+  sourceId: string;
+  locale: string;
+  title: string;
+  body: string;
+}
+
+const WEEKDAYS = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+
+export async function collectDocuments(tx: Tx): Promise<CorpusDocument[]> {
+  const docs: CorpusDocument[] = [];
+
+  const published = await tx
+    .select({
+      id: pages.id,
+      slug: pages.slug,
+      locale: pages.locale,
+      title: pages.title,
+      blocks: pages.blocks,
+      helpCategoryId: pages.helpCategoryId,
+    })
+    .from(pages)
+    .where(eq(pages.status, "published"));
+  for (const page of published) {
+    const body = clip([page.title, textFromBlocks(page.blocks)].filter(Boolean).join("\n"));
+    if (!body) continue;
+    docs.push({
+      sourceType: page.helpCategoryId ? "help" : "page",
+      sourceId: page.id,
+      locale: page.locale,
+      title: page.title,
+      body,
+    });
+  }
+
+  const catalog = await tx
+    .select({
+      id: products.id,
+      name: products.name,
+      kind: products.kind,
+      subtitle: products.subtitle,
+      description: products.description,
+    })
+    .from(products)
+    .where(and(eq(products.status, "active"), eq(products.visibility, "public")));
+  for (const product of catalog) {
+    const body = clip(
+      [
+        product.name,
+        product.kind,
+        product.subtitle,
+        textFromBlocks(product.description),
+      ]
+        .filter((part): part is string => Boolean(part && part.trim()))
+        .join("\n"),
+    );
+    if (!body) continue;
+    docs.push({
+      sourceType: "product",
+      sourceId: product.id,
+      locale: "en",
+      title: product.name,
+      body,
+    });
+  }
+
+  const locations = await tx
+    .select()
+    .from(businessLocations)
+    .where(eq(businessLocations.status, "visible"));
+  for (const location of locations) {
+    const hours = await tx
+      .select()
+      .from(openingHours)
+      .where(eq(openingHours.locationId, location.id));
+    const hourLines = hours.map((row) => {
+      const when = row.onDate ?? WEEKDAYS[row.weekday ?? 0] ?? "day";
+      if (row.closed) return `${when}: closed`;
+      return `${when}: ${row.opens ?? "?"}–${row.closes ?? "?"}`;
+    });
+    const body = clip(
+      [
+        location.name,
+        [location.street, location.unit, location.city, location.region, location.postalCode]
+          .filter(Boolean)
+          .join(", "),
+        location.phone,
+        location.email,
+        location.priceRange ? `Price range: ${location.priceRange}` : null,
+        hourLines.length > 0 ? `Opening hours:\n${hourLines.join("\n")}` : null,
+      ]
+        .filter((part): part is string => Boolean(part && String(part).trim()))
+        .join("\n"),
+    );
+    docs.push({
+      sourceType: "location",
+      sourceId: location.id,
+      locale: "en",
+      title: location.name,
+      body,
+    });
+  }
+
+  const knowledge = await tx
+    .select()
+    .from(knowledgeEntries)
+    .where(eq(knowledgeEntries.enabled, true));
+  for (const entry of knowledge) {
+    docs.push({
+      sourceType: "knowledge",
+      sourceId: entry.id,
+      locale: entry.locale,
+      title: entry.title,
+      body: clip(`${entry.title}\n${entry.body}`),
+    });
+  }
+
+  return docs;
+}

package/dist/template/src/modules/assistant/embed.ts

@@ -0,0 +1,40 @@
+// Copyright (C) 2026 Tony Aly
+// SPDX-License-Identifier: Apache-2.0
+// Local embeddings for retrieval (MASTER.md §31, C9.22).
+//
+// Grounding must not spend the answer budget. A visitor question that only
+// needs to find the parking policy should not call a billed model to embed
+// "where do I park". This hash-and-bucket embedder is deterministic, has no
+// key, and is the same function for indexing and for querying, so cosine
+// search in pgvector is a real retrieval path even on an instance that has
+// not configured a provider.
+export const EMBEDDING_DIMENSIONS = 256;
+
+/** L2-normalised 256-d bag of hashed tokens. */
+export function embedText(text: string): number[] {
+  const vec = new Array<number>(EMBEDDING_DIMENSIONS).fill(0);
+  const tokens = text
+    .toLowerCase()
+    .normalize("NFKD")
+    .split(/[^\p{L}\p{N}]+/u)
+    .filter((token) => token.length > 1);
+  for (const token of tokens) {
+    const features = token.length >= 4 ? [token, token.slice(0, 4)] : [token];
+    for (const feature of features) {
+      let hash = 2166136261;
+      for (let i = 0; i < feature.length; i += 1) {
+        hash = Math.imul(hash ^ feature.charCodeAt(i), 16777619);
+      }
+      const unsigned = hash >>> 0;
+      const a = unsigned % EMBEDDING_DIMENSIONS;
+      const b = (unsigned >>> 8) % EMBEDDING_DIMENSIONS;
+      vec[a] = (vec[a] ?? 0) + 1;
+      vec[b] = (vec[b] ?? 0) + 0.5;
+    }
+  }
+  let norm = 0;
+  for (const value of vec) norm += value * value;
+  const scale = norm > 0 ? 1 / Math.sqrt(norm) : 0;
+  return vec.map((value) => value * scale);
+}
+

package/dist/template/src/modules/assistant/guardrails.ts

@@ -0,0 +1,220 @@
+// Copyright (C) 2026 Tony Aly
+// SPDX-License-Identifier: Apache-2.0
+// Guardrails the module enforces *outside* the model (MASTER.md §31, C9.23).
+//
+// §31 is explicit that refusals, escalation and "never invent a price" are
+// settings, not prompt text. A model asked not to invent $99 will still invent
+// $99; a function that reads the reply against the notes will not. Everything
+// in this file is therefore a read of the visitor's words or the model's
+// words against owner-chosen lists and retrieved notes. Nothing here asks a
+// provider anything.
+//
+// **Refuse and escalate are matches, not instructions.** A topic the owner
+// typed is a substring, case-insensitive, two characters or more. That is
+// crude on purpose: an owner writing "refund" expects "I want a refund" to
+// match, and a regex they did not write is a setting they cannot see.
+//
+// **Prices and availability are claims.** A number is only a price when a
+// currency signal sits next to it; "established 1999" is not a price.
+// Availability is a closed list of phrases ("in stock", "fully booked",
+// "available on"). Either kind of claim is allowed only when the same
+// normalised token already appears in the notes the retriever handed over.
+// Anything else is replaced with a canned "I do not have that to hand" —
+// the visitor is told the truth, and the owner gets a knowledge gap.
+import type { AssistantTone } from "./contract";
+
+const PRICE_RE =
+  /(?:[$£€¥]|CAD|USD|EUR|GBP|AUD|NZD)\s?\d[\d,]*(?:\.\d{1,2})?|\b\d[\d,]*(?:\.\d{1,2})?\s?(?:CAD|USD|EUR|GBP|AUD|NZD|dollars?|euros?|pounds?)\b/gi;
+
+const AVAILABILITY_RE =
+  /\b(?:in stock|out of stock|fully booked|booked until|no availability|available on|we have availability|slots? (?:left|available|open)|free on (?:monday|tuesday|wednesday|thursday|friday|saturday|sunday)|can take you|opening on)\b/gi;
+
+const UNKNOWN_RE =
+  /do not have .{0,40} to hand|don't have .{0,40} to hand|i don't know|i do not know|i'm not sure|i am not sure/i;
+
+const MAX_TOPICS = 40;
+const MAX_TOPIC_LENGTH = 80;
+const MIN_TOPIC_LENGTH = 2;
+
+export function parseTopics(raw: string): string[] {
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (const piece of raw.split(/[\n,]+/)) {
+    const topic = piece.trim();
+    if (topic.length < MIN_TOPIC_LENGTH || topic.length > MAX_TOPIC_LENGTH) continue;
+    const key = topic.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(topic);
+    if (out.length >= MAX_TOPICS) break;
+  }
+  return out;
+}
+
+/** The first owner-chosen topic that appears in `text`, or null. */
+export function matchingTopic(
+  text: string,
+  topics: readonly string[],
+): string | null {
+  const haystack = text.toLowerCase();
+  for (const topic of topics) {
+    const needle = topic.trim().toLowerCase();
+    if (needle.length < MIN_TOPIC_LENGTH) continue;
+    if (haystack.includes(needle)) return topic.trim();
+  }
+  return null;
+}
+
+function normalizePrice(token: string): string {
+  return token
+    .toLowerCase()
+    .replace(/[,\s]/g, "")
+    .replace(/[^\d.]/g, "")
+    .replace(/\.00$/, "");
+}
+
+function pricesIn(text: string): Set<string> {
+  const found = new Set<string>();
+  for (const match of text.matchAll(PRICE_RE)) {
+    const normalised = normalizePrice(match[0] ?? "");
+    if (normalised) found.add(normalised);
+  }
+  return found;
+}
+
+function availabilityIn(text: string): Set<string> {
+  const found = new Set<string>();
+  for (const match of text.matchAll(AVAILABILITY_RE)) {
+    const phrase = (match[0] ?? "").toLowerCase();
+    if (phrase) found.add(phrase);
+  }
+  return found;
+}
+
+export interface InventedClaims {
+  prices: string[];
+  availability: string[];
+}
+
+/** Claims in the reply that the notes do not already make. */
+export function inventedClaims(
+  reply: string,
+  notes: readonly { body: string }[],
+): InventedClaims {
+  const noteText = notes.map((note) => note.body).join("\n");
+  const allowedPrices = pricesIn(noteText);
+  const allowedAvailability = availabilityIn(noteText);
+  const prices: string[] = [];
+  const availability: string[] = [];
+  for (const price of pricesIn(reply)) {
+    if (!allowedPrices.has(price)) prices.push(price);
+  }
+  for (const phrase of availabilityIn(reply)) {
+    if (!allowedAvailability.has(phrase)) availability.push(phrase);
+  }
+  return { prices, availability };
+}
+
+export function admitsUnknown(reply: string): boolean {
+  return UNKNOWN_RE.test(reply);
+}
+
+function pickLocale(locale: string): "en" | "es" | "fr" {
+  const base = locale.trim().toLowerCase().slice(0, 2);
+  if (base === "es" || base === "fr") return base;
+  return "en";
+}
+
+const REFUSE_REPLY = {
+  en: "I can't help with that. If you have another question about this business, I'm happy to try.",
+  es: "No puedo ayudar con eso. Si tiene otra pregunta sobre este negocio, con gusto lo intento.",
+  fr: "Je ne peux pas vous aider là-dessus. Si vous avez une autre question sur cette entreprise, je peux essayer.",
+} as const;
+
+const UNKNOWN_REPLY = {
+  en: "I don't have that price or availability to hand. I can pass you to a person who does.",
+  es: "No tengo ese precio ni esa disponibilidad a mano. Puedo pasarle con una persona que sí los tenga.",
+  fr: "Je n'ai pas ce prix ni cette disponibilité sous la main. Je peux vous passer quelqu'un qui les a.",
+} as const;
+
+const ESCALATE_SUFFIX = {
+  en: "I've asked a person at the business to pick this up.",
+  es: "He pedido a una persona del negocio que retome esta conversación.",
+  fr: "J'ai demandé à une personne de l'entreprise de reprendre cette conversation.",
+} as const;
+
+const FORM_SUFFIX = {
+  en: (path: string) => `You can also reach us at ${path}.`,
+  es: (path: string) => `También puede escribirnos en ${path}.`,
+  fr: (path: string) => `Vous pouvez aussi nous joindre à ${path}.`,
+} as const;
+
+export function refuseReply(locale: string): string {
+  return REFUSE_REPLY[pickLocale(locale)];
+}
+
+export function unknownReply(locale: string, contactFormPath: string | null): string {
+  const language = pickLocale(locale);
+  const path = contactFormPath?.trim();
+  if (path) return `${UNKNOWN_REPLY[language]} ${FORM_SUFFIX[language](path)}`;
+  return UNKNOWN_REPLY[language];
+}
+
+export function escalateSuffix(
+  locale: string,
+  contactFormPath: string | null,
+  handedOver: boolean,
+): string {
+  const language = pickLocale(locale);
+  const parts: string[] = [];
+  if (handedOver) parts.push(ESCALATE_SUFFIX[language]);
+  const path = contactFormPath?.trim();
+  if (path) parts.push(FORM_SUFFIX[language](path));
+  return parts.join(" ");
+}
+
+export function toneInstruction(tone: AssistantTone): string {
+  switch (tone) {
+    case "friendly":
+      return "Write in a warm, friendly tone, still concise.";
+    case "brief":
+      return "Keep every answer to one or two short sentences.";
+    default:
+      return "Write in a professional, calm tone.";
+  }
+}
+
+export interface SanitizedReply {
+  reply: string;
+  invented: boolean;
+}
+
+/**
+ * Replace a reply that invented a price or an availability claim.
+ *
+ * The whole reply goes, not the offending clause. Splicing a sentence the
+ * model wrote around a number it made up is how a leftover "from $99" survives
+ * in the next clause. A canned refusal is the honest answer, and it is the
+ * same answer every time, which is what an owner can stand behind.
+ */
+export function sanitizeReply(
+  reply: string,
+  notes: readonly { body: string }[],
+  locale: string,
+  contactFormPath: string | null,
+): SanitizedReply {
+  const invented = inventedClaims(reply, notes);
+  if (invented.prices.length === 0 && invented.availability.length === 0) {
+    return { reply, invented: false };
+  }
+  return { reply: unknownReply(locale, contactFormPath), invented: true };
+}
+
+/** A path the visitor can actually open. Relative, or https. */
+export function validContactFormPath(value: string | null | undefined): string | null {
+  const trimmed = value?.trim() ?? "";
+  if (!trimmed) return null;
+  if (trimmed.startsWith("/") && !trimmed.startsWith("//")) return trimmed.slice(0, 300);
+  if (trimmed.startsWith("https://")) return trimmed.slice(0, 300);
+  return null;
+}

package/dist/template/src/modules/assistant/jobs.ts

@@ -0,0 +1,17 @@
+// Copyright (C) 2026 Tony Aly
+// SPDX-License-Identifier: Apache-2.0
+// Rebuild the assistant retrieval index (MASTER.md §31, C9.22).
+import { defineJob } from "@/core/jobs";
+
+export const reindexAssistant = defineJob({
+  name: "assistant.reindex",
+  summary: "Rebuild the assistant's retrieval index from published content.",
+  schedule: "17 * * * *",
+  concurrency: 1,
+  handler: async () => {
+    const { reindex } = await import("./service");
+    return reindex.call({}, { kind: "system" });
+  },
+});
+
+export default [reindexAssistant];