@exulu/backend 3.0.0 → 3.1.0

package/dist/index.js

@@ -9,14 +9,19 @@ import {
 import {
   COMPACTION_INSUFFICIENT,
   ContextCompactionRequiredError,
+  CredentialInvalidError,
   DEFAULT_CONTEXT_WINDOW,
   ExuluTool,
+  KB_EDITOR_TOOL_ID,
   LITELLM_UI_PATH,
   LiteLLMAdminError,
   OAUTH_CALLBACK_PATH,
   PreviewRenderError,
   ResolveModelError,
+  SCRUBBED_CREDENTIAL_TEXT,
+  SCRUBBED_OAUTH_TEXT,
   STATISTICS_TYPE_ENUM,
+  authRegistry,
   authentication,
   budgetTagFor,
   buildTags,
@@ -26,8 +31,10 @@ import {
   convertExuluToolsToAiSdkTools,
   copyS3Object,
   createAgenticRetrievalTool,
+  createKbEditorPickerTool,
   createTaggedFetch,
   createUppyRoutes,
+  credentialStore,
   decrypt,
   decryptOauthState,
   deleteS3Object,
@@ -40,12 +47,14 @@ import {
   exchangeCodeForTokens,
   exuluApp,
   getBudgetSettings,
+  getChunksTableName,
   getPdfPreviewBytes,
   getPresignedUrl,
   getS3ObjectBytes,
   getS3ObjectContent,
   getS3ObjectEtag,
   getS3SignedUploadUrl,
+  getTableName,
   getTagBudgetMap,
   getTagDailyActivity,
   getToken,
@@ -57,8 +66,6 @@ import {
   listS3ObjectsByPrefix,
   listTagsByPrefix,
   mapStreamErrorMessage,
-  oauthRegistry,
-  oauthTokenStore,
   parseResetAt,
   postgresClient,
   provisionDefaultUserBudget,
@@ -77,9 +84,10 @@ import {
   updateStatistic,
   uploadFile,
   upsertBudget,
+  verifyCredentialNonce,
   waitForLiteLLMReady,
   withRetry
-} from "./chunk-KFL7HIID.js";
+} from "./chunk-ZDH5S2WF.js";
 import {
   findLiteLLMModel
 } from "./chunk-7CCMW3IW.js";
@@ -140,9 +148,9 @@ async function guardRedisStartup(label, run, source) {
     );
   }, WATCHDOG_INTERVAL_MS);
   watchdog.unref?.();
-  let timer2;
+  let timer3;
   const timeout = new Promise((_resolve, reject) => {
-    timer2 = setTimeout(() => {
+    timer3 = setTimeout(() => {
       reject(
         new Error(
           `[EXULU-REDIS] Redis unreachable at ${addr} after ${REDIS_STARTUP_TIMEOUT_MS / 1e3}s \u2014 aborting ${label} startup. Last error: ${lastError ? describeError(lastError) : "none surfaced"}. Check REDIS_HOST/REDIS_PORT and that a Redis server is reachable at ${addr}.`
@@ -159,7 +167,7 @@ async function guardRedisStartup(label, run, source) {
     return result;
   } finally {
     clearInterval(watchdog);
-    if (timer2) clearTimeout(timer2);
+    if (timer3) clearTimeout(timer3);
     source?.off?.("error", onError);
   }
 }
@@ -209,7 +217,13 @@ var requestValidators = {
     const { db } = await postgresClient();
     let authtoken = null;
     if (!apikey) {
-      authtoken = await getToken((req.headers["authorization"] || req.headers["x-api-key"]) ?? "");
+      try {
+        authtoken = await getToken(
+          (req.headers["authorization"] || req.headers["x-api-key"]) ?? ""
+        );
+      } catch {
+        authtoken = null;
+      }
     }
     return await authentication({
       authtoken,
@@ -523,10 +537,6 @@ var ExuluStorage = class {
   // todo add upload and delete methods
 };
 
-// src/exulu/table-names.ts
-var getTableName = (id) => sanitizeName(id) + "_items";
-var getChunksTableName = (id) => sanitizeName(id) + "_chunks";
-
 // src/exulu/context.ts
 import pgvector from "pgvector/knex";
 
@@ -1388,10 +1398,31 @@ function preprocessQuery(query, options = {}) {
   };
 }
 
+// src/graphql/resolvers/field-allow-list.ts
+var ALWAYS_ALLOWED = /* @__PURE__ */ new Set(["id", "createdAt", "updatedAt"]);
+function groupableFields(table) {
+  const allowed = new Set(ALWAYS_ALLOWED);
+  for (const field of table.fields) {
+    if (field.hidden !== true) {
+      allowed.add(field.name);
+    }
+  }
+  return allowed;
+}
+function assertAllowedField(table, fieldName, label) {
+  const allowed = groupableFields(table);
+  if (!allowed.has(fieldName)) {
+    throw new Error(`Cannot ${label} by "${fieldName}".`);
+  }
+}
+
 // src/graphql/resolvers/apply-sorting.ts
-var applySorting = (query, sort, field_prefix) => {
+var applySorting = (query, sort, field_prefix, table) => {
   const prefix = field_prefix ? field_prefix + "." : "";
   if (sort) {
+    if (table) {
+      assertAllowedField(table, sort.field, "sort");
+    }
     sort.field = prefix + sort.field;
     query = query.orderBy(sort.field, sort.direction.toLowerCase());
   }
@@ -2323,6 +2354,31 @@ var agentsSchema = {
       // (DEFAULT_MAX_STEPS in resolve-max-steps.ts). Auto-ALTERed on boot.
       name: "max_tool_steps",
       type: "number"
+    },
+    {
+      name: "guest_access",
+      type: "boolean",
+      default: false
+    },
+    {
+      name: "guest_auth_mode",
+      type: "text",
+      default: "regular"
+      // 'public' | 'password' | 'regular' (= login)
+    },
+    {
+      // bcrypt hash (hashSharePassword); NEVER exposed via GraphQL/REST —
+      // see sanitizeRequestedFields + createExuluContextsTypeDefs filtering.
+      name: "guest_password_hash",
+      type: "text",
+      required: false,
+      hidden: true
+    },
+    {
+      // S3 key of the custom login-page image shown on the public auth page.
+      name: "guest_cover_image",
+      type: "text",
+      required: false
     }
   ]
 };
@@ -2439,7 +2495,8 @@ var usersSchema = {
     },
     {
       name: "temporary_token",
-      type: "text"
+      type: "text",
+      hidden: true
     },
     {
       name: "type",
@@ -2465,7 +2522,8 @@ var usersSchema = {
     },
     {
       name: "apikey",
-      type: "text"
+      type: "text",
+      hidden: true
     },
     {
       name: "scope_mode",
@@ -2482,11 +2540,13 @@ var usersSchema = {
     },
     {
       name: "password",
-      type: "text"
+      type: "text",
+      hidden: true
     },
     {
       name: "anthropic_token",
-      type: "text"
+      type: "text",
+      hidden: true
     },
     {
       name: "personal_system_prompt",
@@ -2706,29 +2766,20 @@ var imageGenerationsSchema = {
     { name: "error", type: "text", required: false }
   ]
 };
-var oauthTokensSchema = {
-  type: "oauth_tokens",
-  name: {
-    plural: "oauth_tokens",
-    singular: "oauth_token"
-  },
-  // Rows are only ever read/written by the oauth token store for the owning
-  // (provider, user_id) pair — never exposed via GraphQL — so no RBAC fields.
-  RBAC: false,
-  fields: [
-    { name: "provider", type: "text", required: false, index: true },
-    { name: "tool_id", type: "text", required: true, index: true },
-    { name: "user_id", type: "number", required: true, index: true },
-    { name: "access_token", type: "longText", required: true },
-    // AES-encrypted
-    { name: "refresh_token", type: "longText", required: false },
-    // AES-encrypted
-    { name: "token_type", type: "text", required: false },
-    { name: "scopes", type: "text", required: false },
-    { name: "expires_at", type: "date", required: false }
-    // null = non-expiring
-  ]
-};
+function userCredentialsSchema() {
+  return `
+CREATE TABLE IF NOT EXISTS user_credentials (
+    id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+    provider text NOT NULL,
+    user_id text NOT NULL,
+    auth_type text NOT NULL CHECK (auth_type IN ('oauth', 'user_credentials')),
+    data text NOT NULL,
+    created_at timestamptz NOT NULL DEFAULT now(),
+    updated_at timestamptz NOT NULL DEFAULT now(),
+    UNIQUE (provider, user_id)
+);
+`;
+}
 var sharedArtifactsSchema = {
   type: "shared_artifacts",
   name: {
@@ -2742,7 +2793,7 @@ var sharedArtifactsSchema = {
     { name: "name", type: "text", index: true, unique: true, required: true },
     { name: "s3key", type: "text", required: true },
     { name: "auth_mode", type: "text", default: "regular" },
-    { name: "password_hash", type: "text", required: false },
+    { name: "password_hash", type: "text", required: false, hidden: true },
     // bcrypt; password mode only
     { name: "expires_at", type: "date", required: false },
     // null = no expiry
@@ -2840,7 +2891,6 @@ var coreSchemas = {
       entityTypeSettingsSchema: () => addCoreFields(entityTypeSettingsSchema),
       promptFavoritesSchema: () => addCoreFields(promptFavoritesSchema),
       contextPresetsSchema: () => addCoreFields(contextPresetsSchema),
-      oauthTokensSchema: () => addCoreFields(oauthTokensSchema),
       sharedArtifactsSchema: () => addCoreFields(sharedArtifactsSchema),
       transcriptionJobsSchema: () => addCoreFields(transcriptionJobsSchema),
       imageGenerationsSchema: () => addCoreFields(imageGenerationsSchema)
@@ -3689,7 +3739,7 @@ var vectorSearch = async ({
   chunksQuery = applyFilters(chunksQuery, itemFilters, table, "items");
   chunksQuery = applyFilters(chunksQuery, chunkFilters, table, "chunks");
   chunksQuery = applyAccessControl(table, chunksQuery, user, "items");
-  chunksQuery = applySorting(chunksQuery, sort, "items");
+  chunksQuery = applySorting(chunksQuery, sort, "items", table);
   if (filterEntityIds) {
     applyEntityFilter(chunksQuery, "chunks", context, filterEntityIds, entityFilter?.mode || "any");
   }
@@ -5274,6 +5324,8 @@ var GraphQLDate = new GraphQLScalarType({
 });
 
 // src/graphql/resolvers/utils.ts
+var NON_COLUMN_SELECTIONS = /* @__PURE__ */ new Set(["pageInfo", "items", "RBAC"]);
+var isSelectableColumn = (field) => !NON_COLUMN_SELECTIONS.has(field) && !field.startsWith("__");
 var getRequestedFields = (info) => {
   const selections = info.operation.selectionSet.selections[0].selectionSet.selections;
   const itemSelection = selections.find((s) => s.name.value === "item");
@@ -5286,7 +5338,7 @@ var getRequestedFields = (info) => {
         return acc;
       }, {})
     );
-    return fields.filter((field) => field !== "pageInfo" && field !== "items" && field !== "RBAC");
+    return fields.filter(isSelectableColumn);
   }
   if (itemsSelection) {
     fields = Object.keys(
@@ -5295,7 +5347,7 @@ var getRequestedFields = (info) => {
         return acc;
       }, {})
     );
-    return fields.filter((field) => field !== "pageInfo" && field !== "items" && field !== "RBAC");
+    return fields.filter(isSelectableColumn);
   }
   fields = Object.keys(
     selections.reduce((acc, field) => {
@@ -5303,7 +5355,7 @@ var getRequestedFields = (info) => {
       return acc;
     }, {})
   );
-  return fields.filter((field) => field !== "pageInfo" && field !== "items" && field !== "RBAC");
+  return fields.filter(isSelectableColumn);
 };
 var contextItemsProcessorHandler = async (context, config, items, user, role) => {
   let jobs = [];
@@ -5370,7 +5422,7 @@ var exuluProviderFields = [
   "workflows"
 ];
 
-// src/graphql/utilities/sanitize-and-hydrate-fields.ts
+// src/graphql/utilities/budget-field.ts
 var BUDGET_ENTITY_SINGULARS = /* @__PURE__ */ new Set([
   "user",
   "role",
@@ -5393,22 +5445,37 @@ var BUDGET_ENTITY_TYPE_BY_SINGULAR = {
 };
 var addBudgetField = async (requestedFields, result, tableSingular, user) => {
   if (!requestedFields.includes("budget")) return result;
+  const entityType = BUDGET_ENTITY_TYPE_BY_SINGULAR[tableSingular];
   const scope = user?.role?.budget_management;
-  const canRead = !!user?.super_admin || scope === "read" || scope === "write";
-  if (!canRead || result?.id == null) {
+  const canReadAll = !!user?.super_admin || scope === "read" || scope === "write";
+  const memberView = !canReadAll && entityType === "project";
+  if (!canReadAll && !memberView || result?.id == null || !entityType) {
     result.budget = null;
     return result;
   }
-  const entityType = BUDGET_ENTITY_TYPE_BY_SINGULAR[tableSingular];
-  if (!entityType) {
+  const map = await getTagBudgetMap();
+  const tag = budgetTagFor(entityType, result.id);
+  const info = tag ? map[tag] ?? null : null;
+  if (!memberView) {
+    result.budget = info;
+    return result;
+  }
+  if (!info) {
     result.budget = null;
     return result;
   }
-  const map = await getTagBudgetMap();
-  const tag = budgetTagFor(entityType, result.id);
-  result.budget = tag ? map[tag] ?? null : null;
+  const settings = await getBudgetSettings();
+  result.budget = {
+    spend: info.spend,
+    max_budget: info.max_budget,
+    budget_duration: info.budget_duration,
+    budget_reset_at: info.budget_reset_at,
+    display: settings.user_budget_display
+  };
   return result;
 };
+
+// src/graphql/utilities/sanitize-and-hydrate-fields.ts
 var addProviderFields = async (args, requestedFields, providers, result, tools, user, contexts) => {
   let provider;
   let modelRow;
@@ -5658,6 +5725,14 @@ var finalizeRequestedFields = async ({
       if (!requestedFields.includes("provider")) {
         delete result.provider;
       }
+      if (requestedFields.includes("guest_has_password")) {
+        result.guest_has_password = !!result.guest_password_hash;
+      }
+    }
+    for (const field of table.fields) {
+      if (field.hidden === true) {
+        delete result[field.name];
+      }
     }
     if (BUDGET_ENTITY_SINGULARS.has(table.name.singular)) {
       result = await addBudgetField(requestedFields, result, table.name.singular, user);
@@ -5727,7 +5802,7 @@ var itemsPaginationRequest = async ({
   let dataQuery = db(tableName);
   dataQuery = applyFilters(dataQuery, filters, table);
   dataQuery = applyAccessControl(table, dataQuery, user);
-  dataQuery = applySorting(dataQuery, sort);
+  dataQuery = applySorting(dataQuery, sort, void 0, table);
   if (page > 1) {
     dataQuery = dataQuery.offset((page - 1) * limit);
   }
@@ -5750,8 +5825,20 @@ var removeProviderFields = (requestedFields) => {
   return filtered;
 };
 var sanitizeRequestedFields = (table, requestedFields) => {
+  const hiddenNames = new Set(
+    table.fields.filter((f) => f.hidden === true).map((f) => f.name)
+  );
+  if (hiddenNames.size > 0) {
+    requestedFields = requestedFields.filter((f) => !hiddenNames.has(f));
+  }
   if (table.name.singular === "agent") {
     requestedFields = removeProviderFields(requestedFields);
+    if (requestedFields.includes("guest_has_password")) {
+      requestedFields = requestedFields.filter(
+        (field) => field !== "guest_has_password"
+      );
+      requestedFields.push("guest_password_hash");
+    }
   }
   if (["user", "role", "team", "project", "agent"].includes(table.name.singular)) {
     requestedFields = requestedFields.filter((field) => field !== "budget");
@@ -5849,7 +5936,7 @@ function createQueries(table, providers, tools, contexts) {
       let query = db.from(tableNamePlural).select(sanitizedFields);
       query = applyFilters(query, filters, table);
       query = applyAccessControl(table, query, context.user);
-      query = applySorting(query, sort);
+      query = applySorting(query, sort, void 0, table);
       let result = await query.first();
       return finalizeRequestedFields({
         args,
@@ -5900,6 +5987,7 @@ function createQueries(table, providers, tools, contexts) {
       query = applyAccessControl(table, query, context.user);
       query = query.limit(limit);
       if (groupBy) {
+        assertAllowedField(table, groupBy, "group");
         query = query.select(groupBy).groupBy(groupBy);
         if (tableNamePlural === "tracking") {
           query = query.sum("total as count");
@@ -6124,7 +6212,7 @@ var encryptSensitiveFields = (input) => {
 };
 
 // src/graphql/mutations/index.ts
-import bcrypt2 from "bcryptjs";
+import bcrypt3 from "bcryptjs";
 
 // src/exulu/routines/run-state.ts
 import { v4 as uuidv42 } from "uuid";
@@ -6407,7 +6495,73 @@ var handleRBACUpdate = async (db, entityName, resourceId, rbacData, existingRbac
   }
 };
 
+// src/exulu/shared-artifacts.ts
+import bcrypt2 from "bcryptjs";
+var normalizeS3Key = (key, bucket) => {
+  const segments = key.split("/").filter((s, i) => !(i === 0 && s === "")).map((s) => decodeURIComponent(s));
+  if (segments[0] === bucket) segments.shift();
+  return segments.join("/");
+};
+var isHtmlKey = (key) => /\.html?$/i.test(key);
+var deriveFilename = (key) => {
+  const base = key.split("/").pop() ?? key;
+  return base.split("_EXULU_").pop() ?? base;
+};
+var slugifyShareName = (input) => deriveFilename(input).toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+var isExpired = (expiresAt, now) => {
+  if (!expiresAt) return false;
+  return new Date(expiresAt).getTime() <= now.getTime();
+};
+var validateCreateInput = (input, now) => {
+  if (!input.s3key) return { ok: false, message: "s3key is required." };
+  if (!input.name) return { ok: false, message: "name is required." };
+  const mode = input.auth_mode;
+  if (mode !== "public" && mode !== "password" && mode !== "regular") {
+    return { ok: false, message: "auth_mode must be public, password, or regular." };
+  }
+  if (mode === "password" && !input.password) {
+    return { ok: false, message: "A password is required for password mode." };
+  }
+  if (input.expires_at && Number.isNaN(new Date(input.expires_at).getTime())) {
+    return { ok: false, message: "expires_at is not a valid date." };
+  }
+  if (input.expires_at && isExpired(input.expires_at, now)) {
+    return { ok: false, message: "expires_at must be in the future." };
+  }
+  return { ok: true };
+};
+var hashSharePassword = (password) => bcrypt2.hash(password, 10);
+var verifySharePassword = (password, hash) => bcrypt2.compare(password, hash);
+var contentHeadersFor = (key, contentType, filename) => {
+  if (isHtmlKey(key)) return { contentType: "text/html; charset=utf-8" };
+  return {
+    contentType: contentType || "application/octet-stream",
+    disposition: `attachment; filename="${filename.replace(/"/g, "")}"`
+  };
+};
+var getSharedArtifactByName = (db, name) => db("shared_artifacts").where({ name }).first();
+
+// src/graphql/utilities/agent-guest-fields.ts
+var VALID_GUEST_AUTH_MODES = /* @__PURE__ */ new Set(["public", "password", "regular"]);
+var applyAgentGuestFieldTransforms = async (input) => {
+  if (input.guest_auth_mode !== void 0 && !VALID_GUEST_AUTH_MODES.has(input.guest_auth_mode)) {
+    throw new Error(
+      'guest_auth_mode must be "public", "password", or "regular".'
+    );
+  }
+  delete input.guest_password_hash;
+  if (typeof input.guest_password === "string" && input.guest_password.length > 0) {
+    input.guest_password_hash = await hashSharePassword(input.guest_password);
+  }
+  delete input.guest_password;
+  if (input.guest_auth_mode !== void 0 && input.guest_auth_mode !== "password") {
+    input.guest_password_hash = null;
+  }
+  return input;
+};
+
 // src/graphql/mutations/index.ts
+var VALID_RIGHTS_MODES = ["private", "users", "roles", "teams", "public"];
 var postprocessDeletion = async ({
   table,
   requestedFields,
@@ -6601,7 +6755,9 @@ function createMutations(table, providers, contexts, tools, config) {
           entity: table.name.singular,
           target_resource_id: id,
           access_type: "Role",
-          role_id: user.role,
+          // auth.ts hydrates user.role into the full roles row when it
+          // exists; unhydrated it is still the uuid string.
+          role_id: user.role?.id ?? user.role,
           rights: "write"
         }).first();
         if (rbacRecord) {
@@ -6614,7 +6770,8 @@ function createMutations(table, providers, contexts, tools, config) {
           entity: table.name.singular,
           target_resource_id: id,
           access_type: "Team",
-          team_id: user.team,
+          // Same best-effort hydration as user.role above.
+          team_id: user.team?.id ?? user.team,
           rights: "write"
         }).first();
         if (rbacRecord) {
@@ -6644,6 +6801,9 @@ function createMutations(table, providers, contexts, tools, config) {
       if (item.rights_mode) {
         item.rights_mode = "private";
       }
+      if (tableNamePlural === "agents" && "guest_access" in item) {
+        item.guest_access = false;
+      }
       if (item.created_at) {
         item.created_at = /* @__PURE__ */ new Date();
       }
@@ -6712,9 +6872,12 @@ function createMutations(table, providers, contexts, tools, config) {
       }
       if (table.name.singular === "user" && input.password) {
         console.log("[EXULU] Hashing password", input.password);
-        input.password = await bcrypt2.hash(input.password, SALT_ROUNDS);
+        input.password = await bcrypt3.hash(input.password, SALT_ROUNDS);
         console.log("[EXULU] Hashed password", input.password);
       }
+      if (table.name.singular === "agent") {
+        input = await applyAgentGuestFieldTransforms(input);
+      }
       Object.keys(input).forEach((key) => {
         if (table.fields.find((field) => field.name === key)?.type === "json") {
           if (typeof input[key] === "object" || Array.isArray(input[key])) {
@@ -6728,10 +6891,15 @@ function createMutations(table, providers, contexts, tools, config) {
           input.id = db.fn.uuid();
         }
       }
+      if (table.RBAC && input.rights_mode != null && !VALID_RIGHTS_MODES.includes(input.rights_mode)) {
+        throw new Error(
+          `Invalid rights_mode "${input.rights_mode}" \u2014 expected one of: ${VALID_RIGHTS_MODES.join(", ")}`
+        );
+      }
       const columns = await db(tableNamePlural).columnInfo();
       const insert = db(tableNamePlural).insert({
         ...input,
-        ...table.RBAC ? { rights_mode: "private" } : {}
+        ...table.RBAC ? { rights_mode: input.rights_mode ?? "private" } : {}
       }).returning(Object.keys(columns));
       if (args.upsert) {
         insert.onConflict().merge();
@@ -6779,9 +6947,12 @@ function createMutations(table, providers, contexts, tools, config) {
       }
       if (table.name.singular === "user" && input.password) {
         console.log("[EXULU] Hashing password", input.password);
-        input.password = await bcrypt2.hash(input.password, SALT_ROUNDS);
+        input.password = await bcrypt3.hash(input.password, SALT_ROUNDS);
         console.log("[EXULU] Hashed password", input.password);
       }
+      if (table.name.singular === "agent") {
+        input = await applyAgentGuestFieldTransforms(input);
+      }
       Object.keys(input).forEach((key) => {
         if (table.fields.find((field) => field.name === key)?.type === "json") {
           if (typeof input[key] === "object" || Array.isArray(input[key])) {
@@ -6852,9 +7023,12 @@ function createMutations(table, providers, contexts, tools, config) {
       }
       if (table.name.singular === "user" && input.password) {
         console.log("[EXULU] Hashing password", input.password);
-        input.password = await bcrypt2.hash(input.password, SALT_ROUNDS);
+        input.password = await bcrypt3.hash(input.password, SALT_ROUNDS);
         console.log("[EXULU] Hashed password", input.password);
       }
+      if (table.name.singular === "agent") {
+        input = await applyAgentGuestFieldTransforms(input);
+      }
       Object.keys(input).forEach((key) => {
         if (table.fields.find((field) => field.name === key)?.type === "json") {
           if (typeof input[key] === "object" || Array.isArray(input[key])) {
@@ -7346,6 +7520,9 @@ var getEnabledTools = async (agent, allExuluTools, allContexts, disabledTools =
             model: void 0
           });
         }
+        if (id === KB_EDITOR_TOOL_ID) {
+          return null;
+        }
         if (type === "agent") {
           if (id === agent.id) {
             return null;
@@ -7654,6 +7831,35 @@ var isRunSessionMetadata = (metadata) => {
   return typeof parsed === "object" && parsed !== null && !!parsed.job_result_id;
 };
 
+// src/exulu/auth/sanitize-ui-messages.ts
+var sanitizeAuthPayloadsInUiMessages = (messages) => messages.map((message) => {
+  if (message.role !== "assistant" || !Array.isArray(message.parts)) {
+    return message;
+  }
+  let changed = false;
+  const parts = message.parts.map((part) => {
+    const output = part?.output;
+    if (output && typeof output === "object" && output.credentialRequest) {
+      changed = true;
+      return { ...part, output: { result: SCRUBBED_CREDENTIAL_TEXT } };
+    }
+    if (output && typeof output === "object" && output.oauth?.authorizationUrl) {
+      changed = true;
+      return { ...part, output: { result: SCRUBBED_OAUTH_TEXT } };
+    }
+    return part;
+  });
+  return changed ? { ...message, parts } : message;
+});
+
+// src/exulu/auth/guardrail.ts
+var CREDENTIAL_GUARDRAIL = `Credential safety:
+Some tools collect credentials (API keys, passwords, tokens) through a secure form shown directly to the user in the chat UI. Credentials are never entered in the conversation itself.
+- Never ask the user to type credential values into the chat.
+- If the user pastes a credential value into the chat anyway, do not repeat it, do not store it, and do not pass it to any tool. Tell them to use the secure form instead (calling the tool again shows the form if it is no longer visible).
+- After the user confirms they submitted the form, call the tool again.`;
+var credentialGuardrailBlock = (currentTools) => currentTools?.some((t) => t.authentication?.authType === "user_credentials") ? CREDENTIAL_GUARDRAIL : null;
+
 // src/exulu/provider.ts
 var ExuluProvider = class {
   // Must begin with a letter (a-z) or underscore (_). Subsequent characters in a name can be letters, digits (0-9), or
@@ -8023,6 +8229,10 @@ var ExuluProvider = class {
 
 When a tool execution is not approved by the user, do not retry it unless explicitly asked by the user. ' +
     'Inform the user that the action was not performed.`;
+    const credentialGuardrail = credentialGuardrailBlock(currentTools);
+    if (credentialGuardrail) {
+      system += "\n\n" + credentialGuardrail;
+    }
     if (prompt) {
       let result = { object: null, text: "" };
       let inputTokens = 0;
@@ -8100,8 +8310,12 @@ When a tool execution is not approved by the user, do not retry it unless explic
         model,
         // Should be a LanguageModelV1
         system,
-        messages: await convertToModelMessages(messages, {
-          ignoreIncompleteToolCalls: true
+        // tools: applies each tool's toModelOutput to historical tool results;
+        // sanitize: guarantees auth payloads never reach the model regardless
+        // of part encoding (spec 2026-07-22 §1.2).
+        messages: await convertToModelMessages(sanitizeAuthPayloadsInUiMessages(messages), {
+          ignoreIncompleteToolCalls: true,
+          tools
         }),
         maxRetries: 2,
         tools,
@@ -8421,6 +8635,10 @@ ${skillsList}
 
 When a tool execution is not approved by the user, do not retry it unless explicitly asked by the user. ' +
     'Inform the user that the action was not performed.`;
+    const credentialGuardrail = credentialGuardrailBlock(currentTools);
+    if (credentialGuardrail) {
+      system += "\n\n" + credentialGuardrail;
+    }
     console.log("[EXULU] Tools", currentTools?.map((x) => x.name));
     console.log("[EXULU] Skills", currentSkills?.map((x) => x.name));
     const tools = await convertExuluToolsToAiSdkTools(
@@ -8504,8 +8722,12 @@ When a tool execution is not approved by the user, do not retry it unless explic
       // TODO Make this configurable
       model,
       // Should be a LanguageModelV1
-      messages: await convertToModelMessages(messages, {
-        ignoreIncompleteToolCalls: true
+      // tools: applies each tool's toModelOutput to historical tool results;
+      // sanitize: guarantees auth payloads never reach the model regardless
+      // of part encoding (spec 2026-07-22 §1.2).
+      messages: await convertToModelMessages(sanitizeAuthPayloadsInUiMessages(messages), {
+        ignoreIncompleteToolCalls: true,
+        tools
       }),
       // PrepareStep could be used here to set the model
       // for the first step or change other parameters.
@@ -10822,10 +11044,25 @@ var RecallApiError = class extends Error {
   }
 };
 var jitterMs = () => 1e3 * Math.ceil(Math.random() * 5);
+var API_TIMEOUT_MS = 6e4;
+var DOWNLOAD_TIMEOUT_MS = 3e5;
 async function fetch_with_retry(args) {
-  const { url, options, max_attempts = 6 } = args;
+  const { url, options, max_attempts = 6, timeout_ms, retry_on_reject } = args;
   for (let attempt = 1; attempt <= max_attempts; attempt++) {
-    const response = await fetch(url, options);
+    let response;
+    try {
+      response = await fetch(
+        url,
+        timeout_ms ? { ...options, signal: AbortSignal.timeout(timeout_ms) } : options
+      );
+    } catch (err) {
+      if (!retry_on_reject || attempt === max_attempts) throw err;
+      console.log(
+        `[EXULU-RECALL] fetch error from ${url} (${err.message}); retrying in ~5s (attempt ${attempt}/${max_attempts})`
+      );
+      await new Promise((resolve5) => setTimeout(resolve5, 5e3 + jitterMs()));
+      continue;
+    }
     let wait_for = null;
     switch (response.status) {
       case 429:
@@ -10866,7 +11103,9 @@ var request2 = async (path2, init = {}) => {
         ...init.body ? { "content-type": "application/json" } : {},
         ...init.headers ?? {}
       }
-    }
+    },
+    timeout_ms: API_TIMEOUT_MS,
+    retry_on_reject: (init.method ?? "GET").toUpperCase() === "GET"
   });
   if (!response.ok) {
     const body = await response.text();
@@ -10938,7 +11177,9 @@ var recallClient = {
   downloadTranscript: async (downloadUrl) => {
     const response = await fetch_with_retry({
       url: downloadUrl,
-      options: { method: "GET" }
+      options: { method: "GET" },
+      timeout_ms: DOWNLOAD_TIMEOUT_MS,
+      retry_on_reject: true
     });
     if (!response.ok) {
       const body = await response.text();
@@ -10991,6 +11232,12 @@ var durationFromSegments = (segments) => {
 // src/exulu/recall/service.ts
 var TABLE2 = "transcription_jobs";
 var DEFAULT_BOT_NAME = "Company Notetaker";
+var RECONCILE_STALE_MS = 10 * 60 * 1e3;
+var RECONCILE_PROBE_QUIET_MS = 60 * 60 * 1e3;
+var RECONCILE_GIVE_UP_MS = 24 * 60 * 60 * 1e3;
+var POST_PROCESSING_REDO_STALE_MS = 30 * 60 * 1e3;
+var POST_PROCESSING_PROMPT_TIMEOUT_MS = 10 * 60 * 1e3;
+var BOT_ENDED_STATUSES = ["done", "call_ended"];
 var log3 = (msg) => console.log(`[EXULU-RECALL] ${msg}`);
 var parseJson = (v) => {
   if (v == null) return null;
@@ -11067,7 +11314,9 @@ var recallService = {
       target_rights_mode: input.target_rights_mode ?? "private",
       target_rbac_users: input.target_rbac_users ? JSON.stringify(input.target_rbac_users) : null,
       target_rbac_roles: input.target_rbac_roles ? JSON.stringify(input.target_rbac_roles) : null,
-      post_processing_prompts: input.post_processing_prompts ? JSON.stringify(input.post_processing_prompts) : null,
+      // Normalized to NULL when empty so the reconcile sweep's redo select
+      // ("prompts configured but never ran") can never match a no-prompt row.
+      post_processing_prompts: input.post_processing_prompts?.length ? JSON.stringify(input.post_processing_prompts) : null,
       rights_mode: "private",
       created_by: input.userId,
       createdAt: now,
@@ -11136,7 +11385,13 @@ var recallService = {
       return;
     }
     const { db } = await postgresClient();
-    const claimed = await db(TABLE2).where({ id: jobId }).whereNotIn("status", ["transcribing", "awaiting_review", "saved", "failed"]).update({
+    const claimed = await db(TABLE2).where({ id: jobId }).whereNotIn("status", [
+      "transcribing",
+      "awaiting_review",
+      "saved",
+      "failed",
+      "cancelled"
+    ]).update({
       recall_recording_id: recordingId,
       status: "transcribing",
       updatedAt: /* @__PURE__ */ new Date()
@@ -11228,14 +11483,55 @@ var recallService = {
       log3(`post-processing for job ${jobId} skipped: no transcript.`);
       return [];
     }
+    const claimed = await db(TABLE2).where({ id: jobId }).whereRaw(
+      `(post_processing_outputs IS NULL OR (post_processing_outputs::text = '[]' AND "updatedAt" < ?))`,
+      [new Date(Date.now() - POST_PROCESSING_REDO_STALE_MS)]
+    ).update({ post_processing_outputs: "[]", updatedAt: /* @__PURE__ */ new Date() });
+    if (!claimed) {
+      log3(`post-processing for job ${jobId} already in flight; skipping.`);
+      return [];
+    }
     const outputs = [];
     for (const p of prompts) {
       outputs.push(await this._runOnePrompt(job, p.prompt_id, p.agent_id));
+      await this._update(jobId, {});
     }
-    await this._update(jobId, {
-      post_processing_outputs: JSON.stringify(outputs)
-    });
-    return outputs;
+    return this._mergeOutputs(jobId, outputs);
+  },
+  /**
+   * Upsert entries into post_processing_outputs without clobbering concurrent
+   * writers: optimistic-concurrency loop — read, merge by {prompt_id,
+   * agent_id}, write only while the column still matches the snapshot.
+   */
+  async _mergeOutputs(jobId, entries) {
+    const { db } = await postgresClient();
+    for (let attempt = 1; attempt <= 5; attempt++) {
+      const row = await db(TABLE2).where({ id: jobId }).first();
+      if (!row) return entries;
+      const raw = row.post_processing_outputs ?? null;
+      const snapshot = raw == null ? null : typeof raw === "string" ? raw : JSON.stringify(raw);
+      const current = parseJson(raw) ?? [];
+      const merged = [
+        ...current.filter(
+          (o) => !entries.some(
+            (e) => e.prompt_id === o.prompt_id && e.agent_id === o.agent_id
+          )
+        ),
+        ...entries
+      ];
+      const updated = await db(TABLE2).where({ id: jobId }).whereRaw(
+        "post_processing_outputs::jsonb IS NOT DISTINCT FROM ?::jsonb",
+        [snapshot]
+      ).update({
+        post_processing_outputs: JSON.stringify(merged),
+        updatedAt: /* @__PURE__ */ new Date()
+      });
+      if (updated) return merged;
+    }
+    log3(
+      `post-processing outputs for job ${jobId} kept changing under the merge; leaving the concurrent writer's data in place.`
+    );
+    return entries;
   },
   /**
    * Manual single-prompt run (re-run from the review sheet). Upserts the matching
@@ -11246,13 +11542,14 @@ var recallService = {
     const dbRow = await db(TABLE2).where({ id: jobId }).first();
     if (!dbRow) throw new Error(`transcription_job ${jobId} not found`);
     const job = this._row(dbRow);
+    const claimInFlight = dbRow.post_processing_outputs != null && (job.post_processing_outputs?.length ?? 0) === 0 && Date.now() - new Date(job.updatedAt).getTime() < POST_PROCESSING_REDO_STALE_MS;
+    if (claimInFlight) {
+      throw new Error(
+        "POST_PROCESSING_IN_FLIGHT: the automatic post-processing run is still in progress; its results will appear shortly."
+      );
+    }
     const result = await this._runOnePrompt(job, promptId, agentId);
-    const existing = job.post_processing_outputs ?? [];
-    const next = existing.filter(
-      (o) => !(o.prompt_id === promptId && o.agent_id === agentId)
-    );
-    next.push(result);
-    await this._update(jobId, { post_processing_outputs: JSON.stringify(next) });
+    await this._mergeOutputs(jobId, [result]);
     return result;
   },
   async _runOnePrompt(job, promptId, agentId) {
@@ -11286,7 +11583,8 @@ var recallService = {
 Meeting transcript:
 
 ${transcriptText}`,
-        maxRetries: 3
+        maxRetries: 3,
+        abortSignal: AbortSignal.timeout(POST_PROCESSING_PROMPT_TIMEOUT_MS)
       });
       return {
         prompt_id: promptId,
@@ -11310,6 +11608,206 @@ ${transcriptText}`,
       };
     }
   },
+  /**
+   * Reconciliation sweep: re-drive recall jobs whose webhook event was lost
+   * (ACK-first delivery + crash/restart = no redelivery). Called periodically
+   * from the reconcile loop. Returns the number of jobs it acted on.
+   *
+   * Idempotent by construction: every recovery path funnels into the same
+   * guarded transitions the webhook handlers use (_onRecordingDone's atomic
+   * claim, _onTranscriptDone's already-processed check, runPostProcessing's
+   * skip-if-outputs-exist), so a webhook racing the sweep is harmless.
+   */
+  async reconcileOnce(limit = 10) {
+    if (!recallEnabled()) return 0;
+    const { db } = await postgresClient();
+    const now = Date.now();
+    const stuck = await db(TABLE2).where({ source: "recall" }).whereIn("status", ["queued", "transcribing"]).whereRaw(`("join_at" IS NULL OR "join_at" < ?)`, [
+      new Date(now - RECONCILE_STALE_MS)
+    ]).where("updatedAt", "<", new Date(now - RECONCILE_STALE_MS)).orderBy("updatedAt", "asc").limit(limit);
+    const redo = await db(TABLE2).where({ source: "recall", status: "awaiting_review" }).whereNotNull("post_processing_prompts").whereRaw("post_processing_prompts::text <> '[]'").whereRaw("(raw_segments IS NOT NULL AND raw_segments::text <> '[]')").whereRaw(
+      "(post_processing_outputs IS NULL OR post_processing_outputs::text = '[]')"
+    ).where("updatedAt", "<", new Date(now - POST_PROCESSING_REDO_STALE_MS)).orderBy("updatedAt", "asc").limit(limit);
+    let acted = 0;
+    for (const dbRow of stuck) {
+      const job = this._row(dbRow);
+      try {
+        if (await this._reconcileStuckJob(job)) acted++;
+      } catch (err) {
+        if (await this._reconcileError(job, err)) acted++;
+      }
+    }
+    for (const dbRow of redo) {
+      try {
+        log3(`reconcile: re-running lost post-processing for job ${dbRow.id}`);
+        const outputs = await this.runPostProcessing(dbRow.id);
+        if (outputs.length > 0) acted++;
+      } catch (err) {
+        log3(
+          `post-processing redo failed for job ${dbRow.id}: ${err.message}`
+        );
+      }
+    }
+    return acted;
+  },
+  async _reconcileStuckJob(job) {
+    if (!job.recall_bot_id) {
+      await this._fail(job.id, "bot was never launched (lost during creation)");
+      return true;
+    }
+    if (job.status === "queued") return this._reconcileQueued(job);
+    if (job.status === "transcribing") return this._reconcileTranscribing(job);
+    return false;
+  },
+  /**
+   * A recovery step threw. 404 means the Recall object is gone — terminal.
+   * Otherwise apply the 24h give-up (API errors must not defer it forever),
+   * and touch the row so it rotates to the back of the sweep window.
+   */
+  async _reconcileError(job, err) {
+    const message = err.message ?? String(err);
+    if (err.status === 404) {
+      await this._fail(
+        job.id,
+        `Recall no longer knows this recording: ${message}`
+      );
+      return true;
+    }
+    if (this._pastGiveUp(job)) {
+      await this._fail(
+        job.id,
+        `still stuck 24 hours after the meeting start (last error: ${message})`
+      );
+      return true;
+    }
+    log3(`reconcile failed for job ${job.id}: ${message}`);
+    await this._update(job.id, {});
+    return false;
+  },
+  /** A queued row: the recording.done event (or the whole bot lifecycle) was lost. */
+  async _reconcileQueued(job) {
+    const ended = !!job.bot_status && BOT_ENDED_STATUSES.includes(job.bot_status);
+    const quietMs = Date.now() - new Date(job.updatedAt).getTime();
+    if (!ended && quietMs < RECONCILE_PROBE_QUIET_MS) return false;
+    const bot = await recallClient.retrieveBot(job.recall_bot_id);
+    const code = bot?.status_changes?.at(-1)?.code ?? null;
+    if (code === "fatal") {
+      await this._fail(job.id, "bot fatal (recovered by reconciliation)");
+      return true;
+    }
+    const recording = bot?.recordings?.[0] ?? null;
+    if (recording?.id) {
+      const readiness = await this._recordingReadiness(recording);
+      if (readiness === "failed") {
+        await this._fail(job.id, "recording failed (found by reconciliation)");
+        return true;
+      }
+      if (readiness === "done") {
+        log3(`reconcile: driving lost recording.done for job ${job.id}`);
+        await this._onRecordingDone(job.id, recording.id);
+        return true;
+      }
+    } else if (code === "done") {
+      await this._fail(job.id, "bot finished without a recording");
+      return true;
+    }
+    if (this._pastGiveUp(job)) {
+      await this._fail(
+        job.id,
+        "no recording within 24 hours of the meeting start"
+      );
+      return true;
+    }
+    await this._update(
+      job.id,
+      code && code !== job.bot_status ? { bot_status: code } : {}
+    );
+    return false;
+  },
+  /** Whether a recording is safe to transcribe, checking the full recording
+   *  object when the bot payload carries no status. */
+  async _recordingReadiness(recording) {
+    const codeOf = (c) => c === "done" ? "done" : c === "failed" ? "failed" : c ? "processing" : null;
+    const fromBot = codeOf(recording.status?.code);
+    if (fromBot) return fromBot;
+    if (recording.completed_at) return "done";
+    const full = await recallClient.retrieveRecording(recording.id);
+    const fromFull = codeOf(full?.status?.code);
+    if (fromFull) return fromFull;
+    return full?.completed_at || recordingDurationSeconds(full) != null ? "done" : "processing";
+  },
+  /**
+   * A transcribing row: transcript.done was lost, or the original
+   * recording.done handling crashed between the status claim and
+   * createAsyncTranscript (in which case Recall was never asked to
+   * transcribe and no transcript.* event will ever arrive).
+   */
+  async _reconcileTranscribing(job) {
+    let recordingId = job.recall_recording_id;
+    if (!recordingId && !job.recall_transcript_id) {
+      const bot = await recallClient.retrieveBot(job.recall_bot_id);
+      recordingId = bot?.recordings?.[0]?.id ?? null;
+    }
+    let transcriptId = job.recall_transcript_id;
+    if (!transcriptId) {
+      if (!recordingId) return this._transcribingNotReady(job);
+      const rec = await recallClient.retrieveRecording(recordingId);
+      const shortcut = rec?.media_shortcuts?.transcript;
+      if (shortcut?.id) {
+        transcriptId = shortcut.id;
+        await this._update(job.id, {
+          recall_recording_id: recordingId,
+          recall_transcript_id: transcriptId
+        });
+      } else {
+        const { db } = await postgresClient();
+        const claimed = await db(TABLE2).where({ id: job.id, status: "transcribing" }).whereNull("recall_transcript_id").where("updatedAt", "<", new Date(Date.now() - RECONCILE_STALE_MS)).update({ recall_recording_id: recordingId, updatedAt: /* @__PURE__ */ new Date() });
+        if (!claimed) return false;
+        log3(
+          `reconcile: re-requesting transcript for job ${job.id} (lost before createAsyncTranscript)`
+        );
+        const transcript2 = await recallClient.createAsyncTranscript(
+          recordingId,
+          job.language || "auto"
+        );
+        await this._update(job.id, {
+          recall_transcript_id: transcript2.id ?? null
+        });
+        return true;
+      }
+    }
+    const transcript = await recallClient.retrieveTranscript(transcriptId);
+    const transcriptCode = transcript?.status?.code ?? null;
+    if (transcriptCode === "error" || transcriptCode === "failed") {
+      await this._fail(
+        job.id,
+        `transcript failed at Recall: ${transcript?.status?.sub_code || transcriptCode}`
+      );
+      return true;
+    }
+    if (transcript?.data?.download_url) {
+      log3(`reconcile: driving lost transcript.done for job ${job.id}`);
+      await this._onTranscriptDone(job.id, transcriptId, recordingId);
+      return true;
+    }
+    return this._transcribingNotReady(job);
+  },
+  /** Transcript not ready yet: wait (touch) or give up after the hard cap. */
+  async _transcribingNotReady(job) {
+    if (this._pastGiveUp(job)) {
+      await this._fail(
+        job.id,
+        "transcript was not ready within 24 hours of the meeting start"
+      );
+      return true;
+    }
+    await this._update(job.id, {});
+    return false;
+  },
+  _pastGiveUp(job) {
+    const startedAt = new Date(job.join_at ?? job.createdAt).getTime();
+    return Number.isFinite(startedAt) && Date.now() - startedAt > RECONCILE_GIVE_UP_MS;
+  },
   async _findJob(botId, recordingId, transcriptId) {
     const { db } = await postgresClient();
     let dbRow;
@@ -11539,7 +12037,8 @@ function createExuluContextsTypeDefs(table) {
   ${enumValues}
   }`;
   }).filter((enumDef) => enumDef !== null).join("\n");
-  let fields = table.fields.map((field) => {
+  const graphqlFields = table.fields.filter((field) => field.hidden !== true);
+  let fields = graphqlFields.map((field) => {
     let type;
     type = mapExuluFieldTypesToGraphqlTypes(field);
     const required = field.required ? "!" : "";
@@ -11560,6 +12059,7 @@ function createExuluContextsTypeDefs(table) {
     fields.push("  systemInstructions: String");
     fields.push("  workflows: AgentWorkflows");
     fields.push("  slug: String");
+    fields.push("  guest_has_password: Boolean");
   }
   if (table.name.singular === "workflow_template") {
     fields.push("  variables: [String]");
@@ -11576,16 +12076,20 @@ function createExuluContextsTypeDefs(table) {
     }
     `;
   const rbacInputField = table.RBAC ? "  RBAC: RBACInput" : "";
+  const inputFields = table.fields.filter((f) => f.name !== "guest_password_hash");
+  const inputExtra = table.name.singular === "agent" ? "  guest_password: String" : "";
   const inputDef = `
   input ${table.name.singular}Input {
-  ${table.fields.map((f) => `  ${f.name}: ${mapExuluFieldTypesToGraphqlTypes(f)}`).join("\n")}
+  ${inputFields.map((f) => `  ${f.name}: ${mapExuluFieldTypesToGraphqlTypes(f)}`).join("\n")}
+  ${inputExtra}
   ${rbacInputField}
   }
   `;
   return enumDefs + typeDef + inputDef;
 }
 function createExuluContextsFilterTypeDefs(table) {
-  const fieldFilters = table.fields.map((field) => {
+  const filterFields = table.fields.filter((field) => field.hidden !== true);
+  const fieldFilters = filterFields.map((field) => {
     let type;
     if (field.type === "enum" && field.enumValues) {
       type = `${field.name}Enum`;
@@ -11598,7 +12102,7 @@ function createExuluContextsFilterTypeDefs(table) {
   let operatorTypes = "";
   let enumFilterOperators = [];
   const tableNameSingularUpperCaseFirst = table.name.singular.charAt(0).toUpperCase() + table.name.singular.slice(1);
-  enumFilterOperators = table.fields.filter((field) => field.type === "enum" && field.enumValues).map((field) => {
+  enumFilterOperators = filterFields.filter((field) => field.type === "enum" && field.enumValues).map((field) => {
     const enumTypeName = `${field.name}Enum`;
     return `
   input FilterOperator${enumTypeName} {
@@ -13157,12 +13661,12 @@ type LiteLLMModel {
         nonArchived().andWhere((b) => b.whereNull("chunks_count").orWhere("chunks_count", "<=", 0)).count("* as c").first(),
         nonArchived().where("embeddings_updated_at", "<=", staleCutoff).count("* as c").first()
       ]);
-      const num = (v) => v == null ? 0 : Number(v);
+      const num2 = (v) => v == null ? 0 : Number(v);
       return {
-        item_count: num(itemRow?.c),
-        chunk_total: num(chunkRow?.s),
-        stuck_count: num(stuckRow?.c),
-        stale_count: num(staleRow?.c)
+        item_count: num2(itemRow?.c),
+        chunk_total: num2(chunkRow?.s),
+        stuck_count: num2(stuckRow?.c),
+        stale_count: num2(staleRow?.c)
       };
     } catch (err) {
       console.error("[EXULU] computeContextAggregates failed for", contextId, err);
@@ -13368,6 +13872,7 @@ type LiteLLMModel {
       if (agenticRetrievalTool) {
         allTools.push(agenticRetrievalTool);
       }
+      allTools.push(createKbEditorPickerTool());
     }
     if (search && search.trim()) {
       const searchTerm = search.toLowerCase().trim();
@@ -14479,6 +14984,125 @@ See docs/superpowers/specs/2026-05-31-in-chat-image-generation-design.md for the
 
 // src/exulu/routes.ts
 import { resolve as resolvePath } from "path";
+
+// src/exulu/litellm/usage-view.ts
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var DATE_ONLY_RE = /^\d{4}-\d{2}-\d{2}$/;
+var MAX_WINDOW_DAYS = 92;
+var DEFAULT_WINDOW_DAYS = 30;
+var parseDateParam = (raw) => {
+  if (raw === void 0 || raw === null || raw === "") return void 0;
+  if (typeof raw !== "string") return null;
+  if (DATE_ONLY_RE.test(raw)) return raw;
+  const dt = new Date(raw);
+  if (Number.isNaN(dt.getTime())) return null;
+  return dt.toISOString().slice(0, 10);
+};
+var ymdShift = (ymd, days) => new Date(Date.parse(ymd) + days * DAY_MS).toISOString().slice(0, 10);
+function resolveUsageWindow(startRaw, endRaw, now = /* @__PURE__ */ new Date()) {
+  const start = parseDateParam(startRaw);
+  const end = parseDateParam(endRaw);
+  if (start === null || end === null) return null;
+  const end_date = end ?? now.toISOString().slice(0, 10);
+  let start_date = start ?? ymdShift(end_date, -(DEFAULT_WINDOW_DAYS - 1));
+  if (start_date > end_date) return null;
+  const days = Math.round((Date.parse(end_date) - Date.parse(start_date)) / DAY_MS) + 1;
+  if (days > MAX_WINDOW_DAYS) {
+    start_date = ymdShift(end_date, -(MAX_WINDOW_DAYS - 1));
+  }
+  return { start_date, end_date };
+}
+var num = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
+var zeroMetrics = () => ({
+  spend: 0,
+  prompt_tokens: 0,
+  completion_tokens: 0,
+  total_tokens: 0,
+  successful_requests: 0,
+  failed_requests: 0,
+  api_requests: 0
+});
+var readMetrics = (source) => {
+  const m = source?.metrics ?? {};
+  return {
+    spend: num(m.spend ?? source?.spend),
+    prompt_tokens: num(m.prompt_tokens ?? source?.prompt_tokens),
+    completion_tokens: num(m.completion_tokens ?? source?.completion_tokens),
+    total_tokens: num(m.total_tokens ?? source?.total_tokens),
+    successful_requests: num(
+      m.successful_requests ?? source?.successful_requests
+    ),
+    failed_requests: num(m.failed_requests ?? source?.failed_requests),
+    api_requests: num(m.api_requests ?? source?.api_requests)
+  };
+};
+var addMetrics = (into, add) => {
+  into.spend += add.spend;
+  into.prompt_tokens += add.prompt_tokens;
+  into.completion_tokens += add.completion_tokens;
+  into.total_tokens += add.total_tokens;
+  into.successful_requests += add.successful_requests;
+  into.failed_requests += add.failed_requests;
+  into.api_requests += add.api_requests;
+};
+function projectMyUsage(raw) {
+  const results = Array.isArray(raw?.results) ? raw.results : Array.isArray(raw) ? raw : [];
+  const totals = zeroMetrics();
+  const byDate = /* @__PURE__ */ new Map();
+  const byModelMap = /* @__PURE__ */ new Map();
+  for (const result of results) {
+    const date = typeof result?.date === "string" ? result.date : null;
+    if (!date) continue;
+    const metrics = readMetrics(result);
+    addMetrics(totals, metrics);
+    const day = byDate.get(date) ?? zeroMetrics();
+    addMetrics(day, metrics);
+    byDate.set(date, day);
+    const models2 = result?.breakdown && typeof result.breakdown.models === "object" ? result.breakdown.models : {};
+    for (const [model, entry] of Object.entries(models2 ?? {})) {
+      const acc = byModelMap.get(model) ?? zeroMetrics();
+      addMetrics(acc, readMetrics(entry));
+      byModelMap.set(model, acc);
+    }
+  }
+  const daily = [...byDate.entries()].map(([date, m]) => ({ date, ...m })).sort((a, b) => a.date.localeCompare(b.date));
+  const byModel = [...byModelMap.entries()].map(([model, m]) => ({
+    model,
+    spend: m.spend,
+    prompt_tokens: m.prompt_tokens,
+    completion_tokens: m.completion_tokens,
+    total_tokens: m.total_tokens,
+    successful_requests: m.successful_requests,
+    failed_requests: m.failed_requests
+  })).sort((a, b) => b.spend - a.spend);
+  return { totals, daily, byModel };
+}
+async function getMyUsageView(userId, window) {
+  const settings = await getBudgetSettings();
+  if (!settings.show_user_budget_in_chat) return null;
+  const tag = budgetTagFor("user", userId);
+  if (!tag) return null;
+  const daysInRange = Math.round(
+    (Date.parse(window.end_date) - Date.parse(window.start_date)) / DAY_MS
+  ) + 1;
+  const raw = await getTagDailyActivity({
+    startDate: window.start_date,
+    endDate: window.end_date,
+    tags: [tag],
+    page: 1,
+    pageSize: Math.min(daysInRange + 100, 1e4)
+  });
+  const { totals, daily, byModel } = projectMyUsage(raw);
+  return {
+    window,
+    display: settings.user_budget_display,
+    totals,
+    daily,
+    byModel
+  };
+}
+
+// src/exulu/routes.ts
 import multer from "multer";
 import Busboy from "busboy";
 
@@ -15188,7 +15812,7 @@ var getEnabledSkills = async (agent, disabledSkills = []) => {
   return enabledSkills;
 };
 
-// src/exulu/oauth/callback-handler.ts
+// src/exulu/auth/callback-handler.ts
 var escapeHtml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
 var renderResultPage = ({ success, message }) => `<!doctype html>
 <html lang="en">
@@ -15240,7 +15864,7 @@ var handleOauthCallback = async (req, res) => {
       "This authorization link is invalid or has expired. Return to your chat and run the tool again to get a fresh link."
     );
   }
-  const config = oauthRegistry.getByProvider(parsed.provider);
+  const config = authRegistry.getByProvider(parsed.provider);
   if (!config) {
     return send(
       404,
@@ -15248,13 +15872,31 @@ var handleOauthCallback = async (req, res) => {
       `No OAuth configuration is registered for provider "${parsed.provider}".`
     );
   }
+  if (config.authType !== "oauth") {
+    return send(
+      500,
+      false,
+      `Provider "${parsed.provider}" is not configured for OAuth. This callback only handles OAuth flows.`
+    );
+  }
   try {
     const record = await exchangeCodeForTokens({
       config,
       code,
       codeVerifier: parsed.codeVerifier
     });
-    await oauthTokenStore.upsert(parsed.provider, parsed.userId, parsed.toolId, record);
+    await credentialStore.upsert({
+      provider: parsed.provider,
+      userId: parsed.userId,
+      authType: "oauth",
+      data: {
+        accessToken: record.accessToken,
+        refreshToken: record.refreshToken ?? null,
+        tokenType: record.tokenType ?? null,
+        scopes: record.scopes ?? null,
+        expiresAt: record.expiresAt ? record.expiresAt.toISOString() : null
+      }
+    });
   } catch (caught) {
     console.error("[EXULU] OAuth code exchange failed:", caught);
     return send(
@@ -15266,6 +15908,107 @@ var handleOauthCallback = async (req, res) => {
   return send(200, true, "You can close this tab and return to your chat.");
 };
 
+// src/exulu/auth/submit-handler.ts
+import { z as z4 } from "zod";
+var bodySchema = z4.object({
+  nonce: z4.string().min(1),
+  values: z4.record(z4.string(), z4.string())
+});
+async function handleCredentialSubmit(req, res) {
+  const authResult = await requestValidators.authenticate(req);
+  if (!authResult.user?.id) {
+    res.status(401).json({ ok: false, error: "authentication required" });
+    return;
+  }
+  const sessionUserId = authResult.user.id;
+  let parsed;
+  try {
+    parsed = bodySchema.parse(req.body);
+  } catch (caught) {
+    res.status(400).json({ ok: false, error: "invalid body" });
+    return;
+  }
+  const { nonce, values } = parsed;
+  let nonceData;
+  try {
+    nonceData = verifyCredentialNonce(nonce);
+  } catch (e) {
+    res.status(401).json({
+      ok: false,
+      error: /expired/i.test(e.message) ? "nonce expired" : "nonce invalid"
+    });
+    return;
+  }
+  if (sessionUserId !== Number(nonceData.userId)) {
+    res.status(403).json({ ok: false, error: "userId mismatch" });
+    return;
+  }
+  const config = authRegistry.getByProvider(nonceData.provider);
+  if (!config || config.authType !== "user_credentials") {
+    res.status(400).json({
+      ok: false,
+      error: "provider is not a user_credentials provider"
+    });
+    return;
+  }
+  const expectedFields = new Set(config.fields.map((f) => f.name));
+  const submittedFields = new Set(Object.keys(values));
+  if (expectedFields.size !== submittedFields.size || [...expectedFields].some((f) => !submittedFields.has(f))) {
+    res.status(400).json({
+      ok: false,
+      error: "field set mismatch"
+    });
+    return;
+  }
+  if (config.validate) {
+    try {
+      await config.validate(values);
+    } catch (e) {
+      res.status(400).json({
+        ok: false,
+        error: `validation failed: ${e.message}`
+      });
+      return;
+    }
+  }
+  if (!Number.isInteger(sessionUserId) || sessionUserId <= 0) {
+    res.status(401).json({ ok: false, error: "session invalid" });
+    return;
+  }
+  await credentialStore.upsert({
+    provider: nonceData.provider,
+    userId: sessionUserId,
+    authType: "user_credentials",
+    data: values
+  });
+  res.status(200).json({ ok: true });
+}
+
+// src/exulu/auth/manage-handlers.ts
+var handleCredentialList = async (req, res) => {
+  const authResult = await requestValidators.authenticate(req);
+  if (!authResult.user?.id) {
+    res.status(authResult.code ?? 401).json({ ok: false, error: "authentication required" });
+    return;
+  }
+  const credentials = await credentialStore.listByUser(authResult.user.id);
+  res.status(200).json({ ok: true, credentials });
+};
+var handleCredentialDelete = async (req, res) => {
+  const authResult = await requestValidators.authenticate(req);
+  if (!authResult.user?.id) {
+    res.status(authResult.code ?? 401).json({ ok: false, error: "authentication required" });
+    return;
+  }
+  const provider = req.params.provider;
+  if (!provider) {
+    res.status(400).json({ ok: false, error: "provider is required" });
+    return;
+  }
+  await credentialStore.delete(provider, authResult.user.id);
+  res.status(200).json({ ok: true });
+};
+
 // src/exulu/recall/verify.ts
 import { createHmac as createHmac2, timingSafeEqual as timingSafeEqual2 } from "crypto";
 var TOLERANCE_SECONDS = 5 * 60;
@@ -15315,51 +16058,123 @@ var verifyRecallRequest = (headers, rawBody, secret = recallVerificationSecret()
   return passed ? { ok: true } : { ok: false, reason: "signature mismatch" };
 };
 
-// src/exulu/shared-artifacts.ts
-import bcrypt3 from "bcryptjs";
-var normalizeS3Key = (key, bucket) => {
-  const segments = key.split("/").filter((s, i) => !(i === 0 && s === "")).map((s) => decodeURIComponent(s));
-  if (segments[0] === bucket) segments.shift();
-  return segments.join("/");
-};
-var isHtmlKey = (key) => /\.html?$/i.test(key);
-var deriveFilename = (key) => {
-  const base = key.split("/").pop() ?? key;
-  return base.split("_EXULU_").pop() ?? base;
-};
-var slugifyShareName = (input) => deriveFilename(input).toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
-var isExpired = (expiresAt, now) => {
-  if (!expiresAt) return false;
-  return new Date(expiresAt).getTime() <= now.getTime();
-};
-var validateCreateInput = (input, now) => {
-  if (!input.s3key) return { ok: false, message: "s3key is required." };
-  if (!input.name) return { ok: false, message: "name is required." };
-  const mode = input.auth_mode;
-  if (mode !== "public" && mode !== "password" && mode !== "regular") {
-    return { ok: false, message: "auth_mode must be public, password, or regular." };
-  }
-  if (mode === "password" && !input.password) {
-    return { ok: false, message: "A password is required for password mode." };
-  }
-  if (input.expires_at && Number.isNaN(new Date(input.expires_at).getTime())) {
-    return { ok: false, message: "expires_at is not a valid date." };
-  }
-  if (input.expires_at && isExpired(input.expires_at, now)) {
-    return { ok: false, message: "expires_at must be in the future." };
+// src/exulu/public-agents.ts
+var publicAgentView = (row, slug) => ({
+  id: row.id,
+  name: row.name ?? "",
+  description: row.description ?? "",
+  image: row.image ?? null,
+  welcomemessage: row.welcomemessage ?? "",
+  slug,
+  guest_auth_mode: row.guest_auth_mode || "regular",
+  guest_has_cover: !!row.guest_cover_image
+});
+var evaluateGuestChatAccess = async (agent, userId, guestPassword) => {
+  if (agent.guest_access) {
+    if (userId != null) return { allowed: true, via: "guest" };
+    const mode = agent.guest_auth_mode || "regular";
+    if (mode === "public") return { allowed: true, via: "guest" };
+    if (mode === "password") {
+      if (agent.guest_password_hash && guestPassword) {
+        const ok = await verifySharePassword(guestPassword, agent.guest_password_hash);
+        if (ok) return { allowed: true, via: "guest" };
+        return { allowed: false, status: 401, message: "Incorrect password." };
+      }
+      return { allowed: false, status: 401, message: "Password required." };
+    }
+    return { allowed: false, status: 401, message: "Authentication required." };
+  }
+  if (userId == null && agent.rights_mode === "public") {
+    return { allowed: true, via: "rbac-public" };
+  }
+  return { allowed: false, status: 401, message: "Authentication required." };
+};
+
+// src/exulu/guest-rate-limit.ts
+var MINUTE_MS = 6e4;
+var HOUR_MS2 = 36e5;
+var perMinuteLimit = () => parseInt(process.env.EXULU_GUEST_RATE_PER_MINUTE || "10", 10);
+var perHourLimit = () => parseInt(process.env.EXULU_GUEST_RATE_PER_HOUR || "60", 10);
+var maxMessageChars = () => parseInt(process.env.EXULU_GUEST_MAX_MESSAGE_CHARS || "8000", 10);
+var maxTotalChars = () => parseInt(process.env.EXULU_GUEST_MAX_TOTAL_CHARS || "32000", 10);
+var MAX_PART_COUNT = 100;
+var windows = /* @__PURE__ */ new Map();
+var guestRateLimitExceeded = (ip, now = Date.now()) => {
+  const state = windows.get(ip) ?? {
+    minuteStart: now,
+    minuteCount: 0,
+    hourStart: now,
+    hourCount: 0,
+    lastSeen: now
+  };
+  if (now - state.minuteStart >= MINUTE_MS) {
+    state.minuteStart = now;
+    state.minuteCount = 0;
+  }
+  if (now - state.hourStart >= HOUR_MS2) {
+    state.hourStart = now;
+    state.hourCount = 0;
+  }
+  state.minuteCount += 1;
+  state.hourCount += 1;
+  state.lastSeen = now;
+  windows.set(ip, state);
+  if (windows.size > 1e4) {
+    for (const [key, value] of windows) {
+      if (now - value.lastSeen >= HOUR_MS2) windows.delete(key);
+    }
+    if (windows.size > 1e4) {
+      const sorted = [...windows.entries()].sort(
+        (a, b) => a[1].lastSeen - b[1].lastSeen
+      );
+      for (const [key] of sorted) {
+        if (windows.size <= 1e4) break;
+        windows.delete(key);
+      }
+    }
   }
-  return { ok: true };
+  return state.minuteCount > perMinuteLimit() || state.hourCount > perHourLimit();
 };
-var hashSharePassword = (password) => bcrypt3.hash(password, 10);
-var verifySharePassword = (password, hash) => bcrypt3.compare(password, hash);
-var contentHeadersFor = (key, contentType, filename) => {
-  if (isHtmlKey(key)) return { contentType: "text/html; charset=utf-8" };
-  return {
-    contentType: contentType || "application/octet-stream",
-    disposition: `attachment; filename="${filename.replace(/"/g, "")}"`
+var partsTooLong = (parts) => Array.isArray(parts) && parts.some(
+  (p) => typeof p?.text === "string" && p.text.length > maxMessageChars()
+);
+var collectTextParts = (b) => {
+  const parts = [];
+  const addFromParts = (ps) => {
+    if (!Array.isArray(ps)) return;
+    for (const p of ps) {
+      if (typeof p?.text === "string") parts.push(p.text);
+    }
   };
+  if (b.message) addFromParts(b.message.parts);
+  if (Array.isArray(b.messages)) {
+    for (const m of b.messages) addFromParts(m?.parts);
+  }
+  return parts;
+};
+var guestMessageTooLong = (body) => {
+  const b = body;
+  if (!b) return false;
+  if (b.message && partsTooLong(b.message.parts)) return true;
+  if (Array.isArray(b.messages)) {
+    if (b.messages.some((m) => partsTooLong(m?.parts))) return true;
+  }
+  const allParts = collectTextParts(b);
+  if (allParts.length > MAX_PART_COUNT) return true;
+  const totalChars = allParts.reduce((sum, t) => sum + t.length, 0);
+  if (totalChars > maxTotalChars()) return true;
+  return false;
+};
+var extractClientIp = (req) => {
+  const forwarded = req.headers["x-forwarded-for"];
+  if (process.env.EXULU_TRUST_PROXY === "true") {
+    if (typeof forwarded === "string" && forwarded.length > 0) {
+      const parts = forwarded.split(",");
+      return parts[parts.length - 1].trim();
+    }
+  }
+  return req.ip || req.socket?.remoteAddress || "unknown";
 };
-var getSharedArtifactByName = (db, name) => db("shared_artifacts").where({ name }).first();
 
 // src/skills/skill-access.ts
 async function resolveSkillByName(db, name) {
@@ -15717,6 +16532,9 @@ var createExpressRoutes = async (app, providers, tools, contexts, config, evals,
     })
   );
   app.get(OAUTH_CALLBACK_PATH, handleOauthCallback);
+  app.post("/credentials/submit", handleCredentialSubmit);
+  app.get("/credentials", handleCredentialList);
+  app.delete("/credentials/:provider", handleCredentialDelete);
   app.post("/test", async (req, res) => {
     const { item_name, context_id } = req.body;
     let itemFilters = [];
@@ -16060,17 +16878,33 @@ Mood: friendly and intelligent.
       }
       console.log("[EXULU] agent.rights_mode", agent.rights_mode);
       const authenticationResult = await requestValidators.authenticate(req);
-      if (!authenticationResult.user?.id && agent.rights_mode !== "public") {
-        res.status(authenticationResult.code || 500).json({ detail: `${authenticationResult.message}` });
+      const user = authenticationResult.user;
+      if (!user?.id) {
+        const ip = extractClientIp(req);
+        if (guestRateLimitExceeded(ip)) {
+          res.status(429).json({ detail: "Too many requests. Try again later." });
+          return;
+        }
+        if (guestMessageTooLong(req.body)) {
+          res.status(413).json({ detail: "Message too long." });
+          return;
+        }
+      }
+      const guestGate = await evaluateGuestChatAccess(
+        agent,
+        user?.id,
+        req.headers["x-guest-password"]
+      );
+      if (!user?.id && !guestGate.allowed) {
+        res.status(guestGate.status).json({ detail: guestGate.message });
         return;
       }
-      const user = authenticationResult.user;
       const scopeCheck = checkApiKeyScope(user, instance);
       if (!scopeCheck.allowed) {
         res.status(scopeCheck.code).json({ detail: scopeCheck.reason });
         return;
       }
-      const hasAccessToAgent = await checkRecordAccess(agent, "read", user);
+      const hasAccessToAgent = guestGate.allowed || await checkRecordAccess(agent, "read", user);
       if (!hasAccessToAgent) {
         res.status(401).json({
           message: "You don't have access to this agent."
@@ -17428,6 +18262,32 @@ ${style.markdown}` : params.prompt;
     }
     res.status(200).json({ budget: await getUserBudgetView(authResult.user.id) });
   });
+  app.get("/me/usage", async (req, res) => {
+    const authResult = await requestValidators.authenticate(req);
+    if (!authResult.user?.id) {
+      res.status(authResult.code ?? 401).json({ detail: authResult.message });
+      return;
+    }
+    const window = resolveUsageWindow(req.query.start_date, req.query.end_date);
+    if (!window) {
+      res.status(400).json({
+        detail: "start_date and end_date must be YYYY-MM-DD or ISO datetimes, with start_date <= end_date."
+      });
+      return;
+    }
+    try {
+      res.status(200).json({ usage: await getMyUsageView(authResult.user.id, window) });
+    } catch (err) {
+      if (err instanceof LiteLLMAdminError) {
+        res.status(502).json({ detail: err.message });
+        return;
+      }
+      console.error("[EXULU] /me/usage failed", err);
+      res.status(500).json({
+        detail: err instanceof Error ? err.message : "Usage query failed."
+      });
+    }
+  });
   app.put(
     "/admin/budgets/:entityType/bulk",
     async (req, res) => {
@@ -17541,10 +18401,10 @@ ${style.markdown}` : params.prompt;
     }
     return { user: authResult.user };
   };
-  const DATE_ONLY_RE = /^\d{4}-\d{2}-\d{2}$/;
+  const DATE_ONLY_RE2 = /^\d{4}-\d{2}-\d{2}$/;
   const normaliseDateParam = (raw) => {
     if (typeof raw !== "string" || raw.length === 0) return null;
-    if (DATE_ONLY_RE.test(raw)) return raw;
+    if (DATE_ONLY_RE2.test(raw)) return raw;
     const dt = new Date(raw);
     if (Number.isNaN(dt.getTime())) return null;
     return dt.toISOString().slice(0, 10);
@@ -19141,6 +20001,93 @@ ${style.markdown}` : params.prompt;
     if (headers.disposition) res.setHeader("Content-Disposition", headers.disposition);
     res.send(bytes);
   });
+  const resolvePublicAgentSlug = async (agentModel) => {
+    if (isLiteLLMEnabled()) return "/agents/litellm/run";
+    if (!agentModel) return "";
+    const { db } = await postgresClient();
+    const modelRow = await db.from("models").where({ id: agentModel }).first();
+    const provider = modelRow?.provider ? providers.find((a) => a.id === modelRow.provider) : void 0;
+    return provider?.slug || "";
+  };
+  const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  const getGuestAgentById = async (id) => {
+    if (!UUID_RE.test(id)) return void 0;
+    const { db } = await postgresClient();
+    return db.from("agents").where({ id, guest_access: true, active: true }).first();
+  };
+  app.get("/public-agents", async (_req, res) => {
+    const { db } = await postgresClient();
+    const rows = await db.from("agents").where({ guest_access: true, active: true }).select(
+      "id",
+      "name",
+      "description",
+      "image",
+      "welcomemessage",
+      "model",
+      "guest_auth_mode",
+      "guest_cover_image"
+    );
+    const views = await Promise.all(
+      rows.map(
+        async (row) => publicAgentView(row, await resolvePublicAgentSlug(row.model))
+      )
+    );
+    res.json(views);
+  });
+  app.get("/public-agents/:id/meta", async (req, res) => {
+    const row = await getGuestAgentById(req.params.id ?? "");
+    if (!row) {
+      res.status(404).json({ detail: "Not found." });
+      return;
+    }
+    res.json(publicAgentView(row, await resolvePublicAgentSlug(row.model)));
+  });
+  app.get("/public-agents/:id/cover", async (req, res) => {
+    const row = await getGuestAgentById(req.params.id ?? "");
+    if (!row?.guest_cover_image) {
+      res.status(404).json({ detail: "Not found." });
+      return;
+    }
+    let bytes;
+    try {
+      bytes = await getS3ObjectBytes(row.guest_cover_image, config);
+    } catch (e) {
+      if (e?.name === "NoSuchKey" || e?.name === "NotFound" || e?.$metadata?.httpStatusCode === 404) {
+        res.status(404).json({ detail: "Cover not found." });
+        return;
+      }
+      console.error("[EXULU] public-agent cover read failed", e);
+      res.status(500).json({ detail: "Failed to read cover." });
+      return;
+    }
+    const ext = row.guest_cover_image.split(".").pop()?.toLowerCase();
+    const contentType = ext === "png" ? "image/png" : ext === "webp" ? "image/webp" : "image/jpeg";
+    res.setHeader("Content-Type", contentType);
+    res.setHeader("X-Content-Type-Options", "nosniff");
+    res.setHeader("Cache-Control", "public, max-age=300");
+    res.send(bytes);
+  });
+  app.post(
+    "/public-agents/:id/verify-password",
+    async (req, res) => {
+      const ip = extractClientIp(req);
+      if (guestRateLimitExceeded(ip)) {
+        res.status(429).json({ detail: "Too many requests. Try again later." });
+        return;
+      }
+      const row = await getGuestAgentById(req.params.id ?? "");
+      if (!row || row.guest_auth_mode !== "password") {
+        res.status(404).json({ detail: "Not found." });
+        return;
+      }
+      const password = typeof req.body?.password === "string" ? req.body.password : "";
+      if (!row.guest_password_hash || !await verifySharePassword(password, row.guest_password_hash)) {
+        res.status(401).json({ detail: "Incorrect password." });
+        return;
+      }
+      res.status(204).end();
+    }
+  );
   app.use(express2.static("public"));
   await registerOpenAIGatewayRoutes(app, providers, tools, contexts, config);
   return app;
@@ -19213,7 +20160,7 @@ import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/
 import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
 import "express";
 import "@opentelemetry/api";
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 var SESSION_ID_HEADER = "mcp-session-id";
 var ExuluMCP = class {
   server = {};
@@ -19285,7 +20232,7 @@ var ExuluMCP = class {
           title: tool2.name + " agent",
           description: tool2.description,
           inputSchema: {
-            inputs: tool2.inputSchema || z4.object({})
+            inputs: tool2.inputSchema || z5.object({})
           }
         },
         async ({ inputs }, args) => {
@@ -19337,7 +20284,7 @@ var ExuluMCP = class {
           title: "Get List of Prompt Templates",
           description: "Retrieves a list of prompt templates available for this agent. Returns the name, description, and ID of each template.",
           inputSchema: {
-            inputs: z4.object({})
+            inputs: z5.object({})
           }
         },
         async ({ inputs }, args) => {
@@ -19383,8 +20330,8 @@ var ExuluMCP = class {
           title: "Get Prompt Template Details",
           description: "Retrieves the full details of a specific prompt template by ID, including the actual template content with variables.",
           inputSchema: {
-            inputs: z4.object({
-              id: z4.string().describe("The ID of the prompt template to retrieve")
+            inputs: z5.object({
+              id: z5.string().describe("The ID of the prompt template to retrieve")
             })
           }
         },
@@ -20485,7 +21432,7 @@ var ExuluEval = class {
 };
 
 // src/templates/evals/index.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 import { generateText as generateText8, Output as Output2 } from "ai";
 var llmAsJudgeEval = () => {
   if (process.env.REDIS_HOST?.length && process.env.REDIS_PORT?.length) {
@@ -20538,8 +21485,8 @@ var llmAsJudgeEval = () => {
           prompt,
           maxRetries: 2,
           output: Output2.object({
-            schema: z5.object({
-              score: z5.number().min(0).max(100).describe("The score between 0 and 100.")
+            schema: z6.object({
+              score: z6.number().min(0).max(100).describe("The score between 0 and 100.")
             })
           })
         });
@@ -20767,12 +21714,12 @@ Usage:
 - If no todos exist yet, an empty list will be returned`;
 
 // src/templates/tools/todo/todo.ts
-import z6 from "zod";
-var TodoSchema = z6.object({
-  content: z6.string().describe("Brief description of the task"),
-  status: z6.string().describe("Current status of the task: pending, in_progress, completed, cancelled"),
-  priority: z6.string().describe("Priority level of the task: high, medium, low"),
-  id: z6.string().describe("Unique identifier for the todo item")
+import z7 from "zod";
+var TodoSchema = z7.object({
+  content: z7.string().describe("Brief description of the task"),
+  status: z7.string().describe("Current status of the task: pending, in_progress, completed, cancelled"),
+  priority: z7.string().describe("Priority level of the task: high, medium, low"),
+  id: z7.string().describe("Unique identifier for the todo item")
 });
 var TodoWriteTool = new ExuluTool({
   id: "todo_write",
@@ -20788,8 +21735,8 @@ var TodoWriteTool = new ExuluTool({
       default: todowrite_default
     }
   ],
-  inputSchema: z6.object({
-    todos: z6.array(TodoSchema).describe("The updated todo list")
+  inputSchema: z7.object({
+    todos: z7.array(TodoSchema).describe("The updated todo list")
   }),
   execute: async (inputs) => {
     const { sessionID, todos, user } = inputs;
@@ -20824,7 +21771,7 @@ var TodoReadTool = new ExuluTool({
   id: "todo_read",
   name: "Todo Read",
   description: "Use this tool to read your todo list",
-  inputSchema: z6.object({}),
+  inputSchema: z7.object({}),
   type: "function",
   category: "todo",
   config: [
@@ -20866,7 +21813,7 @@ var todoTools = [TodoWriteTool, TodoReadTool];
 var questionread_default = 'Use this tool to read questions you\'ve asked and check if they\'ve been answered by the user. This tool helps you track the status of questions and retrieve the user\'s selected answers.\n\n## When to Use This Tool\n\nUse this tool proactively in these situations:\n- After asking a question to check if the user has responded\n- To retrieve the user\'s answer before proceeding with implementation\n- To review all questions and answers in the current session\n- When you need to reference a previous answer\n\n## How It Works\n\n- This tool takes no parameters (leave the input blank or empty)\n- Returns an array of all questions in the session\n- Each question includes:\n  - `id`: Unique identifier for the question\n  - `question`: The question text\n  - `answerOptions`: Array of answer options with their IDs and text\n  - `status`: Either "pending" (not answered) or "answered"\n  - `selectedAnswerId`: The ID of the chosen answer (only present if answered)\n\n## Usage Pattern\n\nTypically you\'ll:\n1. Use Question Ask to pose a question\n2. Wait for the user to respond\n3. Use Question Read to check the answer\n4. Find the selected answer by matching the `selectedAnswerId` with an option in `answerOptions`\n5. Proceed with implementation based on the user\'s choice\n\n## Example Response\n\n```json\n[\n  {\n    "id": "question123",\n    "question": "Which authentication method would you like to implement?",\n    "answerOptions": [\n      { "id": "ans1", "text": "JWT tokens" },\n      { "id": "ans2", "text": "OAuth 2.0" },\n      { "id": "ans3", "text": "Session-based auth" },\n      { "id": "ans4", "text": "None of the above..." }\n    ],\n    "status": "answered",\n    "selectedAnswerId": "ans1"\n  }\n]\n```\n\nIn this example, the user selected "JWT tokens" (id: ans1).\n\n## Important Notes\n\n- If no questions exist in the session, an empty array will be returned\n- Questions remain in the session even after being answered for reference\n- Use the `selectedAnswerId` to find which answer option the user chose by matching it against the `id` field in `answerOptions`\n';
 
 // src/templates/tools/question/question.ts
-import z8 from "zod";
+import z9 from "zod";
 
 // src/templates/tools/question/questionask.txt
 var questionask_default = `Use this tool to ask the user a question with multiple choice answer options during your session. This helps you gather user input, clarify requirements, and make informed decisions based on user preferences.
@@ -20953,18 +21900,18 @@ After asking a question, use the Question Read tool to check if the user has ans
 `;
 
 // src/templates/tools/question/question-ask.ts
-import z7 from "zod";
+import z8 from "zod";
 import { randomUUID as randomUUID7 } from "crypto";
-var AnswerOptionSchema = z7.object({
-  id: z7.string().describe("Unique identifier for the answer option"),
-  text: z7.string().describe("The text of the answer option")
+var AnswerOptionSchema = z8.object({
+  id: z8.string().describe("Unique identifier for the answer option"),
+  text: z8.string().describe("The text of the answer option")
 });
-var _QuestionSchema = z7.object({
-  id: z7.string().describe("Unique identifier for the question"),
-  question: z7.string().describe("The question to ask the user"),
-  answerOptions: z7.array(AnswerOptionSchema).describe("Array of possible answer options"),
-  selectedAnswerId: z7.string().optional().describe("The ID of the answer option selected by the user"),
-  status: z7.enum(["pending", "answered"]).describe("Status of the question: pending or answered")
+var _QuestionSchema = z8.object({
+  id: z8.string().describe("Unique identifier for the question"),
+  question: z8.string().describe("The question to ask the user"),
+  answerOptions: z8.array(AnswerOptionSchema).describe("Array of possible answer options"),
+  selectedAnswerId: z8.string().optional().describe("The ID of the answer option selected by the user"),
+  status: z8.enum(["pending", "answered"]).describe("Status of the question: pending or answered")
 });
 var QuestionAskTool = new ExuluTool({
   id: "question_ask",
@@ -20981,9 +21928,9 @@ var QuestionAskTool = new ExuluTool({
       default: questionask_default
     }
   ],
-  inputSchema: z7.object({
-    question: z7.string().describe("The question to ask the user"),
-    answerOptions: z7.array(z7.string()).describe("Array of possible answer options (strings)")
+  inputSchema: z8.object({
+    question: z8.string().describe("The question to ask the user"),
+    answerOptions: z8.array(z8.string()).describe("Array of possible answer options (strings)")
   }),
   execute: async (inputs) => {
     const { sessionID, question, answerOptions, user } = inputs;
@@ -21056,7 +22003,7 @@ var QuestionReadTool = new ExuluTool({
   name: "Question Read",
   needsApproval: false,
   description: "Use this tool to read questions and their answers",
-  inputSchema: z8.object({}),
+  inputSchema: z9.object({}),
   type: "function",
   category: "question",
   config: [
@@ -21086,15 +22033,15 @@ async function getQuestions(sessionID) {
 var questionTools = [QuestionAskTool, QuestionReadTool];
 
 // src/templates/tools/perplexity.ts
-import z9 from "zod";
+import z10 from "zod";
 import Perplexity from "@perplexity-ai/perplexity_ai";
 var internetSearchTool = new ExuluTool({
   id: "internet_search",
   name: "Internet Search",
   description: "Search the internet for information.",
-  inputSchema: z9.object({
-    query: z9.string().describe("The query to the tool."),
-    search_recency_filter: z9.enum(["day", "week", "month", "year"]).optional().describe("The recency filter for the search, can be day, week, month or year.")
+  inputSchema: z10.object({
+    query: z10.string().describe("The query to the tool."),
+    search_recency_filter: z10.enum(["day", "week", "month", "year"]).optional().describe("The recency filter for the search, can be day, week, month or year.")
   }),
   category: "internet_search",
   type: "web_search",
@@ -21187,7 +22134,7 @@ var perplexityTools = [internetSearchTool];
 
 // src/templates/tools/email.ts
 import * as nodemailer from "nodemailer";
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var transporter = null;
 function getTransporter(config) {
   if (!transporter) {
@@ -21211,11 +22158,11 @@ var emailTool = new ExuluTool({
   id: "email",
   name: "Email",
   description: "Send an email.",
-  inputSchema: z10.object({
-    recipient: z10.string().describe("The recipient of the email."),
-    subject: z10.string().describe("The subject of the email."),
-    html: z10.string().describe("The HTML body of the email."),
-    text: z10.string().describe("The text body of the email.")
+  inputSchema: z11.object({
+    recipient: z11.string().describe("The recipient of the email."),
+    subject: z11.string().describe("The subject of the email."),
+    html: z11.string().describe("The HTML body of the email."),
+    text: z11.string().describe("The text body of the email.")
   }),
   type: "function",
   config: [{
@@ -21281,7 +22228,7 @@ var emailTool = new ExuluTool({
 });
 
 // src/templates/tools/image-generation.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var _cachedImageModels;
 var setCachedImageModels = (models2) => {
   _cachedImageModels = models2;
@@ -21342,8 +22289,8 @@ var createImageGenerationWidgetTool = (models2) => {
     needsApproval: false,
     type: "function",
     config: [],
-    inputSchema: z11.object({
-      prompt: z11.string().describe(
+    inputSchema: z12.object({
+      prompt: z12.string().describe(
         "Initial image prompt. The user can edit it before generating."
       )
     }),
@@ -21454,6 +22401,42 @@ var startTranscriptionPollingLoop = () => {
   process.on("SIGTERM", stop);
 };
 
+// src/exulu/recall/reconcile-loop.ts
+var RECONCILE_INTERVAL_MS = 6e4;
+var timer2 = null;
+var stopped2 = false;
+var tick2 = async () => {
+  if (stopped2) return;
+  try {
+    const acted = await recallService.reconcileOnce();
+    if (acted > 0) {
+      console.log(`[EXULU-RECALL] reconcile tick recovered ${acted} job(s)`);
+    }
+  } catch (err) {
+    console.error(
+      `[EXULU-RECALL] reconcile tick failed: ${err.message}`
+    );
+  } finally {
+    if (!stopped2) {
+      timer2 = setTimeout(tick2, RECONCILE_INTERVAL_MS);
+    }
+  }
+};
+var startRecallReconcileLoop = () => {
+  if (timer2) return;
+  stopped2 = false;
+  timer2 = setTimeout(tick2, RECONCILE_INTERVAL_MS);
+  const stop = () => {
+    stopped2 = true;
+    if (timer2) {
+      clearTimeout(timer2);
+      timer2 = null;
+    }
+  };
+  process.on("SIGINT", stop);
+  process.on("SIGTERM", stop);
+};
+
 // src/exulu/app/index.ts
 var isDev = process.env.NODE_ENV !== "production";
 var lineLimitFormat = winston2.format((info) => {
@@ -21688,6 +22671,9 @@ var ExuluApp = class {
         );
       }
       logRecallStartup();
+      if (recallEnabled()) {
+        startRecallReconcileLoop();
+      }
       return this._expressApp;
     }
   };
@@ -22728,7 +23714,6 @@ var {
   promptFavoritesSchema: promptFavoritesSchema3,
   transcriptionJobsSchema: transcriptionJobsSchema3,
   imageGenerationsSchema: imageGenerationsSchema2,
-  oauthTokensSchema: oauthTokensSchema2,
   sharedArtifactsSchema: sharedArtifactsSchema2
 } = coreSchemas.get();
 var addMissingFields = async (knex, tableName, fields, skipFields = []) => {
@@ -22751,6 +23736,18 @@ var addMissingFields = async (knex, tableName, fields, skipFields = []) => {
     console.log(`[EXULU] Field '${sanitizedName}' already exists in ${tableName} table.`);
   }
 };
+var migrateUserCredentialsDataColumn = async (knex) => {
+  const dataType = await knex.raw(
+    `SELECT data_type FROM information_schema.columns
+      WHERE table_name = 'user_credentials' AND column_name = 'data'`
+  );
+  if (dataType.rows?.[0]?.data_type === "jsonb") {
+    console.log("[EXULU] Migrating user_credentials.data jsonb -> text.");
+    await knex.raw(
+      "ALTER TABLE user_credentials ALTER COLUMN data TYPE text USING data::text"
+    );
+  }
+};
 var up = async function(knex) {
   console.log("[EXULU] Database up.");
   const schemas = [
@@ -22772,7 +23769,6 @@ var up = async function(knex) {
     promptFavoritesSchema3(),
     transcriptionJobsSchema3(),
     imageGenerationsSchema2(),
-    oauthTokensSchema2(),
     sharedArtifactsSchema2(),
     rbacSchema3(),
     agentsSchema3(),
@@ -22806,10 +23802,9 @@ var up = async function(knex) {
     console.log(`[EXULU] Creating ${schema.name.plural} table.`, schema.fields);
     await createTable(schema);
   }
-  await knex.raw("DROP INDEX IF EXISTS oauth_tokens_tool_id_user_id_unique");
-  await knex.raw(
-    "CREATE UNIQUE INDEX IF NOT EXISTS oauth_tokens_provider_user_id_unique ON oauth_tokens (provider, user_id)"
-  );
+  await knex.raw("DROP TABLE IF EXISTS oauth_tokens CASCADE;");
+  await knex.raw(userCredentialsSchema());
+  await migrateUserCredentialsDataColumn(knex);
   if (await knex.schema.hasColumn("job_results", "workflow") && await knex.schema.hasColumn("job_results", "trigger_metadata")) {
     await knex.raw(
       "CREATE INDEX IF NOT EXISTS job_results_email_dedup_idx ON job_results (workflow, (trigger_metadata->>'message_id'))"
@@ -23003,6 +23998,11 @@ var execute = async ({ contexts }) => {
       evals: "read"
     }).returning("id");
   }
+  const existingExternalRole = await db.from("roles").where({ name: "external" }).first();
+  if (!existingExternalRole) {
+    console.log("[EXULU] Creating external role.");
+    await db.from("roles").insert({ name: "external" }).returning("id");
+  }
   const existingUser = await db.from("users").where({ email: "admin@exulu.com" }).first();
   if (!existingUser) {
     const password = await encryptString("admin");
@@ -23836,7 +24836,7 @@ var MarkdownChunker = class {
 import * as fs3 from "fs";
 import * as path from "path";
 import { generateText as generateText9, Output as Output3 } from "ai";
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 import pLimit from "p-limit";
 import { randomUUID as randomUUID8 } from "crypto";
 import * as mammoth from "mammoth";
@@ -24295,15 +25295,15 @@ If the page contains a flow-chart, schematic, technical drawing or control board
   const result = await generateText9({
     model,
     output: Output3.object({
-      schema: z12.object({
-        needs_correction: z12.boolean(),
-        corrected_text: z12.string().nullable(),
-        current_page_table: z12.object({
-          headers: z12.array(z12.string()),
-          is_continuation: z12.boolean()
+      schema: z13.object({
+        needs_correction: z13.boolean(),
+        corrected_text: z13.string().nullable(),
+        current_page_table: z13.object({
+          headers: z13.array(z13.string()),
+          is_continuation: z13.boolean()
         }).nullable(),
-        confidence: z12.enum(["high", "medium", "low"]),
-        reasoning: z12.string()
+        confidence: z13.enum(["high", "medium", "low"]),
+        reasoning: z13.string()
       })
     }),
     messages: [
@@ -24923,6 +25923,7 @@ var ExuluPython = {
   instructions: getPythonSetupInstructions
 };
 export {
+  CredentialInvalidError,
   JOB_STATUS_ENUM as EXULU_JOB_STATUS_ENUM,
   STATISTICS_TYPE_ENUM as EXULU_STATISTICS_TYPE_ENUM,
   ExuluApp,