@fayz-ai/admin 0.62.0 → 0.63.0

package/dist/chunk-KLO7DKXX.js

@@ -0,0 +1,1651 @@
+import { useOrganizationStore } from './chunk-YKPPCV2Z.js';
+import '@fayz-ai/core';
+import { taskEntityDef } from '@fayz-ai/tasks/data/supabase';
+import { create } from 'zustand';
+import { useAuthStore } from '@fayz-ai/auth';
+
+// src/lib/report-attachments.ts
+var turnFiles = [];
+function setTurnReportFiles(files) {
+  if (files.length) turnFiles = files.slice(0, 8);
+}
+function takeTurnReportFiles() {
+  const out = turnFiles;
+  turnFiles = [];
+  return out;
+}
+function clearTurnReportFiles() {
+  turnFiles = [];
+}
+var addressEntity = {
+  name: "Address",
+  namePlural: "Addresses",
+  icon: "MapPin",
+  data: {
+    table: "addresses",
+    tenantScoped: true,
+    tenantIdColumn: "tenant_id",
+    searchColumns: ["label", "street", "district", "city", "postal_code", "recipient"]
+  },
+  fields: [
+    // owner_id/owner_type are how an address attaches to its person. They are
+    // required and described rather than hidden: the agent reaches this table
+    // from a record it already has in hand ("adiciona o endereço X pra ele"),
+    // so the id it must pass is the one it just searched for or created.
+    {
+      key: "owner_id",
+      label: "Owner record id",
+      type: "text",
+      required: true,
+      hint: "Id of the person (client, contact, supplier, staff\u2026) this address belongs to."
+    },
+    {
+      key: "owner_type",
+      label: "Owner kind",
+      type: "select",
+      options: ["person", "location", "tenant"],
+      hint: "Defaults to 'person'. Only set it for an address that belongs to a business location or to the tenant itself."
+    },
+    { key: "label", label: "Label", type: "text", searchable: true, hint: "Casa, Trabalho, Dep\xF3sito\u2026" },
+    {
+      key: "kind",
+      label: "Use",
+      type: "select",
+      options: ["both", "shipping", "billing"],
+      hint: "Defaults to 'both'."
+    },
+    { key: "postal_code", label: "Postal code", type: "text", required: true, searchable: true, hint: "CEP." },
+    { key: "street", label: "Street", type: "text", required: true, searchable: true },
+    { key: "number", label: "Number", type: "text" },
+    { key: "complement", label: "Complement", type: "text" },
+    { key: "district", label: "District", type: "text", searchable: true, hint: "Bairro." },
+    { key: "city", label: "City", type: "text", required: true, searchable: true },
+    { key: "state", label: "State", type: "text", required: true, hint: "Two-letter UF." },
+    { key: "country", label: "Country", type: "text", hint: "Defaults to 'BR'." },
+    { key: "recipient", label: "Recipient", type: "text", searchable: true, hint: "Who receives, if not the owner." },
+    { key: "phone", label: "Phone", type: "text" },
+    {
+      key: "is_default",
+      label: "Default address",
+      type: "boolean",
+      hint: "Only one default per owner and kind \u2014 clear the previous one before setting this."
+    }
+  ]
+};
+var CORE_QUERY_ENTITIES = [
+  {
+    key: "address",
+    entity: addressEntity,
+    writable: true,
+    agentHint: "`address` holds the street address of a PERSON (client, contact, supplier, staff). A person record has NO street/city/postal_code fields of its own. To read where someone lives, search `address` with filters {\"owner_id\": <the person's id>} \u2014 a person with no address field is not a person without an address. To record one, create an `address` with owner_id set to the person's id. Never write an address into a notes field."
+  },
+  {
+    key: "task",
+    entity: taskEntityDef,
+    writable: true,
+    agentHint: '`task` is the workspace to-do list shown in the assistant column. Rows with source = "onboarding" are the setup checklist and are assigned to whoever created the workspace. To close one, update its `status` to "done" \u2014 never delete it. Leave `source` and `source_key` alone when creating a task; they belong to the feature that seeded the row.'
+  }
+];
+
+// src/lib/core-ai-tools.ts
+var coreAITools = [
+  {
+    id: "core.business-summary",
+    name: "getBusinessSummary",
+    description: "Returns a summary of the current business: name, plan, vertical, team size, and key metrics.",
+    icon: "Building2",
+    mode: "read",
+    parameters: { type: "object", properties: {}, required: [] },
+    category: "Core",
+    // No opener suggestion: plugin-dashboard's kpi-summary already offers the
+    // "how is the business doing" prompt (localised). A second one here only
+    // duplicated it, in English, on the opening screen.
+    suggestions: []
+  },
+  {
+    id: "core.team-members",
+    name: "getTeamMembers",
+    description: "Lists the WORKSPACE TEAM exactly as the Team screen shows it: the people who staff this business. Each row carries `kind` (what they do here \u2014 teacher, staff\u2026), `accessRole` (their permission role, null when they have no login) and `hasLogin`. Answer headcount questions from this \u2014 never report the number of logins as the size of the team.",
+    icon: "Users",
+    mode: "read",
+    parameters: {
+      type: "object",
+      properties: {
+        role: {
+          type: "string",
+          description: "Optional filter, matched against either the person kind (teacher, staff\u2026) or the access role (owner, admin, manager, viewer)."
+        }
+      }
+    },
+    permission: { feature: "members", action: "read" },
+    category: "Core",
+    suggestions: [
+      { label: "Quem est\xE1 na minha equipe?" }
+    ]
+  },
+  {
+    id: "core.navigate",
+    name: "navigateTo",
+    description: "Opens one of the app's PAGES (Agenda, Clients, Financial\u2026). Takes a page name, never a person or a record \u2014 to open a specific record use openRecord.",
+    icon: "Compass",
+    mode: "read",
+    parameters: {
+      type: "object",
+      properties: {
+        page: { type: "string", description: "Name of the page, as listed in the app pages" }
+      },
+      required: ["page"]
+    },
+    category: "Core"
+  },
+  {
+    id: "core.find-connectors",
+    name: "findConnectors",
+    description: 'Finds the INTEGRATIONS this app can have with outside providers \u2014 payments (Pix, cart\xE3o, boleto), frete, nota fiscal/ERP, banco, CRM, agenda, mensagens. Call it WHENEVER someone asks for a provider by name ("tem AppMax?", "queria pagamento com a appmax") or by need ("quero receber por Pix", "preciso emitir nota fiscal"). You have NO other way to know what this app can connect \u2014 never answer that you cannot help with a specific provider without calling this first. Each result carries a `state`, and they mean different things: `connected` (already live), `needs_setup` (authorized, but it CANNOT work until something is chosen on its screen \u2014 never call this one ready or working), `ready` (installed here \u2014 the person can connect it right now), `soon` (a module this app has declared it, but it is not built yet \u2014 do NOT offer to connect it), and `needs_module` (it belongs to a module this app was not built with \u2014 the person CANNOT install a module, so say plainly that it would come with a new version of the app and offer nothing to click). The reply already renders a card per result, with the brand mark and the button; answer in one or two short sentences and do not repeat the list, the logos or any link. You never connect anything yourself \u2014 connecting is a human step on the connector screen.',
+    icon: "Plug",
+    mode: "read",
+    parameters: {
+      type: "object",
+      properties: {
+        need: {
+          type: "string",
+          description: 'What the person needs, in their own words \u2014 a provider name ("appmax") or a need ("pagamento", "receber por pix", "frete", "nota fiscal").'
+        }
+      },
+      required: ["need"]
+    },
+    category: "Core",
+    suggestions: [{ label: "D\xE1 pra receber por Pix aqui?" }]
+  },
+  {
+    id: "core.open-record",
+    name: "openRecord",
+    description: "Opens the detail page of a record already returned by a tool in THIS conversation. Takes that record's id \u2014 never a name.",
+    icon: "ExternalLink",
+    mode: "read",
+    parameters: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "Record id from an earlier tool result" }
+      },
+      required: ["id"]
+    },
+    category: "Core"
+  }
+];
+function pascalCase(value) {
+  return value.normalize("NFD").replace(/[\u0300-\u036f]/g, "").split(/[^a-zA-Z0-9]+/).filter(Boolean).map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
+}
+function registryToolName(pluginId, registryId) {
+  return `list${pascalCase(pluginId)}${pascalCase(registryId)}`;
+}
+function formatToolSignature(tool) {
+  const params = tool.parameters?.properties ? Object.entries(tool.parameters.properties).map(([key]) => tool.parameters?.required?.includes(key) ? key : `${key}?`).join(", ") : "";
+  return `${tool.name}(${params})`;
+}
+function entityToolName(entityKey) {
+  return `search${pascalCase(entityKey)}`;
+}
+function attachedRecordGuidance(writableKeys) {
+  const hints = CORE_QUERY_ENTITIES.filter((q) => q.agentHint && writableKeys.includes(q.key)).map((q) => q.agentHint);
+  return hints.length ? ` Records that attach to another record: ${hints.join(" ")}` : "";
+}
+var FIELD_CATALOGUE_POINTER = "\n\nField names per entity are listed in the `searchRecords` tool description (* = required). Send nothing outside them.";
+function fieldCatalogue(entries) {
+  const lines = entries.filter((e) => e.fields.length > 0).map((e) => {
+    const names = e.fields.slice(0, 24).map((f) => f.required ? `${f.key}*` : f.key);
+    return `${e.key}: ${names.join(", ")}`;
+  });
+  if (!lines.length) return "";
+  return `
+
+Fields by entity (* = required, send nothing else):
+${lines.join("\n")}`;
+}
+function buildDataPrimitiveTools(input) {
+  const options = [];
+  const schema = [];
+  for (const e of input.entities) {
+    if (e.entityDef && !e.entityDef.agentHidden) {
+      options.push({ key: e.entityKey, label: e.labelPlural });
+      schema.push({ key: e.entityKey, fields: e.entityDef.fields ?? [] });
+    }
+  }
+  for (const [pluginId, defs] of input.registries) {
+    for (const registry2 of defs) {
+      if (registry2.readOnly) continue;
+      const key = `${pluginId}:${registry2.id}`;
+      options.push({
+        key,
+        label: registry2.entity.namePlural ?? registry2.entity.name,
+        ...registry2.agentHint ? { hint: registry2.agentHint } : {}
+      });
+      schema.push({ key, fields: registry2.entity.fields ?? [] });
+    }
+  }
+  const writableKeys = options.map((o) => o.key);
+  for (const q of [...input.queryEntities ?? [], ...CORE_QUERY_ENTITIES]) {
+    options.push({ key: q.key, label: q.entity.namePlural ?? q.entity.name });
+    if (q.writable) writableKeys.push(q.key);
+  }
+  if (!options.length) return [];
+  const keys = options.map((o) => o.key);
+  const catalogLine = options.map((o) => `${o.key} (${o.label.toLowerCase()}${o.hint ? ` \u2014 ${o.hint}` : ""})`).join(", ");
+  return [
+    {
+      id: "data.find-anything",
+      name: "findAnything",
+      description: `Global search (like the app command center): looks a name/text up across ALL record types the user may see at once and returns grouped matches. Use this FIRST whenever you do not know what kind of record a name refers to ("quem \xE9 X?", "o que \xE9 Y?") \u2014 then drill down with searchRecords. It matches TEXT INSIDE each record, so records attached to a person are never returned by that person's name \u2014 reaching them takes a second searchRecords call filtered by owner_id.` + attachedRecordGuidance(keys),
+      icon: "Command",
+      mode: "read",
+      parameters: {
+        type: "object",
+        properties: {
+          search: { type: "string", description: "Name or text to look up everywhere." }
+        },
+        required: ["search"]
+      },
+      category: "Data",
+      suggestions: [{ label: "Quem \xE9 \u2026?" }]
+    },
+    ...writableKeys.length ? [
+      {
+        id: "data.create-record",
+        name: "createRecord",
+        description: "Creates ONE new record of an entity (client, service, supplier, \u2026). ALWAYS search first to avoid duplicates. Use ONLY the fields listed below for that entity. Do NOT interview the user field-by-field. Ask in chat only for required (*) fields you genuinely cannot infer, and call this tool the moment you have them \u2014 omit every optional field you were not given (its default applies; a boolean status like active defaults to on/true). The confirmation this opens is an EDITABLE FORM, not a yes/no receipt: the user reviews, fills and corrects anything there \u2014 including optionals \u2014 before it is written. Opening that form fast beats collecting everything in chat." + attachedRecordGuidance(writableKeys) + FIELD_CATALOGUE_POINTER,
+        icon: "Plus",
+        mode: "persist",
+        // The handler orchestrates its own guard chain (permission → plan
+        // cap → confirmation → create) because the target is dynamic.
+        requiresConfirmation: false,
+        parameters: {
+          type: "object",
+          properties: {
+            entity: { type: "string", description: "Which entity to create", enum: writableKeys },
+            values: { type: "object", description: 'Field values for the new record, e.g. {"name":"\u2026","phone":"\u2026"}' }
+          },
+          required: ["entity", "values"]
+        },
+        category: "Data"
+      }
+    ] : [],
+    ...writableKeys.length ? [
+      {
+        id: "data.update-record",
+        name: "updateRecord",
+        description: "Updates fields on an EXISTING record (add an email, fix a phone, change a name\u2026). Use the record id already known from this conversation or from a search. Only send the fields being changed, and only fields the entity actually has. The user confirms before anything is written." + FIELD_CATALOGUE_POINTER,
+        icon: "Pencil",
+        mode: "persist",
+        requiresConfirmation: false,
+        parameters: {
+          type: "object",
+          properties: {
+            entity: { type: "string", description: "Which entity the record belongs to", enum: writableKeys },
+            id: { type: "string", description: "Id of the record to update" },
+            values: { type: "object", description: 'Only the fields to change, e.g. {"email":"\u2026"}' }
+          },
+          required: ["entity", "id", "values"]
+        },
+        category: "Data"
+      }
+    ] : [],
+    {
+      id: "data.search-records",
+      name: "searchRecords",
+      description: `Searches or lists records of ONE entity and returns matching rows with their fields. Use \`search\` for names/text and \`filters\` for exact field values (e.g. {"status":"open"}) \u2014 never put a status word in search. For ANY date or period question ("hoje", "amanh\xE3", "esta semana"), use \`dateField\` + \`from\`/\`to\` \u2014 NOT \`filters\`. Plain dates (YYYY-MM-DD) are read as whole days in the business timezone, so \`from\` and \`to\` both being today is exactly "today". Entities: ${catalogLine}.${attachedRecordGuidance(keys)}` + fieldCatalogue(schema),
+      icon: "Search",
+      mode: "read",
+      parameters: {
+        type: "object",
+        properties: {
+          entity: { type: "string", description: "Which entity to search", enum: keys },
+          search: { type: "string", description: "Name or text to match. Omit to list recent records." },
+          filters: { type: "object", description: 'Optional exact-value filters {field: value}, e.g. {"status":"open"}. Do not use for dates.' },
+          dateField: { type: "string", description: "Date field the from/to window applies to (e.g. startsAt for agenda; default 'createdAt')." },
+          from: { type: "string", description: "Start of the window: YYYY-MM-DD (whole local day) or ISO datetime." },
+          to: { type: "string", description: "End of the window: YYYY-MM-DD (whole local day, inclusive) or ISO datetime." },
+          orderBy: { type: "string", description: 'Field to sort by (e.g. startsAt for "next/upcoming" questions).' },
+          direction: { type: "string", description: "Sort direction", enum: ["asc", "desc"] }
+        },
+        required: ["entity"]
+      },
+      category: "Data"
+    },
+    ...writableKeys.length ? [
+      {
+        id: "data.propose-import",
+        name: "proposeImport",
+        description: `Proposes how the columns of an ATTACHED spreadsheet/CSV map to the fields of one entity, and opens the mapping for the user to review and correct. Use this the moment a file is attached and the user talks about importing \u2014 it is the ONLY way to answer that, and it replaces writing the mapping out as text. Send one entry per column you can map; columns you leave out are shown as unmapped for the user to fill in. Field names come from the entity field list in createRecord. When it comes back ok, call commitImport with the same mapping \u2014 that is what actually writes the rows. Entities: ${catalogLine}.`,
+        icon: "ArrowRightLeft",
+        mode: "read",
+        category: "Data",
+        parameters: {
+          type: "object",
+          properties: {
+            entity: { type: "string", description: "Which entity the rows would become", enum: writableKeys },
+            mapping: {
+              type: "object",
+              description: 'Column name from the file \u2192 field name in the app, e.g. {"Nome":"name","Celular":"phone"}. Leave a column out when no field fits.'
+            },
+            file: { type: "string", description: "File name, when more than one is attached." }
+          },
+          required: ["entity", "mapping"]
+        }
+      },
+      {
+        id: "data.commit-import",
+        name: "commitImport",
+        description: `WRITES the rows of an attached file as records, using a mapping the user already confirmed through proposeImport. Call it only after proposeImport came back ok, and pass the SAME mapping it returned. The user confirms the row count before anything is written. Never call this to "check" anything \u2014 it creates records. Entities: ${catalogLine}.`,
+        icon: "Upload",
+        mode: "persist",
+        requiresConfirmation: false,
+        category: "Data",
+        parameters: {
+          type: "object",
+          properties: {
+            entity: { type: "string", description: "Which entity the rows become", enum: writableKeys },
+            mapping: {
+              type: "object",
+              description: "The confirmed mapping from proposeImport: file column -> app field."
+            },
+            file: { type: "string", description: "File name, when more than one is attached." }
+          },
+          required: ["entity", "mapping"]
+        }
+      }
+    ] : [],
+    {
+      id: "data.query-data",
+      name: "queryData",
+      description: `Aggregates over ONE entity: count, sum or avg of a field, with optional date range, equality filters and a group-by. Use for analytical questions (revenue this week, new clients this month, busiest professional). Entities: ${catalogLine}.`,
+      icon: "Sigma",
+      mode: "read",
+      parameters: {
+        type: "object",
+        properties: {
+          entity: { type: "string", description: "Which entity to aggregate", enum: keys },
+          metric: { type: "string", description: "Aggregation", enum: ["count", "sum", "avg"] },
+          field: { type: "string", description: "Field to sum/avg (record field name). Ignored for count." },
+          dateField: { type: "string", description: "Date field to range-filter (default 'createdAt'; use startsAt for agenda questions)." },
+          from: { type: "string", description: "Lower bound (inclusive): YYYY-MM-DD (whole local day) or ISO datetime." },
+          to: { type: "string", description: "Upper bound (inclusive): YYYY-MM-DD (whole local day) or ISO datetime." },
+          groupBy: { type: "string", description: "Optional field to group results by." },
+          filters: { type: "object", description: "Optional equality filters {field: value}." }
+        },
+        required: ["entity", "metric"]
+      },
+      category: "Data"
+    }
+  ];
+}
+var PROFILE_ACTIONS = ["read", "create", "edit", "delete"];
+var MAX_FEATURES = 80;
+function buildPermissionTools(features, profiles = []) {
+  const usable = features.filter((f) => f.id && f.label).slice(0, MAX_FEATURES);
+  if (!usable.length) return [];
+  const catalog = usable.map((f) => `${f.id} (${f.label}${f.group && f.group !== f.label ? ` \u2014 ${f.group}` : ""})`).join("; ");
+  const editable = profiles.filter((p) => !p.isSystem);
+  return [
+    {
+      id: "core.create-permission-profile",
+      name: "createPermissionProfile",
+      description: `Creates an ACCESS PROFILE (permission role) that people on the team can then be assigned to \u2014 "um perfil para Marketing", "um acesso s\xF3 de leitura para o estagi\xE1rio". YOU choose which areas the role needs from the catalog below and which actions on each: pick the smallest set that lets that role do its job, and grant \`delete\` only when the user asked for it. Use the exact ids from the catalog \u2014 an id that is not in it is rejected. After it comes back ok, tell the user in plain language what the profile can and cannot reach, using the labels \u2014 not the ids.
+
+Areas (id (label \u2014 group)): ${catalog}
+Actions on each area: ${PROFILE_ACTIONS.join(", ")}.`,
+      icon: "ShieldCheck",
+      mode: "persist",
+      // Own guard chain: system permission → validation → confirmation → write.
+      requiresConfirmation: false,
+      parameters: {
+        type: "object",
+        properties: {
+          name: { type: "string", description: 'Name of the profile, e.g. "Marketing".' },
+          description: { type: "string", description: "One line on what this role is for." },
+          grants: {
+            type: "object",
+            description: 'Area id \u2192 actions, e.g. {"crm.leads":["read","create","edit"],"agenda":["read"]}. Leave an area out entirely when the role should not reach it.'
+          }
+        },
+        required: ["name", "grants"]
+      },
+      category: "Core",
+      suggestions: [{ label: "Cria um perfil de acesso para Marketing" }]
+    },
+    ...editable.length ? [
+      {
+        id: "core.update-permission-profile",
+        name: "updatePermissionProfile",
+        description: `Changes an access profile that ALREADY exists \u2014 "d\xE1 edi\xE7\xE3o em cursos para o Marketing", "deixa o estagi\xE1rio s\xF3 com leitura", "renomeia para Growth". This is the ONLY way to change a profile: never reach for a record tool, a profile is not a record. Grants MERGE by area: an area you send replaces that area's actions, an area you leave out keeps what it had, and an area only goes away when you name it in \`revoke\`. So "s\xF3 leitura em cursos" is grants {courses:["read"]}, and "tira o financeiro" is revoke ["financial"]. YOU decide which areas and actions that means \u2014 ask the user only when the areas themselves are ambiguous, never to have them dictate the action lists.
+
+Profiles you can change (id \u2014 name): ${editable.map((p) => `${p.id} \u2014 ${p.name}`).join("; ")}
+Areas (id (label \u2014 group)): ${catalog}
+Actions on each area: ${PROFILE_ACTIONS.join(", ")}.`,
+        icon: "ShieldCheck",
+        mode: "persist",
+        requiresConfirmation: false,
+        parameters: {
+          type: "object",
+          properties: {
+            id: { type: "string", description: "Id of the profile to change, from the list above.", enum: editable.map((p) => p.id) },
+            name: { type: "string", description: "New name, only when renaming." },
+            description: { type: "string", description: "New one-line description, only when changing it." },
+            grants: {
+              type: "object",
+              description: 'Areas to set, e.g. {"courses":["read","edit"]}. Replaces the actions of the areas named here and leaves every other area alone.'
+            },
+            revoke: {
+              type: "array",
+              items: { type: "string" },
+              description: "Area ids the profile should lose entirely."
+            }
+          },
+          required: ["id"]
+        },
+        category: "Core"
+      }
+    ] : []
+  ];
+}
+
+// src/lib/tool-search.ts
+var ALWAYS_ON_TOOLS = /* @__PURE__ */ new Set([
+  "getBusinessSummary",
+  "getTeamMembers",
+  "navigateTo",
+  "openRecord",
+  "findAnything",
+  "searchRecords",
+  "queryData",
+  "createRecord",
+  "updateRecord",
+  "findTools",
+  // Reporting a problem has to work from ANY screen — that is where a user hits
+  // one. So the Dico carries it every turn instead of behind findTools; the
+  // plugin registers its executor, and a turn without the plugin simply has no
+  // such tool to ship. findSupportRequests rides along so the agent can check an
+  // existing ticket before opening a duplicate.
+  "reportIssue",
+  "findSupportRequests"
+]);
+var loaded = /* @__PURE__ */ new Set();
+var areas = /* @__PURE__ */ new Set();
+var listeners = /* @__PURE__ */ new Set();
+function bump() {
+  for (const fn of listeners) fn();
+}
+function loadedToolNames() {
+  return loaded;
+}
+function loadTools(names) {
+  const added = names.filter((n) => !loaded.has(n));
+  if (!added.length) return [];
+  for (const n of added) loaded.add(n);
+  bump();
+  return added;
+}
+function loadArea(area) {
+  if (areas.has(area)) return;
+  areas.add(area);
+  bump();
+}
+function resetLoadedTools() {
+  if (!loaded.size && !areas.size) return;
+  loaded.clear();
+  areas.clear();
+  bump();
+}
+function resolveLoadedNames(catalog) {
+  const names = new Set(loaded);
+  if (areas.size) {
+    for (const tool of catalog) {
+      if (tool.role && areas.has(tool.role)) names.add(tool.name);
+    }
+  }
+  return names;
+}
+function areaOf(tool) {
+  return tool.category ?? tool.id.split(".")[0] ?? "Outros";
+}
+function searchableTools(catalog, pinned) {
+  return catalog.filter((t) => !pinned.has(t.name) && !ALWAYS_ON_TOOLS.has(t.name));
+}
+function buildToolIndex(tools) {
+  const byArea = /* @__PURE__ */ new Map();
+  for (const tool of tools) {
+    const area = areaOf(tool);
+    if (!byArea.has(area)) byArea.set(area, []);
+    byArea.get(area).push(tool.name);
+  }
+  return [...byArea.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([area, names]) => `${area}: ${names.join(", ")}`).join("\n");
+}
+function buildToolSearchTool(searchable) {
+  if (!searchable.length) return [];
+  return [
+    {
+      id: "core.find-tools",
+      name: "findTools",
+      description: `Loads MORE tools. You carry the general-purpose ones plus the ones for the screen the user is on; everything else in this app is listed below and arrives only when you ask for it here. Call this the moment a request belongs to an area you have no tool for \u2014 BEFORE saying you cannot do something. The tools come back callable from your next step, so ask and then act; never announce that you are loading them.
+
+What this app can also do:
+${buildToolIndex(searchable)}`,
+      icon: "Wrench",
+      mode: "read",
+      category: "Core",
+      parameters: {
+        type: "object",
+        properties: {
+          tools: {
+            type: "array",
+            items: { type: "string" },
+            description: "Tool names from the list above. Ask for everything the task needs at once."
+          },
+          query: {
+            type: "string",
+            description: "What you are trying to do, in a few words. Use when no name above clearly matches."
+          }
+        }
+      }
+    }
+  ];
+}
+function words(text) {
+  return text.replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase().split(/[^a-z0-9]+/).filter((w) => w.length > 2);
+}
+function matches(tool, query) {
+  const terms = words(query);
+  if (!terms.length) return false;
+  const haystack = new Set(words(`${tool.name} ${areaOf(tool)} ${tool.description}`));
+  return terms.some((t) => haystack.has(t));
+}
+function resolveToolSearch(args, searchable, carried = /* @__PURE__ */ new Set()) {
+  const asked = Array.isArray(args.tools) ? args.tools.filter((n) => typeof n === "string") : [];
+  const query = typeof args.query === "string" ? args.query : "";
+  const byName = new Map(searchable.map((t) => [t.name.toLowerCase(), t]));
+  const found = /* @__PURE__ */ new Map();
+  for (const name of asked) {
+    const hit = byName.get(name.trim().toLowerCase());
+    if (hit) found.set(hit.name, hit);
+  }
+  if (!found.size && query) {
+    for (const tool of searchable.filter((t) => matches(t, query)).slice(0, 8)) found.set(tool.name, tool);
+  }
+  if (!found.size && asked.length) {
+    for (const tool of searchable.filter((t) => matches(t, asked.join(" "))).slice(0, 8)) found.set(tool.name, tool);
+  }
+  const tools = [...found.values()];
+  if (!tools.length) {
+    const byName2 = new Map([...carried].map((n) => [n.toLowerCase(), n]));
+    const held = asked.map((n) => byName2.get(n.trim().toLowerCase())).filter((n) => !!n);
+    if (held.length) {
+      return {
+        loaded: [],
+        note: `You are already carrying ${held.join(", ")} this turn \u2014 call ${held.length > 1 ? "them" : "it"} directly instead of loading anything.`
+      };
+    }
+  }
+  if (!tools.length) {
+    return {
+      loaded: [],
+      available: buildToolIndex(searchable),
+      note: "Nothing matched. Pick names from the list above, or tell the user this app has no tool for that."
+    };
+  }
+  loadTools(tools.map((t) => t.name));
+  return {
+    loaded: tools.map((t) => ({
+      name: t.name,
+      signature: formatToolSignature(t),
+      // Truncated: the full schema arrives with the tool itself on the next
+      // step, so repeating it here pays for the same text twice.
+      description: t.description.slice(0, 400)
+    })),
+    note: "Available from your next step. Continue the task now \u2014 do not tell the user about this step."
+  };
+}
+
+// src/lib/attachments.ts
+var SAMPLE_ROWS = 5;
+var SCAN_ROWS = 200;
+var MAX_HEADERS = 50;
+var MAX_CELL_CHARS = 120;
+var MAX_SHEETS = 8;
+var PREVIEW_CHARS = 2e3;
+var FULL_READ_LIMIT = 8 * 1024 * 1024;
+var HEAD_SLICE = 512 * 1024;
+var registry = /* @__PURE__ */ new Map();
+var seq = 0;
+function registerAttachment(file) {
+  const id = `att-${Date.now().toString(36)}-${(seq++).toString(36)}`;
+  registry.set(id, { file });
+  return id;
+}
+function getAttachmentFile(id) {
+  return registry.get(id)?.file;
+}
+function releaseAttachment(id) {
+  registry.delete(id);
+}
+function clearAttachmentRegistry() {
+  registry.clear();
+}
+function resolveAttachmentDigest(name) {
+  const readable = [...registry.values()].map((e) => e.parsed).filter((d) => !!d?.headers?.length);
+  if (name?.trim()) {
+    const wanted = name.trim().toLowerCase();
+    return readable.find((d) => d.name.toLowerCase() === wanted);
+  }
+  return readable[readable.length - 1];
+}
+async function readAllRows(digest) {
+  const entry = [...registry.values()].find((e) => e.parsed === digest);
+  if (!entry) throw new Error("The file is no longer available in this conversation.");
+  if (digest.kind !== "csv") {
+    throw new Error("Only CSV files can be read in full here. Ask the user to save the sheet as CSV.");
+  }
+  const text = await entry.file.text();
+  const delimiter = detectDelimiter(text, /\.tsv$/i.test(entry.file.name) ? "	" : void 0);
+  const { rows } = parseDelimited(text, delimiter);
+  if (!rows.length) return [];
+  const headers = rows[0].map((h) => h.trim());
+  return rows.slice(1).filter((row) => row.some((cell) => cell.trim())).map((row) => {
+    const record = {};
+    headers.forEach((header, i) => {
+      if (header) record[header] = (row[i] ?? "").trim();
+    });
+    return record;
+  });
+}
+function listAttachmentNames() {
+  return [...registry.values()].map((e) => e.parsed).filter((d) => !!d?.headers?.length).map((d) => d.name);
+}
+function nonTabularAttachmentNames() {
+  return [...registry.values()].map((e) => e.parsed).filter((d) => !!d && !d.headers?.length && !d.sheets?.length).map((d) => d.name);
+}
+var SPREADSHEET_EXT = /\.(xlsx|xlsm|xls)$/i;
+var CSV_EXT = /\.(csv|tsv)$/i;
+var TEXT_EXT = /\.(txt|md|markdown|json|log)$/i;
+function detectKind(file) {
+  const name = file.name;
+  const mime = file.type || "";
+  if (SPREADSHEET_EXT.test(name) || mime.includes("spreadsheetml") || mime === "application/vnd.ms-excel") {
+    return "spreadsheet";
+  }
+  if (CSV_EXT.test(name) || mime === "text/csv" || mime === "text/tab-separated-values") return "csv";
+  if (mime.startsWith("image/")) return "image";
+  if (mime === "application/pdf" || /\.pdf$/i.test(name)) return "pdf";
+  if (TEXT_EXT.test(name) || mime.startsWith("text/") || mime === "application/json") return "text";
+  return "binary";
+}
+async function parseAttachment(file, id) {
+  const attachmentId = id ?? registerAttachment(file);
+  const base = {
+    id: attachmentId,
+    name: file.name,
+    mime: file.type || "application/octet-stream",
+    size: file.size,
+    kind: detectKind(file)
+  };
+  let digest = base;
+  switch (base.kind) {
+    case "csv":
+      digest = await parseDelimitedFile(file, base);
+      break;
+    case "spreadsheet":
+      digest = await parseSpreadsheetFile(file, base);
+      break;
+    case "text":
+      digest = await parseTextFile(file, base);
+      break;
+  }
+  const entry = registry.get(attachmentId);
+  if (entry) entry.parsed = digest;
+  return digest;
+}
+async function readTextBounded(file) {
+  if (file.size <= FULL_READ_LIMIT) return { text: await file.text(), partial: false };
+  return { text: await file.slice(0, HEAD_SLICE).text(), partial: true };
+}
+async function parseTextFile(file, base) {
+  const { text } = await readTextBounded(file);
+  const preview = text.slice(0, PREVIEW_CHARS);
+  return {
+    ...base,
+    preview,
+    ...text.length > PREVIEW_CHARS ? { warnings: [`preview truncated to ${PREVIEW_CHARS} characters`] } : {}
+  };
+}
+async function parseDelimitedFile(file, base) {
+  const { text, partial } = await readTextBounded(file);
+  const warnings = [];
+  if (partial) {
+    warnings.push("file too large \u2014 only the first rows were read, row count unknown");
+  }
+  const delimiter = detectDelimiter(text, /\.tsv$/i.test(file.name) ? "	" : void 0);
+  const sheet = buildSheet(file.name.replace(CSV_EXT, ""), parseDelimited(text, delimiter), warnings);
+  if (partial) delete sheet.rowCount;
+  return {
+    ...base,
+    headers: sheet.headers,
+    ...sheet.rowCount === void 0 ? {} : { rowCount: sheet.rowCount },
+    sample: sheet.sample,
+    columnTypes: sheet.columnTypes,
+    ...warnings.length ? { warnings } : {}
+  };
+}
+var loadModule = (name) => new Function("m", "return import(m)")(name);
+async function parseSpreadsheetFile(file, base) {
+  let XLSX;
+  try {
+    XLSX = await loadModule("xlsx");
+  } catch {
+    return {
+      ...base,
+      unreadable: "spreadsheet",
+      warnings: [
+        "Excel files are not read here. Ask the user to save the sheet as CSV (File > Save as > CSV) and attach it again \u2014 CSV is read in full."
+      ]
+    };
+  }
+  const warnings = [];
+  let book;
+  try {
+    book = XLSX.read(await file.arrayBuffer(), { type: "array" });
+  } catch {
+    return { ...base, warnings: ["could not read this spreadsheet \u2014 the file may be corrupted"] };
+  }
+  const names = book.SheetNames ?? [];
+  const sheets = [];
+  for (const name of names.slice(0, MAX_SHEETS)) {
+    const ws = book.Sheets?.[name];
+    if (!ws) continue;
+    const raw = XLSX.utils.sheet_to_json(ws, { header: 1, raw: false, defval: "" });
+    const rows = raw.slice(0, SCAN_ROWS).map((row) => row.map((cell) => String(cell ?? "")));
+    sheets.push(buildSheet(name, { rows, count: raw.length }, warnings));
+  }
+  if (names.length > MAX_SHEETS) {
+    warnings.push(`${names.length - MAX_SHEETS} additional sheet(s) not described`);
+  }
+  const only = sheets.length === 1 ? sheets[0] : void 0;
+  return {
+    ...base,
+    ...only ? {
+      headers: only.headers,
+      ...only.rowCount === void 0 ? {} : { rowCount: only.rowCount },
+      sample: only.sample,
+      columnTypes: only.columnTypes
+    } : { sheets },
+    ...warnings.length ? { warnings } : {}
+  };
+}
+function detectDelimiter(text, forced) {
+  if (forced) return forced;
+  const firstLine = text.slice(0, 4e3).split(/\r?\n/)[0] ?? "";
+  let best = ",";
+  let bestCount = 0;
+  for (const candidate of [",", ";", "	", "|"]) {
+    const count = countOutsideQuotes(firstLine, candidate);
+    if (count > bestCount) {
+      best = candidate;
+      bestCount = count;
+    }
+  }
+  return best;
+}
+function countOutsideQuotes(line, char) {
+  let inQuotes = false;
+  let count = 0;
+  for (let i = 0; i < line.length; i++) {
+    const c = line[i];
+    if (c === '"') inQuotes = !inQuotes;
+    else if (!inQuotes && c === char) count++;
+  }
+  return count;
+}
+function parseDelimited(text, delimiter) {
+  const rows = [];
+  let count = 0;
+  let row = [];
+  let field = "";
+  let inQuotes = false;
+  const endField = () => {
+    row.push(field);
+    field = "";
+  };
+  const endRow = () => {
+    endField();
+    count++;
+    if (rows.length < SCAN_ROWS) rows.push(row);
+    row = [];
+  };
+  const source = text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+  for (let i = 0; i < source.length; i++) {
+    const c = source[i];
+    if (inQuotes) {
+      if (c === '"') {
+        if (source[i + 1] === '"') {
+          field += '"';
+          i++;
+        } else inQuotes = false;
+      } else field += c;
+      continue;
+    }
+    if (c === '"' && field === "") inQuotes = true;
+    else if (c === delimiter) endField();
+    else if (c === "\n") endRow();
+    else if (c === "\r") continue;
+    else field += c;
+  }
+  if (field !== "" || row.length) endRow();
+  return { rows, count };
+}
+function buildSheet(name, parsed, warnings) {
+  const [rawHeader = [], ...body] = parsed.rows;
+  const headers = rawHeader.slice(0, MAX_HEADERS).map((h, i) => truncateCell(h).trim() || `col_${i + 1}`);
+  if (rawHeader.length > MAX_HEADERS) {
+    warnings.push(`${name}: ${rawHeader.length - MAX_HEADERS} column(s) beyond the first ${MAX_HEADERS} not described`);
+  }
+  const sample = body.slice(0, SAMPLE_ROWS).map((row) => headers.map((_, i) => truncateCell(row[i] ?? "")));
+  const columnTypes = headers.map(
+    (header, i) => inferColumn(header, body.map((row) => row[i] ?? ""), name, warnings)
+  );
+  return { name, headers, rowCount: Math.max(0, parsed.count - 1), sample, columnTypes };
+}
+function truncateCell(value) {
+  const text = String(value ?? "");
+  return text.length > MAX_CELL_CHARS ? `${text.slice(0, MAX_CELL_CHARS)}\u2026` : text;
+}
+var SLASH_DATE = /^(\d{1,2})[/.-](\d{1,2})[/.-](\d{2,4})$/;
+var ISO_DATE = /^\d{4}-\d{2}-\d{2}([T ]\d{2}:\d{2}(:\d{2})?)?/;
+var EMAIL = /^[^\s@]+@[^\s@]+\.[^\s@]{2,}$/;
+var MASKED_PHONE = /^\+?[\d\s().-]{8,20}$/;
+var BOOLEANS = /* @__PURE__ */ new Set(["sim", "n\xE3o", "nao", "true", "false", "yes", "no", "verdadeiro", "falso"]);
+function inferColumn(name, values, sheetName = "", warnings = []) {
+  const filled = values.slice(0, SCAN_ROWS).map((v) => String(v ?? "").trim()).filter((v) => v !== "");
+  if (!filled.length) return { name, type: "text" };
+  if (filled.every((v) => BOOLEANS.has(v.toLowerCase()))) return { name, type: "boolean" };
+  if (filled.every((v) => EMAIL.test(v))) return { name, type: "email" };
+  const dates = inferDates(filled);
+  if (dates) {
+    if (dates.ambiguous) {
+      const note = dates.reason === "conflict" ? "mixed dd/mm and mm/dd rows \u2014 read as text" : "day/month order cannot be told apart (all values \u2264 12) \u2014 read as text";
+      warnings.push(`${sheetName ? `${sheetName}: ` : ""}column "${name}": ${note}`);
+      return { name, type: "text", note };
+    }
+    return { name, type: "date", format: dates.format };
+  }
+  const identifier = inferIdentifier(name, filled);
+  if (identifier) return identifier;
+  const numbers = inferNumbers(filled);
+  if (numbers) {
+    return {
+      name,
+      type: "number",
+      ...numbers.format ? { format: numbers.format } : {},
+      ...numbers.note ? { note: numbers.note } : {}
+    };
+  }
+  if (filled.every((v) => MASKED_PHONE.test(v) && /[\s().+-]/.test(v) && digitsOf(v).length >= 8)) {
+    return { name, type: "phone" };
+  }
+  return { name, type: "text" };
+}
+function digitsOf(value) {
+  return value.replace(/\D/g, "");
+}
+function inferDates(values) {
+  if (values.every((v) => ISO_DATE.test(v))) return { format: "yyyy-mm-dd", ambiguous: false };
+  if (!values.every((v) => SLASH_DATE.test(v))) return null;
+  let dayFirst = false;
+  let monthFirst = false;
+  for (const value of values) {
+    const match = SLASH_DATE.exec(value);
+    const a = Number(match[1]);
+    const b = Number(match[2]);
+    if (a > 12 && b <= 12) dayFirst = true;
+    if (b > 12 && a <= 12) monthFirst = true;
+    if (a > 31 || b > 31) return null;
+  }
+  if (dayFirst && monthFirst) return { ambiguous: true, reason: "conflict" };
+  if (dayFirst) return { format: "dd/mm/yyyy", ambiguous: false };
+  if (monthFirst) return { format: "mm/dd/yyyy", ambiguous: false };
+  return { ambiguous: true, reason: "undecidable" };
+}
+var BR_DECIMAL = /^-?\d{1,3}(\.\d{3})*,\d+$|^-?\d+,\d+$/;
+var US_DECIMAL = /^-?\d{1,3}(,\d{3})*\.\d+$|^-?\d+\.\d+$/;
+var PLAIN_INT = /^-?\d+$/;
+var DOTTED_GROUP = /^-?\d{1,3}(\.\d{3})+$/;
+var PHONE_HEADER = /(celular|telefone|fone|whats|tel\b|mobile|phone)/i;
+var DOCUMENT_HEADER = /(cpf|cnpj|\brg\b|documento|\bdoc\b|inscri|matr[ií]cula|identificador|c[oó]digo)/i;
+var CEP_HEADER = /(cep|zip|postal)/i;
+function inferIdentifier(name, values) {
+  const bareDigits = values.every((v) => /^\d+$/.test(v));
+  if (!bareDigits) return null;
+  const lengths = values.map((v) => v.length);
+  const hasLeadingZero = values.some((v) => v.length > 1 && v.startsWith("0"));
+  if (PHONE_HEADER.test(name) && lengths.every((n) => n >= 8 && n <= 15)) {
+    return { name, type: "phone", note: "digits only, no mask" };
+  }
+  if (DOCUMENT_HEADER.test(name) || CEP_HEADER.test(name)) {
+    return {
+      name,
+      type: "text",
+      note: "identifier, not a quantity \u2014 keep it as text so leading zeros survive"
+    };
+  }
+  if (hasLeadingZero) {
+    return { name, type: "text", note: "leading zeros \u2014 read as text, not a number" };
+  }
+  return null;
+}
+function inferNumbers(values) {
+  const stripped = values.map((v) => v.replace(/[R$€£%\s ]/g, ""));
+  let br = false;
+  let us = false;
+  let dotted = false;
+  for (const value of stripped) {
+    if (BR_DECIMAL.test(value)) br = true;
+    else if (DOTTED_GROUP.test(value)) dotted = true;
+    else if (US_DECIMAL.test(value)) us = true;
+    else if (!PLAIN_INT.test(value)) return null;
+  }
+  if (br && us) return { note: "mixed decimal separators (, and .)" };
+  if (br) return { format: "1.234,56" };
+  if (us) return { format: "1,234.56" };
+  if (dotted) return { note: "dots could be thousand separators or decimals" };
+  return {};
+}
+async function readAttachmentBytes(id) {
+  const file = getAttachmentFile(id);
+  if (!file) return null;
+  return toInlineFile(file);
+}
+var VISION_MAX_EDGE = 1568;
+async function shrinkForVision(file, maxEdge = VISION_MAX_EDGE) {
+  if (!file.type.startsWith("image/")) return file;
+  if (typeof document === "undefined" || typeof createImageBitmap !== "function") return file;
+  try {
+    const bitmap = await createImageBitmap(file);
+    const longest = Math.max(bitmap.width, bitmap.height);
+    if (longest <= maxEdge) {
+      bitmap.close?.();
+      return file;
+    }
+    const scale = maxEdge / longest;
+    const canvas = document.createElement("canvas");
+    canvas.width = Math.round(bitmap.width * scale);
+    canvas.height = Math.round(bitmap.height * scale);
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+      bitmap.close?.();
+      return file;
+    }
+    ctx.drawImage(bitmap, 0, 0, canvas.width, canvas.height);
+    bitmap.close?.();
+    const blob = await new Promise(
+      (resolve) => canvas.toBlob((b) => resolve(b), "image/jpeg", 0.85)
+    );
+    if (!blob || blob.size >= file.size) return file;
+    return new File([blob], file.name.replace(/\.[^.]+$/, "") + ".jpg", { type: "image/jpeg" });
+  } catch {
+    return file;
+  }
+}
+async function toInlineFile(file) {
+  return {
+    name: file.name,
+    mime: file.type || "application/octet-stream",
+    data: await toBase64(file)
+  };
+}
+async function toBase64(file) {
+  const bytes = new Uint8Array(await file.arrayBuffer());
+  const CHUNK = 32768;
+  let binary = "";
+  for (let i = 0; i < bytes.length; i += CHUNK) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + CHUNK));
+  }
+  return btoa(binary);
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${Math.round(bytes / 1024)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+var STORAGE_PREFIX = "fayz.agent.auto-approve.v1";
+var DESTRUCTIVE = /(delete|destroy|remove|cancel|archive|refund|void)/i;
+function isDestructiveTool(toolName) {
+  return DESTRUCTIVE.test(toolName);
+}
+function approvalKey(toolName, scope) {
+  return scope ? `${toolName}:${scope}` : toolName;
+}
+function storageKey() {
+  const orgId = useOrganizationStore.getState().currentOrg?.id;
+  const userId = useAuthStore.getState().user?.id;
+  if (!orgId || !userId) return null;
+  return `${STORAGE_PREFIX}:${orgId}:${userId}`;
+}
+function read() {
+  const key = storageKey();
+  if (!key || typeof localStorage === "undefined") return [];
+  try {
+    const raw = localStorage.getItem(key);
+    const parsed = raw ? JSON.parse(raw) : [];
+    return Array.isArray(parsed) ? parsed.filter((r) => r && r.key) : [];
+  } catch {
+    return [];
+  }
+}
+function write(rules) {
+  const key = storageKey();
+  if (!key || typeof localStorage === "undefined") return;
+  try {
+    localStorage.setItem(key, JSON.stringify(rules));
+  } catch {
+  }
+}
+var sessionGrants = /* @__PURE__ */ new Set();
+var listeners2 = /* @__PURE__ */ new Set();
+function notify() {
+  for (const listener of Array.from(listeners2)) listener();
+}
+function subscribeAutoApprovals(listener) {
+  listeners2.add(listener);
+  return () => listeners2.delete(listener);
+}
+function listAutoApprovals() {
+  return read();
+}
+function isAutoApproved(toolName, scope) {
+  const key = approvalKey(toolName, scope);
+  if (sessionGrants.has(key)) return true;
+  if (isDestructiveTool(toolName)) return false;
+  return read().some((rule) => rule.key === key);
+}
+function grantAutoApproval(input) {
+  const key = approvalKey(input.toolName, input.scope);
+  if (input.session || isDestructiveTool(input.toolName)) {
+    sessionGrants.add(key);
+    notify();
+    return;
+  }
+  const rules = read().filter((rule) => rule.key !== key);
+  rules.push({
+    key,
+    toolName: input.toolName,
+    scope: input.scope,
+    label: input.label,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  write(rules);
+  notify();
+}
+function revokeAutoApproval(key) {
+  sessionGrants.delete(key);
+  write(read().filter((rule) => rule.key !== key));
+  notify();
+}
+function revokeAllAutoApprovals() {
+  sessionGrants.clear();
+  write([]);
+  notify();
+}
+
+// src/lib/record-refs.ts
+var MAX_ENTRIES = 300;
+var refs = /* @__PURE__ */ new Map();
+var LABEL_FIELDS = [
+  "name",
+  "full_name",
+  "fullName",
+  "title",
+  "label",
+  "client_name",
+  "customer_name",
+  "service_name",
+  "display_name",
+  "email"
+];
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function looksLikeRecordId(value) {
+  return typeof value === "string" && UUID.test(value);
+}
+function bestLabel(row, ref) {
+  if (typeof ref.label === "string" && ref.label.trim()) return ref.label.trim();
+  for (const field of LABEL_FIELDS) {
+    const value = row[field];
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return null;
+}
+function remember(link) {
+  const existing = refs.get(link.id);
+  const merged = {
+    ...link,
+    ...!link.archetype && existing?.archetype ? { archetype: existing.archetype, ...existing.kind ? { kind: existing.kind } : {} } : {},
+    ...!link.entityKey && existing?.entityKey ? { entityKey: existing.entityKey } : {}
+  };
+  refs.delete(link.id);
+  refs.set(link.id, merged);
+  while (refs.size > MAX_ENTRIES) {
+    const oldest = refs.keys().next().value;
+    if (oldest === void 0) break;
+    refs.delete(oldest);
+  }
+}
+function rememberRecordRefs(content) {
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    return;
+  }
+  walk(parsed, 0);
+}
+function walk(node, depth) {
+  if (depth > 6 || !node || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    for (const item of node) walk(item, depth + 1);
+    return;
+  }
+  const row = node;
+  const ref = row.ref;
+  if (ref && typeof ref === "object" && !Array.isArray(ref)) {
+    const r = ref;
+    const id = typeof r.id === "string" ? r.id : null;
+    if (id) {
+      const [archetype, kind] = String(r.archetype ?? "").split(":");
+      const label = bestLabel(row, r);
+      if (label) {
+        remember({
+          id,
+          label,
+          ...archetype ? { archetype } : {},
+          ...kind ? { kind } : {},
+          ...typeof r.entityKey === "string" ? { entityKey: r.entityKey } : {}
+        });
+      }
+    }
+  } else if (looksLikeRecordId(row.id)) {
+    const label = bestLabel(row, {});
+    if (label) remember({ id: row.id, label });
+  }
+  for (const value of Object.values(row)) walk(value, depth + 1);
+}
+function rememberSurfaceRefs(snapshot) {
+  if (!snapshot) return;
+  const list = Array.isArray(snapshot) ? snapshot : [snapshot];
+  for (const entry of list) {
+    if (!entry || typeof entry !== "object") continue;
+    const record = entry.record;
+    if (record && typeof record === "object") {
+      const r = record;
+      if (looksLikeRecordId(r.id)) {
+        const label = typeof r.label === "string" && r.label.trim() || bestLabel(r.summary ?? {}, {});
+        if (label) {
+          remember({
+            id: r.id,
+            label,
+            ...typeof r.entity === "string" ? { entityKey: r.entity } : {}
+          });
+        }
+      }
+    }
+    walk(entry, 0);
+  }
+}
+function lookupRecordRef(id) {
+  if (!looksLikeRecordId(id)) return null;
+  return refs.get(id) ?? null;
+}
+function clearRecordRefs() {
+  refs.clear();
+}
+function extractRecordLinks(content) {
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    return [];
+  }
+  const links = [];
+  const push = (ref, fallbackLabel) => {
+    if (!ref || typeof ref !== "object") return;
+    const r = ref;
+    if (!r.id) return;
+    const [archetype, kind] = (r.archetype ?? "").split(":");
+    links.push({
+      id: r.id,
+      label: String(r.label ?? fallbackLabel ?? "registro"),
+      ...archetype ? { archetype } : {},
+      ...kind ? { kind } : {},
+      ...r.entityKey ? { entityKey: r.entityKey } : {},
+      // A destination the route map cannot derive (a settings tab) — the only
+      // way a non-record result gets a working button.
+      ...typeof r.path === "string" && r.path.startsWith("/") ? { path: r.path } : {}
+    });
+  };
+  const record = parsed.record;
+  push(parsed.ref, record?.name);
+  push(record?.ref, record?.client_name ?? record?.service_name);
+  const singleFrom = (rows) => {
+    if (Array.isArray(rows) && rows.length === 1) {
+      const row = rows[0];
+      push(row.ref, row.name);
+    }
+  };
+  singleFrom(parsed.records);
+  for (const m of Array.isArray(parsed.matches) ? parsed.matches : []) {
+    singleFrom(m.records);
+  }
+  return links;
+}
+function dedupeLinks(links) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const l of links) if (!seen.has(l.id)) seen.set(l.id, l);
+  return Array.from(seen.values()).slice(0, 3);
+}
+
+// src/lib/agent-threads.ts
+var KEY = "fayz.agent.thread-roles";
+var CAP = 200;
+function read2() {
+  if (typeof localStorage === "undefined") return {};
+  try {
+    const raw = localStorage.getItem(KEY);
+    return raw ? JSON.parse(raw) : {};
+  } catch {
+    return {};
+  }
+}
+function write2(map) {
+  if (typeof localStorage === "undefined") return;
+  try {
+    const entries = Object.entries(map);
+    const kept = entries.length > CAP ? entries.slice(entries.length - CAP) : entries;
+    localStorage.setItem(KEY, JSON.stringify(Object.fromEntries(kept)));
+  } catch {
+  }
+}
+function tagConversation(conversationId, role) {
+  const map = read2();
+  if (map[conversationId] === role) return;
+  map[conversationId] = role;
+  write2(map);
+}
+
+// src/lib/assistant-text.ts
+var TOOL_IN_BRACES = /\{\s*[a-z][A-Za-z0-9_]{2,}\s*(?:\([^()]*\))?\s*\}/g;
+var FAKE_BUTTON_LINE = /^[ \t]*\[[^\][\n]{2,60}\][ \t]*$(?!\()/gm;
+function mapOutsideCode(text, transform) {
+  return text.split(/(```[\s\S]*?```|`[^`\n]*`)/g).map((chunk, index) => index % 2 === 1 ? chunk : transform(chunk)).join("");
+}
+function sanitizeAssistantText(text) {
+  if (!text || !text.includes("{") && !text.includes("[")) return text;
+  const cleaned = mapOutsideCode(
+    text,
+    (chunk) => chunk.replace(TOOL_IN_BRACES, "").replace(FAKE_BUTTON_LINE, "")
+  );
+  if (cleaned === text) return text;
+  return cleaned.replace(/[ \t]+$/gm, "").replace(/\n{3,}/g, "\n\n").replace(/^\n+/, "");
+}
+
+// src/stores/chat.store.ts
+function chatCardKey(card) {
+  if (card.kind === "connector") return `connector:${card.slug}`;
+  return `choice:${card.id}`;
+}
+function revokePreview(url) {
+  if (url) URL.revokeObjectURL(url);
+}
+function matchesAccept(file, accept) {
+  if (!accept) return true;
+  return accept.split(",").map((rule) => rule.trim().toLowerCase()).some((rule) => {
+    if (!rule) return false;
+    if (rule.startsWith(".")) return file.name.toLowerCase().endsWith(rule);
+    if (rule.endsWith("/*")) return file.type.toLowerCase().startsWith(rule.slice(0, -1));
+    return file.type.toLowerCase() === rule;
+  });
+}
+var MAX_ATTACHMENTS = 5;
+var MAX_ATTACHMENT_BYTES = 25 * 1024 * 1024;
+var pendingQueue = [];
+function headState() {
+  const head = pendingQueue[0];
+  if (!head) return { pendingAction: null, pendingSameTool: 0 };
+  return {
+    pendingAction: head.action,
+    // Siblings only. A queue of "create a product" + "delete a client" is two
+    // decisions, and offering one button for both is how the wrong thing gets
+    // approved by someone answering the card in front of them.
+    pendingSameTool: pendingQueue.filter((e, i) => i > 0 && e.action.toolName === head.action.toolName).length
+  };
+}
+function declineAllPending() {
+  const queued = pendingQueue;
+  pendingQueue = [];
+  for (const entry of queued) entry.resolve({ approved: false });
+}
+var VOICE_REPLIES_KEY = "fayz.agent.voice-replies";
+function readVoiceRepliesPref() {
+  if (typeof localStorage === "undefined") return false;
+  try {
+    return localStorage.getItem(VOICE_REPLIES_KEY) === "1";
+  } catch {
+    return false;
+  }
+}
+var useChatStore = create((set, get) => ({
+  messages: [],
+  isOpen: false,
+  isStreaming: false,
+  conversationId: null,
+  // Fechar o painel encerra o handoff junto: uma dica sobrevivente devolveria
+  // "Ex.: receita por mesa" a quem abriu o assistente para outra coisa.
+  setOpen: (open) => set(open ? { isOpen: true } : { isOpen: false, composerHint: null, composerFocusRequested: false }),
+  toggleOpen: () => set((s) => ({ isOpen: !s.isOpen })),
+  // Stamped with whoever is on duty, here rather than at each call site: every
+  // message in the transcript needs a face, and a caller that forgets leaves an
+  // anonymous bubble in the middle of a conversation with a named colleague.
+  addMessage: (message) => set((s) => ({
+    messages: [...s.messages, s.threadRole && !message.agentKey ? { ...message, agentKey: s.threadRole } : message]
+  })),
+  setMessageContent: (id, content) => set((s) => {
+    const i = s.messages.findIndex((m) => m.id === id);
+    if (i < 0) return s;
+    const msgs = [...s.messages];
+    msgs[i] = { ...msgs[i], content: sanitizeAssistantText(content) };
+    return { messages: msgs };
+  }),
+  updateLastAssistant: (content) => set((s) => {
+    const msgs = [...s.messages];
+    const lastIdx = msgs.length - 1;
+    if (lastIdx >= 0 && msgs[lastIdx].role === "assistant") {
+      msgs[lastIdx] = { ...msgs[lastIdx], content: sanitizeAssistantText(content) };
+    }
+    return { messages: msgs };
+  }),
+  setStreaming: (isStreaming) => set({ isStreaming }),
+  setConversationId: (conversationId) => {
+    const role = get().threadRole;
+    if (conversationId && role) tagConversation(conversationId, role);
+    set({ conversationId });
+  },
+  threadRole: null,
+  threads: {},
+  switchThread: (role, seed) => {
+    const s = get();
+    if (s.threadRole === role && !seed) return;
+    declineAllPending();
+    clearAttachmentRegistry();
+    clearTurnReportFiles();
+    const threads = { ...s.threads };
+    if (s.threadRole) {
+      threads[s.threadRole] = { messages: s.messages, conversationId: s.conversationId };
+    }
+    const parked = threads[role] ?? { messages: [], conversationId: null };
+    const target = !s.threadRole && s.messages.length ? {
+      messages: [...s.messages, ...parked.messages],
+      conversationId: s.conversationId ?? parked.conversationId
+    } : parked;
+    delete threads[role];
+    set({
+      threads,
+      threadRole: role,
+      messages: seed ? [...target.messages, seed] : target.messages,
+      conversationId: target.conversationId,
+      pendingAction: null,
+      pendingSameTool: 0,
+      activeTools: [],
+      autoApprovedTools: [],
+      attachments: []
+    });
+  },
+  reset: () => {
+    declineAllPending();
+    clearRecordRefs();
+    resetLoadedTools();
+    clearAttachmentRegistry();
+    clearTurnReportFiles();
+    set({
+      messages: [],
+      isStreaming: false,
+      conversationId: null,
+      pendingAction: null,
+      pendingSameTool: 0,
+      activeTools: [],
+      autoApprovedTools: [],
+      attachments: []
+      // suggestionsOpen is a standing preference, not thread state.
+    });
+  },
+  pendingAction: null,
+  pendingSameTool: 0,
+  autoApprovedTools: [],
+  requestConfirmation: (action) => {
+    const destructive = action.destructive ?? isDestructiveTool(action.toolName);
+    if (!action.noAutoApproval && isAutoApproved(action.toolName, action.scope)) {
+      set((s) => ({
+        autoApprovedTools: s.autoApprovedTools.includes(action.toolName) ? s.autoApprovedTools : [...s.autoApprovedTools, action.toolName]
+      }));
+      return Promise.resolve({ approved: true });
+    }
+    return new Promise((resolve) => {
+      pendingQueue = [...pendingQueue, { action: { ...action, destructive }, resolve }];
+      set(headState());
+    });
+  },
+  resolvePendingAction: (approved, values) => {
+    const [head, ...rest] = pendingQueue;
+    if (!head) return;
+    pendingQueue = rest;
+    set(headState());
+    head.resolve({ approved, values });
+  },
+  resolveAllPending: (approved) => {
+    const head = pendingQueue[0];
+    if (!head) return;
+    const toolName = head.action.toolName;
+    const matched = [];
+    const kept = [];
+    for (const entry of pendingQueue) {
+      (entry.action.toolName === toolName ? matched : kept).push(entry);
+    }
+    pendingQueue = kept;
+    set(headState());
+    for (const entry of matched) entry.resolve({ approved });
+  },
+  voiceReplies: readVoiceRepliesPref(),
+  setVoiceReplies: (enabled) => {
+    try {
+      localStorage?.setItem(VOICE_REPLIES_KEY, enabled ? "1" : "0");
+    } catch {
+    }
+    set({ voiceReplies: enabled });
+  },
+  draft: "",
+  setDraft: (draft) => set({ draft }),
+  attachments: [],
+  addAttachments: async (files) => {
+    const room = MAX_ATTACHMENTS - get().attachments.length;
+    if (room <= 0) return;
+    const staged = files.slice(0, room).map((file) => ({
+      file,
+      attachment: {
+        id: registerAttachment(file),
+        name: file.name,
+        size: file.size,
+        mime: file.type || "application/octet-stream",
+        kind: detectKind(file),
+        // The picture IS the label for an image: "image.png · 1.3 MB" tells the
+        // user nothing about which photo they just attached.
+        ...file.type.startsWith("image/") ? { previewUrl: URL.createObjectURL(file) } : {},
+        status: file.size > MAX_ATTACHMENT_BYTES ? "error" : "parsing",
+        ...file.size > MAX_ATTACHMENT_BYTES ? { error: "tooLarge" } : {}
+      }
+    }));
+    if (!staged.length) return;
+    set((s) => ({ attachments: [...s.attachments, ...staged.map((e) => e.attachment)] }));
+    const settle = (id, patch) => set((s) => ({
+      attachments: s.attachments.map((a) => a.id === id ? { ...a, ...patch } : a)
+    }));
+    await Promise.all(
+      staged.map(async ({ file, attachment }) => {
+        if (attachment.status === "error") return;
+        try {
+          settle(attachment.id, { status: "ready", digest: await parseAttachment(file, attachment.id) });
+        } catch {
+          settle(attachment.id, { status: "error", error: "unreadable" });
+        }
+      })
+    );
+  },
+  removeAttachment: (id) => {
+    releaseAttachment(id);
+    revokePreview(get().attachments.find((a) => a.id === id)?.previewUrl);
+    set((s) => ({ attachments: s.attachments.filter((a) => a.id !== id) }));
+  },
+  clearAttachments: () => {
+    for (const attachment of get().attachments) {
+      releaseAttachment(attachment.id);
+      revokePreview(attachment.previewUrl);
+    }
+    set({ attachments: [] });
+  },
+  // Sending clears the CHIPS, never the registry. The file is what the rest of
+  // the conversation is about: released here, "ta certo isso ai" two turns later
+  // reached proposeImport as "there is no readable file attached". The registry
+  // is emptied when the thread is — reset() and setMessages() do it.
+  consumePendingAttachments: () => {
+    const staged = get().attachments;
+    if (!staged.length) return [];
+    const digests = staged.flatMap((a) => a.status === "ready" && a.digest ? [a.digest] : []);
+    set({ attachments: [] });
+    return digests;
+  },
+  composerMedia: null,
+  attachMedia: (composerMedia) => set({ composerMedia }),
+  clearComposerMedia: () => set({ composerMedia: null }),
+  uploadRequest: null,
+  requestUpload: (request) => {
+    const id = `upload-${Date.now()}`;
+    set({ uploadRequest: { ...request, id, status: "waiting", files: [] }, isOpen: true });
+    return id;
+  },
+  addUploadFiles: (files) => {
+    const request = get().uploadRequest;
+    if (!request || files.length === 0) return;
+    const staged = (request.multiple ? files : files.slice(0, 1)).map((file) => ({
+      file,
+      previewUrl: file.type.startsWith("image/") ? URL.createObjectURL(file) : void 0
+    }));
+    const kept = request.multiple ? [...request.files, ...staged] : staged;
+    if (!request.multiple) for (const previous of request.files) revokePreview(previous.previewUrl);
+    set({ uploadRequest: { ...request, files: kept } });
+  },
+  removeUploadFile: (index) => {
+    const request = get().uploadRequest;
+    if (!request) return;
+    revokePreview(request.files[index]?.previewUrl);
+    set({ uploadRequest: { ...request, files: request.files.filter((_, i) => i !== index) } });
+  },
+  submitUpload: async () => {
+    const request = get().uploadRequest;
+    if (!request || request.files.length === 0) return;
+    set({ uploadRequest: { ...request, status: "working" } });
+    try {
+      await request.onFiles(request.files.map((staged) => staged.file));
+    } finally {
+      for (const staged of request.files) revokePreview(staged.previewUrl);
+      if (get().uploadRequest?.id === request.id) set({ uploadRequest: null });
+    }
+  },
+  clearUploadRequest: () => {
+    const request = get().uploadRequest;
+    if (request) for (const staged of request.files) revokePreview(staged.previewUrl);
+    set({ uploadRequest: null });
+  },
+  receiveFiles: (files) => {
+    if (files.length === 0) return;
+    const request = get().uploadRequest;
+    if (request && request.status !== "working") {
+      const wanted = files.filter((file) => matchesAccept(file, request.accept));
+      if (wanted.length) {
+        get().addUploadFiles(wanted);
+        const rest = files.filter((file) => !wanted.includes(file));
+        if (rest.length) void get().addAttachments(rest);
+        return;
+      }
+    }
+    void get().addAttachments(files);
+  },
+  queuedPrompt: null,
+  queuedFilesToRead: null,
+  queuePrompt: (queuedPrompt, filesToRead) => set({ queuedPrompt, queuedFilesToRead: filesToRead?.length ? filesToRead : null, isOpen: true }),
+  consumeQueuedFilesToRead: () => {
+    const files = get().queuedFilesToRead;
+    if (files) set({ queuedFilesToRead: null });
+    return files;
+  },
+  composerHint: null,
+  setComposerHint: (composerHint) => set({ composerHint }),
+  composerFocusRequested: false,
+  requestComposerFocus: () => set({ composerFocusRequested: true }),
+  consumeComposerFocus: () => set({ composerFocusRequested: false }),
+  consumeQueuedPrompt: () => {
+    const prompt = get().queuedPrompt;
+    if (prompt) set({ queuedPrompt: null });
+    return prompt;
+  },
+  // Open to begin with; collapsing sticks for the session.
+  suggestionsOpen: true,
+  setSuggestionsOpen: (suggestionsOpen) => set({ suggestionsOpen }),
+  voiceStartRequested: false,
+  requestVoiceStart: () => set({ isOpen: true, voiceStartRequested: true }),
+  consumeVoiceStart: () => set({ voiceStartRequested: false }),
+  activeTools: [],
+  setActiveTools: (activeTools) => set({ activeTools }),
+  appendToolCallsToLastAssistant: (calls) => set((s) => {
+    if (!calls.length) return s;
+    const msgs = [...s.messages];
+    const lastIdx = msgs.length - 1;
+    if (lastIdx >= 0 && msgs[lastIdx].role === "assistant") {
+      msgs[lastIdx] = { ...msgs[lastIdx], toolCalls: [...msgs[lastIdx].toolCalls ?? [], ...calls] };
+    }
+    return { messages: msgs };
+  }),
+  appendLinksToLastAssistant: (links) => set((s) => {
+    if (!links.length) return s;
+    const msgs = [...s.messages];
+    const lastIdx = msgs.length - 1;
+    if (lastIdx >= 0 && msgs[lastIdx].role === "assistant") {
+      const seen = new Map((msgs[lastIdx].links ?? []).map((l) => [l.id, l]));
+      for (const l of links) if (!seen.has(l.id)) seen.set(l.id, l);
+      msgs[lastIdx] = { ...msgs[lastIdx], links: Array.from(seen.values()).slice(0, 3) };
+    }
+    return { messages: msgs };
+  }),
+  appendCardsToLastAssistant: (cards) => set((s) => {
+    if (!cards.length) return s;
+    const msgs = [...s.messages];
+    const lastIdx = msgs.length - 1;
+    if (lastIdx >= 0 && msgs[lastIdx].role === "assistant") {
+      const seen = new Map((msgs[lastIdx].cards ?? []).map((c) => [chatCardKey(c), c]));
+      for (const c of cards) if (!seen.has(chatCardKey(c))) seen.set(chatCardKey(c), c);
+      msgs[lastIdx] = { ...msgs[lastIdx], cards: Array.from(seen.values()).slice(0, 4) };
+    }
+    return { messages: msgs };
+  }),
+  conversations: [],
+  conversationsLoaded: false,
+  setConversations: (conversations) => set({ conversations, conversationsLoaded: true }),
+  setMessages: (messages) => {
+    clearAttachmentRegistry();
+    set({ messages, attachments: [] });
+  }
+}));
+
+export { ALWAYS_ON_TOOLS, CORE_QUERY_ENTITIES, PROFILE_ACTIONS, buildDataPrimitiveTools, buildPermissionTools, buildToolSearchTool, chatCardKey, coreAITools, dedupeLinks, detectKind, entityToolName, extractRecordLinks, formatBytes, formatToolSignature, getAttachmentFile, grantAutoApproval, listAttachmentNames, listAutoApprovals, loadArea, loadTools, loadedToolNames, looksLikeRecordId, lookupRecordRef, nonTabularAttachmentNames, readAllRows, readAttachmentBytes, registryToolName, rememberRecordRefs, rememberSurfaceRefs, resetLoadedTools, resolveAttachmentDigest, resolveLoadedNames, resolveToolSearch, revokeAllAutoApprovals, revokeAutoApproval, searchableTools, setTurnReportFiles, shrinkForVision, subscribeAutoApprovals, takeTurnReportFiles, toInlineFile, useChatStore };
+//# sourceMappingURL=chunk-KLO7DKXX.js.map
+//# sourceMappingURL=chunk-KLO7DKXX.js.map