@deepagents/text2sql 0.2.3 → 0.3.1

package/dist/lib/agents/text2sql.agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"text2sql.agent.d.ts","sourceRoot":"","sources":["../../../src/lib/agents/text2sql.agent.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,IAAI,EAAQ,MAAM,IAAI,CAAC;AAWrC,OAAO,KAAK,EAAW,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAGrE,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC;AAsKlE,eAAO,MAAM,YAAY;SAzDhB,MAAM;;mBAEI,aAAa;aACnB,MAAM;iBACF,MAAM;qBACF,cAAc;eACpB,MAAM;kBACH,MAAM;;mBALL,aAAa;aACnB,MAAM;iBACF,MAAM;qBACF,cAAc;eACpB,MAAM;kBACH,MAAM;EAwEtB,CAAC;AAEH,eAAO,MAAM,gBAAgB;SAjFpB,MAAM;;mBAEI,aAAa;aACnB,MAAM;iBACF,MAAM;qBACF,cAAc;eACpB,MAAM;kBACH,MAAM;;mBALL,aAAa;aACnB,MAAM;iBACF,MAAM;qBACF,cAAc;eACpB,MAAM;kBACH,MAAM;EA8EtB,CAAC"}
+{"version":3,"file":"text2sql.agent.d.ts","sourceRoot":"","sources":["../../../src/lib/agents/text2sql.agent.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,IAAI,EAAQ,MAAM,IAAI,CAAC;AAarC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAEjE,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC;AAmHlE,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgEvB,CAAC;AAgCF,eAAO,MAAM,aAAa,wIAqBxB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,KAAK;SACT,MAAM;;mBAGI,MAAM;eACV,MAAM;aACR,eAAe;aACf,MAAM;;mBAHA,MAAM;eACV,MAAM;aACR,eAAe;aACf,MAAM;EAiBjB,CAAC"}

package/dist/lib/file-cache.d.ts

@@ -0,0 +1,12 @@
+export declare class FileCache {
+    path: string;
+    constructor(watermark: string, extension?: string);
+    get(): Promise<string | null>;
+    set(content: string): Promise<void>;
+}
+export declare class JsonCache<T> extends FileCache {
+    constructor(watermark: string);
+    read(): Promise<T | null>;
+    write(data: T): Promise<void>;
+}
+//# sourceMappingURL=file-cache.d.ts.map

package/dist/lib/file-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-cache.d.ts","sourceRoot":"","sources":["../../src/lib/file-cache.ts"],"names":[],"mappings":"AAMA,qBAAa,SAAS;IACb,IAAI,EAAE,MAAM,CAAC;gBACR,SAAS,EAAE,MAAM,EAAE,SAAS,SAAS;IAK3C,GAAG;IAOT,GAAG,CAAC,OAAO,EAAE,MAAM;CAGpB;AAED,qBAAa,SAAS,CAAC,CAAC,CAAE,SAAQ,SAAS;gBAC7B,SAAS,EAAE,MAAM;IAIvB,IAAI,IAAI,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAQ/B,KAAK,CAAC,IAAI,EAAE,CAAC;CAGd"}

package/dist/lib/instructions.d.ts

@@ -0,0 +1,3 @@
+export * from './teach/teachables.ts';
+export { default } from './teach/teachables.ts';
+//# sourceMappingURL=instructions.d.ts.map

package/dist/lib/instructions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instructions.d.ts","sourceRoot":"","sources":["../../src/lib/instructions.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/lib/instructions.js

@@ -0,0 +1,386 @@
+// packages/text2sql/src/lib/teach/xml.ts
+function wrapBlock(tag, children) {
+  const content = children.filter((child) => Boolean(child)).join("\n");
+  if (!content) {
+    return "";
+  }
+  return `<${tag}>
+${indentBlock(content, 2)}
+</${tag}>`;
+}
+function list(tag, values, childTag) {
+  if (!values.length) {
+    return "";
+  }
+  const children = values.map((value) => leaf(childTag, value)).join("\n");
+  return `<${tag}>
+${indentBlock(children, 2)}
+</${tag}>`;
+}
+function leaf(tag, value) {
+  const safe = escapeXml(value);
+  if (safe.includes("\n")) {
+    return `<${tag}>
+${indentBlock(safe, 2)}
+</${tag}>`;
+  }
+  return `<${tag}>${safe}</${tag}>`;
+}
+function indentBlock(text, spaces) {
+  if (!text.trim()) {
+    return "";
+  }
+  const padding = " ".repeat(spaces);
+  return text.split("\n").map((line) => line.length ? padding + line : padding).join("\n");
+}
+function escapeXml(value) {
+  if (value == null) {
+    return "";
+  }
+  return value.replaceAll(/&/g, "&amp;").replaceAll(/</g, "&lt;").replaceAll(/>/g, "&gt;").replaceAll(/"/g, "&quot;").replaceAll(/'/g, "&apos;");
+}
+
+// packages/text2sql/src/lib/teach/teachables.ts
+function term(name, definition) {
+  return {
+    type: "term",
+    format: () => wrapBlock("term", [leaf("name", name), leaf("definition", definition)])
+  };
+}
+function hint(text) {
+  return {
+    type: "hint",
+    format: () => leaf("hint", text)
+  };
+}
+function guardrail(input) {
+  const { rule, reason, action } = input;
+  return {
+    type: "guardrail",
+    format: () => wrapBlock("guardrail", [
+      leaf("rule", rule),
+      reason ? leaf("reason", reason) : "",
+      action ? leaf("action", action) : ""
+    ])
+  };
+}
+function explain(input) {
+  const { concept, explanation, therefore } = input;
+  return {
+    type: "explain",
+    format: () => wrapBlock("explanation", [
+      leaf("concept", concept),
+      leaf("details", explanation),
+      therefore ? leaf("therefore", therefore) : ""
+    ])
+  };
+}
+function example(input) {
+  const { question, answer, note } = input;
+  return {
+    type: "example",
+    format: () => wrapBlock("example", [
+      leaf("question", question),
+      leaf("answer", answer),
+      note ? leaf("note", note) : ""
+    ])
+  };
+}
+function clarification(input) {
+  const { when, ask, reason } = input;
+  return {
+    type: "clarification",
+    format: () => wrapBlock("clarification", [
+      leaf("when", when),
+      leaf("ask", ask),
+      leaf("reason", reason)
+    ])
+  };
+}
+function workflow(input) {
+  const { task, steps, triggers, notes } = input;
+  return {
+    type: "workflow",
+    format: () => wrapBlock("workflow", [
+      leaf("task", task),
+      triggers?.length ? list("triggers", triggers, "trigger") : "",
+      list("steps", steps, "step"),
+      notes ? leaf("notes", notes) : ""
+    ])
+  };
+}
+function quirk(input) {
+  const { issue, workaround } = input;
+  return {
+    type: "quirk",
+    format: () => wrapBlock("quirk", [
+      leaf("issue", issue),
+      leaf("workaround", workaround)
+    ])
+  };
+}
+function styleGuide(input) {
+  const { prefer, never, always } = input;
+  return {
+    type: "styleGuide",
+    format: () => wrapBlock("style_guide", [
+      leaf("prefer", prefer),
+      always ? leaf("always", always) : "",
+      never ? leaf("never", never) : ""
+    ])
+  };
+}
+function analogy(input) {
+  const { concept, relationship, insight, therefore, pitfall } = input;
+  return {
+    type: "analogy",
+    format: () => wrapBlock("analogy", [
+      list("concepts", concept, "concept"),
+      leaf("relationship", relationship),
+      insight ? leaf("insight", insight) : "",
+      therefore ? leaf("therefore", therefore) : "",
+      pitfall ? leaf("pitfall", pitfall) : ""
+    ])
+  };
+}
+function glossary(entries) {
+  return {
+    type: "glossary",
+    format: () => wrapBlock(
+      "glossary",
+      Object.entries(entries).map(
+        ([term2, sql]) => wrapBlock("entry", [leaf("term", term2), leaf("sql", sql)])
+      )
+    )
+  };
+}
+function identity(input) {
+  const { name, role } = input;
+  return {
+    type: "identity",
+    format: () => wrapBlock("identity", [
+      name ? leaf("name", name) : "",
+      role ? leaf("role", role) : ""
+    ])
+  };
+}
+function persona(input) {
+  const { name, role, tone } = input;
+  return {
+    type: "persona",
+    format: () => wrapBlock("persona", [
+      leaf("name", name),
+      leaf("role", role),
+      leaf("tone", tone)
+    ])
+  };
+}
+function alias(termName, meaning) {
+  return {
+    type: "alias",
+    format: () => wrapBlock("alias", [leaf("term", termName), leaf("meaning", meaning)])
+  };
+}
+function preference(aspect, value) {
+  return {
+    type: "preference",
+    format: () => wrapBlock("preference", [leaf("aspect", aspect), leaf("value", value)])
+  };
+}
+function context(description) {
+  return {
+    type: "context",
+    format: () => leaf("context", description)
+  };
+}
+function correction(subject, clarification2) {
+  return {
+    type: "correction",
+    format: () => wrapBlock("correction", [
+      leaf("subject", subject),
+      leaf("clarification", clarification2)
+    ])
+  };
+}
+function teachable(tag, ...teachables) {
+  return {
+    type: "user_profile",
+    format: () => toInstructions(tag, ...teachables)
+  };
+}
+function toInstructions(tag, ...teachables) {
+  if (!teachables.length) {
+    return "";
+  }
+  const grouped = /* @__PURE__ */ new Map();
+  for (const teachable2 of teachables) {
+    const existing = grouped.get(teachable2.type) ?? [];
+    existing.push(teachable2);
+    grouped.set(teachable2.type, existing);
+  }
+  const definedTypes = new Set(SECTION_ORDER.map((s) => s.type));
+  const sections = SECTION_ORDER.map(({ type, tag: tag2 }) => {
+    const items = grouped.get(type);
+    if (!items?.length) {
+      return "";
+    }
+    const renderedItems = items.map((item) => item.format().trim()).filter(Boolean).map((item) => indentBlock(item, 2)).join("\n");
+    if (!renderedItems.length) {
+      return "";
+    }
+    return `<${tag2}>
+${renderedItems}
+</${tag2}>`;
+  }).filter((section) => Boolean(section));
+  for (const [type, items] of grouped) {
+    if (definedTypes.has(type)) {
+      continue;
+    }
+    const renderedItems = items.map((item) => item.format().trim()).filter(Boolean).map((item) => indentBlock(item, 2)).join("\n");
+    if (renderedItems.length) {
+      sections.push(renderedItems);
+    }
+  }
+  if (!sections.length) {
+    return "";
+  }
+  const content = indentBlock(sections.join("\n"), 2);
+  return `<${tag}>
+${content}
+</${tag}>`;
+}
+var SECTION_ORDER = [
+  // User context (render first - most important for personalization)
+  { type: "identity", tag: "identity" },
+  { type: "persona", tag: "persona" },
+  { type: "context", tag: "user_context" },
+  { type: "preference", tag: "user_preferences" },
+  { type: "alias", tag: "user_vocabulary" },
+  { type: "correction", tag: "user_corrections" },
+  // Domain knowledge
+  { type: "guardrail", tag: "guardrails" },
+  { type: "styleGuide", tag: "style_guides" },
+  { type: "hint", tag: "hints" },
+  { type: "clarification", tag: "clarifications" },
+  { type: "workflow", tag: "workflows" },
+  { type: "quirk", tag: "quirks" },
+  { type: "term", tag: "terminology" },
+  { type: "explain", tag: "explanations" },
+  { type: "analogy", tag: "analogies" },
+  { type: "glossary", tag: "glossary" },
+  { type: "example", tag: "examples" }
+];
+function toTeachables(generated) {
+  return generated.map((item) => {
+    switch (item.type) {
+      case "persona":
+        return persona({ name: item.name, role: item.role, tone: item.tone });
+      case "term":
+        return term(item.name, item.definition);
+      case "hint":
+        return hint(item.text);
+      case "guardrail":
+        return guardrail({
+          rule: item.rule,
+          reason: item.reason,
+          action: item.action
+        });
+      case "explain":
+        return explain({
+          concept: item.concept,
+          explanation: item.explanation,
+          therefore: item.therefore
+        });
+      case "example":
+        return example({
+          question: item.question,
+          answer: item.answer,
+          note: item.note
+        });
+      case "clarification":
+        return clarification({
+          when: item.when,
+          ask: item.ask,
+          reason: item.reason
+        });
+      case "workflow":
+        return workflow({
+          task: item.task,
+          steps: item.steps,
+          triggers: item.triggers,
+          notes: item.notes
+        });
+      case "quirk":
+        return quirk({
+          issue: item.issue,
+          workaround: item.workaround
+        });
+      case "styleGuide":
+        return styleGuide({
+          prefer: item.prefer,
+          never: item.never,
+          always: item.always
+        });
+      case "analogy":
+        return analogy({
+          concept: item.concept,
+          relationship: item.relationship,
+          insight: item.insight,
+          therefore: item.therefore,
+          pitfall: item.pitfall
+        });
+      case "glossary":
+        return glossary(item.entries);
+      // User-specific teachable types
+      case "identity":
+        return identity({ name: item.name, role: item.role });
+      case "alias":
+        return alias(item.term, item.meaning);
+      case "preference":
+        return preference(item.aspect, item.value);
+      case "context":
+        return context(item.description);
+      case "correction":
+        return correction(item.subject, item.clarification);
+    }
+  });
+}
+var teachables_default = {
+  persona,
+  term,
+  hint,
+  guardrail,
+  explain,
+  example,
+  clarification,
+  workflow,
+  quirk,
+  styleGuide,
+  analogy,
+  glossary,
+  teachable
+};
+export {
+  alias,
+  analogy,
+  clarification,
+  context,
+  correction,
+  teachables_default as default,
+  example,
+  explain,
+  glossary,
+  guardrail,
+  hint,
+  identity,
+  persona,
+  preference,
+  quirk,
+  styleGuide,
+  teachable,
+  term,
+  toInstructions,
+  toTeachables,
+  workflow
+};
+//# sourceMappingURL=instructions.js.map

package/dist/lib/instructions.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/lib/teach/xml.ts", "../../src/lib/teach/teachables.ts"],
+  "sourcesContent": ["export function wrapBlock(tag: string, children: string[]): string {\n  const content = children\n    .filter((child): child is string => Boolean(child))\n    .join('\\n');\n  if (!content) {\n    return '';\n  }\n  return `<${tag}>\\n${indentBlock(content, 2)}\\n</${tag}>`;\n}\n\nexport function list(tag: string, values: string[], childTag: string): string {\n  if (!values.length) {\n    return '';\n  }\n  const children = values.map((value) => leaf(childTag, value)).join('\\n');\n  return `<${tag}>\\n${indentBlock(children, 2)}\\n</${tag}>`;\n}\n\nexport function leaf(tag: string, value: string): string {\n  const safe = escapeXml(value);\n  if (safe.includes('\\n')) {\n    return `<${tag}>\\n${indentBlock(safe, 2)}\\n</${tag}>`;\n  }\n  return `<${tag}>${safe}</${tag}>`;\n}\n\nexport function indentBlock(text: string, spaces: number): string {\n  if (!text.trim()) {\n    return '';\n  }\n  const padding = ' '.repeat(spaces);\n  return text\n    .split('\\n')\n    .map((line) => (line.length ? padding + line : padding))\n    .join('\\n');\n}\n\nexport function escapeXml(value: string): string {\n  if (value == null) {\n    return '';\n  }\n  return value\n    .replaceAll(/&/g, '&amp;')\n    .replaceAll(/</g, '&lt;')\n    .replaceAll(/>/g, '&gt;')\n    .replaceAll(/\"/g, '&quot;')\n    .replaceAll(/'/g, '&apos;');\n}\n", "import { indentBlock, leaf, list, wrapBlock } from './xml.ts';\n\nexport interface Teachables {\n  type:\n    | 'term'\n    | 'hint'\n    | 'guardrail'\n    | 'explain'\n    | 'example'\n    | 'clarification'\n    | 'workflow'\n    | 'quirk'\n    | 'styleGuide'\n    | 'analogy'\n    | 'glossary'\n    | 'user_profile'\n    // User-specific teachable types\n    | 'identity'\n    | 'persona'\n    | 'alias'\n    | 'preference'\n    | 'context'\n    | 'correction';\n  format: () => string;\n}\nexport type GeneratedTeachable =\n  | { type: 'term'; name: string; definition: string }\n  | { type: 'hint'; text: string }\n  | { type: 'guardrail'; rule: string; reason?: string; action?: string }\n  | {\n      type: 'explain';\n      concept: string;\n      explanation: string;\n      therefore?: string;\n    }\n  | { type: 'example'; question: string; answer: string; note?: string }\n  | { type: 'clarification'; when: string; ask: string; reason: string }\n  | {\n      type: 'workflow';\n      task: string;\n      steps: string[];\n      triggers?: string[];\n      notes?: string;\n    }\n  | { type: 'quirk'; issue: string; workaround: string }\n  | { type: 'styleGuide'; prefer: string; never?: string; always?: string }\n  | {\n      type: 'analogy';\n      concept: string[];\n      relationship: string;\n      insight?: string;\n      therefore?: string;\n      pitfall?: string;\n    }\n  | { type: 'glossary'; entries: Record<string, string> }\n  // User-specific teachable types\n  | { type: 'identity'; name?: string; role?: string }\n  | { type: 'persona'; name: string; role: string; tone: string }\n  | { type: 'alias'; term: string; meaning: string }\n  | { type: 'preference'; aspect: string; value: string }\n  | { type: 'context'; description: string }\n  | { type: 'correction'; subject: string; clarification: string };\n\n/**\n * Teach the system domain-specific vocabulary and business terminology.\n *\n * Use this to define simple, direct mappings between business terms and their meanings.\n * The system will understand these terms when users mention them in queries.\n *\n * @param name - The business term or acronym to define\n * @param definition - What the term means in your domain\n *\n * @example\n * // Logistics/Transportation dataset\n * term(\"deadhead miles\", \"distance driven with empty truck between deliveries\")\n * term(\"dwell time\", \"total time a truck spends at a loading dock or warehouse\")\n * term(\"LTL\", \"less than truckload - shipment that doesn't fill entire truck\")\n *\n * @example\n * // Education/University dataset\n * term(\"matriculation\", \"students who completed enrollment and started classes\")\n * term(\"DFW rate\", \"percentage of students receiving D, F, or Withdrawal in a course\")\n * term(\"cohort\", \"group of students who entered the same semester or academic year\")\n *\n * @example\n * // Finance/Banking dataset\n * term(\"NPL\", \"non-performing loan - loan past due 90+ days\")\n * term(\"basis points\", \"one hundredth of a percentage point (1% = 100 bps)\")\n * term(\"AUM\", \"assets under management - total market value of client investments\")\n */\nexport function term(name: string, definition: string): Teachables {\n  return {\n    type: 'term',\n    format: () =>\n      wrapBlock('term', [leaf('name', name), leaf('definition', definition)]),\n  };\n}\n\n/**\n * Teach the system behavioral rules and constraints that should always apply.\n *\n * Use this for business logic, data quality rules, or query preferences that should\n * be automatically applied to all relevant queries. Hints are injected as constraints\n * in the system prompt.\n *\n * @param text - The rule or constraint to follow (use imperative language)\n *\n * @example\n * // Manufacturing/Supply Chain dataset\n * hint(\"Always exclude work orders with status = 'simulation' from production metrics\")\n * hint(\"When calculating OEE (overall equipment effectiveness), only count scheduled production time\")\n * hint(\"Defect rates should be calculated per batch, not per individual unit, for consistency\")\n *\n * @example\n * // Real Estate/Property dataset\n * hint(\"Never include properties with listing_status = 'draft' in market analysis\")\n * hint(\"Always filter out duplicate MLS listings - use the earliest listing_date for each property_id\")\n * hint(\"Square footage comparisons must specify if including or excluding basement/garage\")\n *\n * @example\n * // Social Media/Content Platform dataset\n * hint(\"Engagement metrics should exclude bot accounts identified by is_verified_human = false\")\n * hint(\"View counts reset daily - always use cumulative_views for historical analysis\")\n * hint(\"Default content filters to published_status = 'public' unless analyzing drafts\")\n */\nexport function hint(text: string): Teachables {\n  return {\n    type: 'hint',\n    format: () => leaf('hint', text),\n  };\n}\n\n/**\n * Define hard guardrails, safety rules, and compliance boundaries the system must enforce.\n *\n * Use this for \"never do\" rules, sensitive data handling, and required behaviors when\n * certain conditions occur. Guardrails should be explicit and action oriented.\n *\n * @param input.rule - The guardrail or restriction to enforce\n * @param input.reason - Why this guardrail exists (compliance, security, performance)\n * @param input.action - What to do when this guardrail is triggered (block, ask, sanitize)\n *\n * @example\n * // Healthcare dataset\n * guardrail({\n *   rule: \"Never return PHI like SSN, MRN, or full address in query results\",\n *   reason: \"HIPAA compliance\",\n *   action: \"If asked, state that identifiable patient data cannot be shared; offer de-identified aggregates instead\"\n * })\n *\n * @example\n * // Finance dataset\n * guardrail({\n *   rule: \"Block any query exposing employee-level compensation by name\",\n *   reason: \"Confidential payroll data\",\n *   action: \"Provide ranges grouped by department or level instead of individual salaries\"\n * })\n *\n * @example\n * // E-commerce dataset\n * guardrail({\n *   rule: \"Warn when a query would scan more than 10 million rows; require a narrower date range\",\n *   reason: \"Performance and cost control\",\n *   action: \"Ask the user to add filters (recent timeframe, specific categories) before proceeding\"\n * })\n */\nexport function guardrail(input: {\n  rule: string;\n  reason?: string;\n  action?: string;\n}): Teachables {\n  const { rule, reason, action } = input;\n  return {\n    type: 'guardrail',\n    format: () =>\n      wrapBlock('guardrail', [\n        leaf('rule', rule),\n        reason ? leaf('reason', reason) : '',\n        action ? leaf('action', action) : '',\n      ]),\n  };\n}\n\n/**\n * Teach the system a rich understanding of a single concept using metaphors and explanations.\n *\n * Use this when a simple term definition isn't enough - when you need to convey deeper\n * understanding about how to think about and calculate a metric or concept.\n *\n * @param input.concept - The concept being explained\n * @param input.explanation - A metaphor or detailed explanation (often using real-world comparisons)\n * @param input.therefore - Optional actionable instruction based on this understanding\n *\n * @example\n * // Gaming/Entertainment dataset\n * explain({\n *   concept: \"daily active users to monthly active users ratio\",\n *   explanation: \"like measuring how many club members visit daily vs just once a month - shows stickiness\",\n *   therefore: \"Calculate as DAU / MAU, where higher ratio (closer to 1) means more engaged user base\"\n * })\n *\n * @example\n * // HR/Employee Management dataset\n * explain({\n *   concept: \"time to fill\",\n *   explanation: \"like measuring how long a house sits on the market - from posting job to accepting offer\",\n *   therefore: \"Calculate as days between job_posted_date and offer_accepted_date, exclude cancelled requisitions\"\n * })\n *\n * @example\n * // Telecommunications dataset\n * explain({\n *   concept: \"network congestion ratio\",\n *   explanation: \"like rush hour traffic density - measures actual usage vs total capacity at peak times\",\n *   therefore: \"Calculate as (peak_hour_bandwidth_used / total_bandwidth_capacity) during busiest hour of day\"\n * })\n */\nexport function explain(input: {\n  concept: string;\n  explanation: string;\n  therefore?: string;\n}): Teachables {\n  const { concept, explanation, therefore } = input;\n  return {\n    type: 'explain',\n    format: () =>\n      wrapBlock('explanation', [\n        leaf('concept', concept),\n        leaf('details', explanation),\n        therefore ? leaf('therefore', therefore) : '',\n      ]),\n  };\n}\n\n/**\n * Teach the system through concrete examples of question \u2192 SQL pairs.\n *\n * Use this for few-shot learning - show the system exactly how to translate\n * specific types of questions into SQL queries. Great for establishing patterns\n * and handling domain-specific query structures.\n *\n * @param input.question - The natural language question or request\n * @param input.answer - The correct answer that responds to the question\n * @param input.note - Optional note or explanation about the example\n *\n * @example\n * // Energy/Utilities dataset\n * example({\n *   question: \"show me peak demand hours for the last week\",\n *   answer: \"SELECT DATE_TRUNC('hour', reading_timestamp) as hour, MAX(consumption_kwh) as peak_demand FROM meter_readings WHERE reading_timestamp >= CURRENT_DATE - INTERVAL '7 days' GROUP BY hour ORDER BY peak_demand DESC LIMIT 10\"\n * })\n *\n * @example\n * // Agriculture/Farm Management dataset\n * example({\n *   question: \"what is the average yield per acre by crop type this season\",\n *   answer: \"SELECT crop_type, AVG(harvest_quantity / field_acres) as yield_per_acre FROM harvests WHERE harvest_date >= '2024-01-01' GROUP BY crop_type ORDER BY yield_per_acre DESC\"\n * })\n *\n * @example\n * // Travel/Hospitality dataset\n * example({\n *   question: \"show me hotel occupancy rate for this month\",\n *   answer: \"SELECT hotel_name, (SUM(occupied_rooms) / SUM(total_rooms)) * 100 as occupancy_rate FROM daily_occupancy WHERE date >= DATE_TRUNC('month', CURRENT_DATE) GROUP BY hotel_id, hotel_name ORDER BY occupancy_rate DESC\",\n *   note: \"Occupancy rate is a percentage - multiply by 100 for readable output\"\n * })\n */\nexport function example(input: {\n  question: string;\n  answer: string;\n  note?: string;\n}): Teachables {\n  const { question, answer, note } = input;\n  return {\n    type: 'example',\n    format: () =>\n      wrapBlock('example', [\n        leaf('question', question),\n        leaf('answer', answer),\n        note ? leaf('note', note) : '',\n      ]),\n  };\n}\n\n/**\n * Teach the system when and what to ask for clarification.\n *\n * Use this to handle ambiguous terms or situations where the system should\n * proactively ask the user for more information before generating a query.\n * Makes the system more conversational and precise.\n *\n * @param input.when - The condition or trigger that should prompt clarification\n * @param input.ask - The question to ask the user\n * @param input.reason - Why this clarification is necessary (helps system understand importance)\n *\n * @example\n * // Marketing/Advertising dataset\n * clarification({\n *   when: \"user asks for 'conversion rate'\",\n *   ask: \"Which conversion: click-to-lead, lead-to-opportunity, or opportunity-to-customer?\",\n *   reason: \"Conversion rate means different things at each funnel stage - need to specify which metric\"\n * })\n *\n * @example\n * // Food Delivery dataset\n * clarification({\n *   when: \"user asks about 'delivery time'\",\n *   ask: \"Do you mean estimated time at order, actual delivery time, or time from kitchen to door?\",\n *   reason: \"Multiple time metrics exist - estimated vs actual impacts customer satisfaction differently\"\n * })\n *\n * @example\n * // Fitness/Gym Management dataset\n * clarification({\n *   when: \"user mentions 'active members'\",\n *   ask: \"Do you mean paid memberships or members who actually visited in last 30 days?\",\n *   reason: \"Many paid members don't use facilities - different metrics for revenue vs utilization\"\n * })\n */\nexport function clarification(input: {\n  when: string;\n  ask: string;\n  reason: string;\n}): Teachables {\n  const { when, ask, reason } = input;\n  return {\n    type: 'clarification',\n    format: () =>\n      wrapBlock('clarification', [\n        leaf('when', when),\n        leaf('ask', ask),\n        leaf('reason', reason),\n      ]),\n  };\n}\n\n/**\n * Teach the system multi-step analytical processes that can't be solved with a single query.\n *\n * Use this for complex analytical tasks that require multiple CTEs, sequential logic,\n * or specific methodologies. Workflows teach the system HOW to approach a type of analysis.\n *\n * @param input.task - Name of the analytical task\n * @param input.steps - Sequential steps to execute (can include SQL snippets or descriptions)\n * @param input.triggers - Optional phrases that should activate this workflow\n * @param input.notes - Optional additional context, warnings, or guidance\n *\n * @example\n * // Insurance dataset\n * workflow({\n *   task: \"Claims Loss Ratio Analysis\",\n *   triggers: [\"loss ratio\", \"claims ratio\", \"underwriting performance\"],\n *   steps: [\n *     \"Calculate total claims paid for each policy period\",\n *     \"Calculate total premiums earned for same period\",\n *     \"Compute loss ratio as (claims_paid / premiums_earned) * 100\",\n *     \"Segment by policy type, geography, and underwriter\",\n *     \"Identify policies with loss ratio > 100% (losing money)\",\n *     \"Calculate trend over time using rolling 12-month windows\"\n *   ],\n *   notes: \"Use incurred date for claims, not paid date. Exclude reinsurance recoveries from claims total.\"\n * })\n *\n * @example\n * // Media/Publishing dataset\n * workflow({\n *   task: \"Content Performance Funnel\",\n *   triggers: [\"content funnel\", \"engagement funnel\", \"content performance\"],\n *   steps: [\n *     \"Count total impressions (articles shown) per content piece\",\n *     \"Count click-throughs (articles opened)\",\n *     \"Count scroll depth > 50% (meaningful engagement)\",\n *     \"Count shares, comments, or saves (viral actions)\",\n *     \"Calculate conversion rate at each funnel stage\",\n *     \"Identify top-performing content by final conversion rate\"\n *   ],\n *   notes: \"Requires multiple event types. Join events table multiple times or use conditional aggregation.\"\n * })\n *\n * @example\n * // Sports Analytics dataset\n * workflow({\n *   task: \"Player Performance Rating Calculation\",\n *   triggers: [\"player rating\", \"performance score\", \"player analytics\"],\n *   steps: [\n *     \"Aggregate per-game stats: points, assists, rebounds, turnovers\",\n *     \"Calculate efficiency metrics: shooting percentage, plus/minus\",\n *     \"Normalize each metric using z-scores vs league average\",\n *     \"Apply position-specific weights to each metric\",\n *     \"Combine weighted scores into overall performance rating (0-100)\",\n *     \"Rank players within position group and overall\"\n *   ],\n *   notes: \"Requires league-wide statistics for normalization. Update weights each season based on game trends.\"\n * })\n */\nexport function workflow(input: {\n  task: string;\n  steps: string[];\n  triggers?: string[];\n  notes?: string;\n}): Teachables {\n  const { task, steps, triggers, notes } = input;\n  return {\n    type: 'workflow',\n    format: () =>\n      wrapBlock('workflow', [\n        leaf('task', task),\n        triggers?.length ? list('triggers', triggers, 'trigger') : '',\n        list('steps', steps, 'step'),\n        notes ? leaf('notes', notes) : '',\n      ]),\n  };\n}\n\n/**\n * Teach the system about data quirks, edge cases, or database-specific issues and their workarounds.\n *\n * Use this to document weird data patterns, database limitations, or special handling\n * required for specific scenarios. Helps the system navigate real-world messiness.\n *\n * @param input.issue - Description of the quirk, edge case, or problem\n * @param input.workaround - How to handle or work around this issue\n *\n * @example\n * // Government/Public Services dataset\n * quirk({\n *   issue: \"Citizen IDs contain leading zeros but are stored as integers, losing the zeros\",\n *   workaround: \"Always cast to VARCHAR and use LPAD(citizen_id::VARCHAR, 10, '0') to restore leading zeros\"\n * })\n *\n * @example\n * // Aviation dataset\n * quirk({\n *   issue: \"Flight times crossing midnight show as negative duration (landing before takeoff)\",\n *   workaround: \"Add 24 hours when calculated duration < 0: CASE WHEN duration < 0 THEN duration + INTERVAL '24 hours' ELSE duration END\"\n * })\n *\n * @example\n * // Automotive/Dealership dataset\n * quirk({\n *   issue: \"VIN numbers with letter 'O' were incorrectly entered as zero '0' in legacy data\",\n *   workaround: \"When searching by VIN, use REPLACE(vin, '0', 'O') or fuzzy matching to handle both cases\"\n * })\n */\nexport function quirk(input: {\n  issue: string;\n  workaround: string;\n}): Teachables {\n  const { issue, workaround } = input;\n  return {\n    type: 'quirk',\n    format: () =>\n      wrapBlock('quirk', [\n        leaf('issue', issue),\n        leaf('workaround', workaround),\n      ]),\n  };\n}\n\n/**\n * Teach the system SQL style preferences and coding standards for generated queries.\n *\n * Use this to enforce consistent SQL formatting, naming conventions, and best practices\n * specific to your team or organization. Improves readability and maintainability.\n *\n * @param input.prefer - Preferred SQL style or pattern\n * @param input.never - Optional anti-pattern to avoid\n * @param input.always - Optional rule that must always be followed\n *\n * @example\n * // Non-profit/Charity dataset\n * styleGuide({\n *   prefer: \"Use donor-centric language in column aliases: 'donor_name' not 'customer_name'\",\n *   never: \"Never expose internal donor IDs in external reports - use public gift IDs\",\n *   always: \"Always include fiscal year in date-based aggregations (FY starts July 1)\"\n * })\n *\n * @example\n * // Legal/Law Firm dataset\n * styleGuide({\n *   prefer: \"Use billable_hours with 2 decimal precision for accurate client billing\",\n *   never: \"Never include attorney_rate in queries visible to paralegals - confidential data\",\n *   always: \"Always filter by matter_status = 'open' unless specifically analyzing closed cases\"\n * })\n *\n * @example\n * // Inventory/Warehouse dataset\n * styleGuide({\n *   prefer: \"Use location_id in joins rather than location_name (duplicates exist across warehouses)\",\n *   never: \"Never aggregate inventory without grouping by warehouse_id first\",\n *   always: \"Always use inventory_on_hand - inventory_reserved for available stock calculations\"\n * })\n */\nexport function styleGuide(input: {\n  prefer: string;\n  never?: string;\n  always?: string;\n}): Teachables {\n  const { prefer, never, always } = input;\n  return {\n    type: 'styleGuide',\n    format: () =>\n      wrapBlock('style_guide', [\n        leaf('prefer', prefer),\n        always ? leaf('always', always) : '',\n        never ? leaf('never', never) : '',\n      ]),\n  };\n}\n\n/**\n * Teach the system by comparing related concepts through real-world analogies.\n *\n * Use this to teach relational understanding between two concepts by drawing comparisons\n * to familiar real-world scenarios. Helps the system understand WHY concepts differ and\n * when to use each one appropriately.\n *\n * @param input.concept - Array of two related concepts to compare\n * @param input.relationship - The comparison/analogy using real-world examples\n * @param input.insight - Optional key insight the analogy reveals\n * @param input.therefore - Optional actionable instruction based on this understanding\n * @param input.pitfall - Optional common mistake to avoid\n *\n * @example\n * // E-commerce dataset\n * analogy({\n *   concept: [\"cart abandonment\", \"browse abandonment\"],\n *   relationship: \"Cart abandonment is like leaving items at a checkout counter, browse abandonment is like window shopping without picking anything up\",\n *   insight: \"Cart abandonment shows purchase intent (added to cart), browse abandonment shows only interest\",\n *   therefore: \"Prioritize cart abandonment recovery campaigns - higher conversion potential than browse\",\n *   pitfall: \"Don't combine both into generic 'abandonment rate' - they need different marketing strategies\"\n * })\n *\n * @example\n * // SaaS dataset\n * analogy({\n *   concept: [\"logo churn\", \"revenue churn\"],\n *   relationship: \"Logo churn is like counting how many customers left the store, revenue churn is how much money walked out\",\n *   insight: \"Losing 10 small customers (high logo churn) might hurt less than losing 1 enterprise customer (high revenue churn)\",\n *   therefore: \"Always report both metrics - logo churn for customer satisfaction, revenue churn for financial health\",\n *   pitfall: \"Don't use logo churn to predict revenue impact - customer size distribution matters\"\n * })\n *\n * @example\n * // Healthcare dataset\n * analogy({\n *   concept: [\"incident\", \"prevalence\"],\n *   relationship: \"Incidence is like new house sales this month, prevalence is total houses currently occupied\",\n *   insight: \"Incidence measures new cases over time, prevalence measures all existing cases at a point in time\",\n *   therefore: \"For tracking disease outbreaks use incidence rate, for resource planning use prevalence\",\n *   pitfall: \"Don't sum incidence rates across time periods - it's a rate not a count\"\n * })\n */\nexport function analogy(input: {\n  concept: string[];\n  relationship: string;\n  insight?: string;\n  therefore?: string;\n  pitfall?: string;\n}): Teachables {\n  const { concept, relationship, insight, therefore, pitfall } = input;\n  return {\n    type: 'analogy',\n    format: () =>\n      wrapBlock('analogy', [\n        list('concepts', concept, 'concept'),\n        leaf('relationship', relationship),\n        insight ? leaf('insight', insight) : '',\n        therefore ? leaf('therefore', therefore) : '',\n        pitfall ? leaf('pitfall', pitfall) : '',\n      ]),\n  };\n}\n\n/**\n * Map business terms directly to SQL expressions or fragments.\n *\n * Use this to teach the system how to CALCULATE or QUERY specific business concepts.\n * The system will substitute these SQL patterns when users mention the term.\n *\n * **Glossary vs Alias:**\n * - `alias` = user vocabulary \u2192 table/column name (\"the big table\" \u2192 \"orders table\")\n * - `glossary` = business term \u2192 SQL expression (\"revenue\" \u2192 \"SUM(orders.total_amount)\")\n *\n * In short: alias renames, glossary computes.\n *\n * @param entries - Record mapping business terms to their SQL expressions\n *\n * @example\n * glossary({\n *   \"revenue\": \"SUM(orders.total_amount)\",\n *   \"average order value\": \"AVG(orders.total_amount)\",\n *   \"active user\": \"last_login > NOW() - INTERVAL '30 days'\",\n *   \"churned\": \"status = 'churned'\",\n *   \"power user\": \"order_count > 10\",\n *   \"net revenue\": \"SUM(orders.total_amount) - SUM(refunds.amount)\",\n * })\n */\nexport function glossary(entries: Record<string, string>): Teachables {\n  return {\n    type: 'glossary',\n    format: () =>\n      wrapBlock(\n        'glossary',\n        Object.entries(entries).map(([term, sql]) =>\n          wrapBlock('entry', [leaf('term', term), leaf('sql', sql)]),\n        ),\n      ),\n  };\n}\n\n// =============================================================================\n// User-Specific Teachable Types\n// =============================================================================\n\n/**\n * Define the user's identity including name and/or role.\n *\n * Use this to capture who the user is and what lens they view data through.\n * Helps tailor explanations, terminology, and focus areas.\n *\n * @param input.name - The user's name (optional)\n * @param input.role - The user's role or position (optional)\n *\n * @example\n * identity({ name: \"John\", role: \"VP of Sales\" })\n * identity({ role: \"Data analyst in the marketing team\" })\n * identity({ name: \"Sarah\" })\n * identity({ role: \"Finance manager focused on cost optimization\" })\n */\nexport function identity(input: { name?: string; role?: string }): Teachables {\n  const { name, role } = input;\n  return {\n    type: 'identity',\n    format: () =>\n      wrapBlock('identity', [\n        name ? leaf('name', name) : '',\n        role ? leaf('role', role) : '',\n      ]),\n  };\n}\n\n/**\n * Define an AI persona with a name, role, and communication tone.\n *\n * Use this to customize the assistant's personality and how it communicates.\n * The persona influences the style and approach of responses.\n *\n * @param input.name - The persona's name\n * @param input.role - The persona's role or expertise\n * @param input.tone - The communication style (e.g., friendly, professional, concise)\n *\n * @example\n * persona({ name: \"DataBot\", role: \"SQL Expert\", tone: \"friendly and encouraging\" })\n * persona({ name: \"QueryMaster\", role: \"Database Analyst\", tone: \"professional and concise\" })\n * persona({ name: \"SQLHelper\", role: \"Data Assistant\", tone: \"casual and approachable\" })\n */\nexport function persona(input: {\n  name: string;\n  role: string;\n  tone: string;\n}): Teachables {\n  const { name, role, tone } = input;\n  return {\n    type: 'persona',\n    format: () =>\n      wrapBlock('persona', [\n        leaf('name', name),\n        leaf('role', role),\n        leaf('tone', tone),\n      ]),\n  };\n}\n\n/**\n * Define user-specific term meanings and vocabulary.\n *\n * Use this when the user has their own definitions for terms that might\n * differ from standard or domain definitions. Like `term()` but personal.\n *\n * @param termName - The term the user uses\n * @param meaning - What the user means by this term\n *\n * @example\n * alias(\"revenue\", \"gross revenue before deductions, not net\")\n * alias(\"active users\", \"users who logged in within the last 30 days\")\n * alias(\"the big table\", \"the orders table\")\n * alias(\"Q4\", \"October through December, not fiscal Q4\")\n */\nexport function alias(termName: string, meaning: string): Teachables {\n  return {\n    type: 'alias',\n    format: () =>\n      wrapBlock('alias', [leaf('term', termName), leaf('meaning', meaning)]),\n  };\n}\n\n/**\n * Define how the user prefers results presented.\n *\n * Use this to capture output formatting, style, and behavioral preferences\n * that should apply to all interactions with this user.\n *\n * @param aspect - What aspect of output this preference applies to\n * @param value - The user's preference\n *\n * @example\n * preference(\"date format\", \"YYYY-MM-DD\")\n * preference(\"output style\", \"tables over charts unless trend data\")\n * preference(\"detail level\", \"always show the SQL query in responses\")\n * preference(\"row limit\", \"default to 50 rows unless I ask for more\")\n * preference(\"explanation style\", \"brief and to the point\")\n */\nexport function preference(aspect: string, value: string): Teachables {\n  return {\n    type: 'preference',\n    format: () =>\n      wrapBlock('preference', [leaf('aspect', aspect), leaf('value', value)]),\n  };\n}\n\n/**\n * Define the user's current working focus or project.\n *\n * Use this to capture temporary context that helps inform defaults,\n * assumptions, and suggestions. Should be updated as focus changes.\n *\n * @param description - What the user is currently working on\n *\n * @example\n * context(\"Preparing Q4 board presentation\")\n * context(\"Investigating drop in signups last week\")\n * context(\"Working on EMEA regional analysis for strategy meeting\")\n * context(\"Debugging discrepancy in revenue numbers\")\n */\nexport function context(description: string): Teachables {\n  return {\n    type: 'context',\n    format: () => leaf('context', description),\n  };\n}\n\n/**\n * Record a correction the user made to previous understanding.\n *\n * Use this when the user corrects a misunderstanding about data, columns,\n * or business logic. Prevents repeating the same mistake.\n *\n * @param subject - What was misunderstood\n * @param clarification - The correct understanding\n *\n * @example\n * correction(\"status column\", \"1 = active, 0 = inactive, not boolean true/false\")\n * correction(\"orders table\", \"Use orders_v2, not the deprecated legacy_orders table\")\n * correction(\"date field\", \"order_date is when order was placed, ship_date is when shipped\")\n * correction(\"revenue calculation\", \"Must exclude refunds and chargebacks\")\n */\nexport function correction(subject: string, clarification: string): Teachables {\n  return {\n    type: 'correction',\n    format: () =>\n      wrapBlock('correction', [\n        leaf('subject', subject),\n        leaf('clarification', clarification),\n      ]),\n  };\n}\n\nexport function teachable(\n  tag: string,\n  ...teachables: Teachables[]\n): Teachables {\n  return {\n    type: 'user_profile',\n    format: () => toInstructions(tag, ...teachables),\n  };\n}\n\nexport function toInstructions(\n  tag: string,\n  ...teachables: Teachables[]\n): string {\n  if (!teachables.length) {\n    return '';\n  }\n\n  const grouped = new Map<Teachables['type'], Teachables[]>();\n  for (const teachable of teachables) {\n    const existing = grouped.get(teachable.type) ?? [];\n    existing.push(teachable);\n    grouped.set(teachable.type, existing);\n  }\n\n  const definedTypes = new Set(SECTION_ORDER.map((s) => s.type));\n\n  const sections = SECTION_ORDER.map(({ type, tag }) => {\n    const items = grouped.get(type);\n    if (!items?.length) {\n      return '';\n    }\n    const renderedItems = items\n      .map((item) => item.format().trim())\n      .filter(Boolean)\n      .map((item) => indentBlock(item, 2))\n      .join('\\n');\n    if (!renderedItems.length) {\n      return '';\n    }\n    return `<${tag}>\\n${renderedItems}\\n</${tag}>`;\n  }).filter((section): section is string => Boolean(section));\n\n  // Render types not defined in SECTION_ORDER at the end\n  for (const [type, items] of grouped) {\n    if (definedTypes.has(type)) {\n      continue;\n    }\n    const renderedItems = items\n      .map((item) => item.format().trim())\n      .filter(Boolean)\n      .map((item) => indentBlock(item, 2))\n      .join('\\n');\n    if (renderedItems.length) {\n      sections.push(renderedItems);\n    }\n  }\n\n  if (!sections.length) {\n    return '';\n  }\n\n  const content = indentBlock(sections.join('\\n'), 2);\n  return `<${tag}>\\n${content}\\n</${tag}>`;\n}\n\nconst SECTION_ORDER: Array<{ type: Teachables['type']; tag: string }> = [\n  // User context (render first - most important for personalization)\n  { type: 'identity', tag: 'identity' },\n  { type: 'persona', tag: 'persona' },\n  { type: 'context', tag: 'user_context' },\n  { type: 'preference', tag: 'user_preferences' },\n  { type: 'alias', tag: 'user_vocabulary' },\n  { type: 'correction', tag: 'user_corrections' },\n  // Domain knowledge\n  { type: 'guardrail', tag: 'guardrails' },\n  { type: 'styleGuide', tag: 'style_guides' },\n  { type: 'hint', tag: 'hints' },\n  { type: 'clarification', tag: 'clarifications' },\n  { type: 'workflow', tag: 'workflows' },\n  { type: 'quirk', tag: 'quirks' },\n  { type: 'term', tag: 'terminology' },\n  { type: 'explain', tag: 'explanations' },\n  { type: 'analogy', tag: 'analogies' },\n  { type: 'glossary', tag: 'glossary' },\n  { type: 'example', tag: 'examples' },\n];\n\nexport function toTeachables(generated: GeneratedTeachable[]): Teachables[] {\n  return generated.map((item) => {\n    switch (item.type) {\n      case 'persona':\n        return persona({ name: item.name, role: item.role, tone: item.tone });\n      case 'term':\n        return term(item.name, item.definition);\n      case 'hint':\n        return hint(item.text);\n      case 'guardrail':\n        return guardrail({\n          rule: item.rule,\n          reason: item.reason,\n          action: item.action,\n        });\n      case 'explain':\n        return explain({\n          concept: item.concept,\n          explanation: item.explanation,\n          therefore: item.therefore,\n        });\n      case 'example':\n        return example({\n          question: item.question,\n          answer: item.answer,\n          note: item.note,\n        });\n      case 'clarification':\n        return clarification({\n          when: item.when,\n          ask: item.ask,\n          reason: item.reason,\n        });\n      case 'workflow':\n        return workflow({\n          task: item.task,\n          steps: item.steps,\n          triggers: item.triggers,\n          notes: item.notes,\n        });\n      case 'quirk':\n        return quirk({\n          issue: item.issue,\n          workaround: item.workaround,\n        });\n      case 'styleGuide':\n        return styleGuide({\n          prefer: item.prefer,\n          never: item.never,\n          always: item.always,\n        });\n      case 'analogy':\n        return analogy({\n          concept: item.concept,\n          relationship: item.relationship,\n          insight: item.insight,\n          therefore: item.therefore,\n          pitfall: item.pitfall,\n        });\n      case 'glossary':\n        return glossary(item.entries);\n      // User-specific teachable types\n      case 'identity':\n        return identity({ name: item.name, role: item.role });\n      case 'alias':\n        return alias(item.term, item.meaning);\n      case 'preference':\n        return preference(item.aspect, item.value);\n      case 'context':\n        return context(item.description);\n      case 'correction':\n        return correction(item.subject, item.clarification);\n    }\n  });\n}\n\n/**\n * Default export containing all system teachable factory functions.\n * Excludes user-specific teachables (identity, alias, preference, context, correction).\n */\nexport default {\n  persona,\n  term,\n  hint,\n  guardrail,\n  explain,\n  example,\n  clarification,\n  workflow,\n  quirk,\n  styleGuide,\n  analogy,\n  glossary,\n  teachable,\n};\n"],
+  "mappings": "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",
+  "names": ["term", "clarification", "teachable", "tag"]
+}

package/dist/lib/memory/memory.prompt.d.ts

@@ -0,0 +1,3 @@
+declare const _default: string;
+export default _default;
+//# sourceMappingURL=memory.prompt.d.ts.map

package/dist/lib/memory/memory.prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.prompt.d.ts","sourceRoot":"","sources":["../../../src/lib/memory/memory.prompt.ts"],"names":[],"mappings":";AAUA,wBA4JE"}

package/dist/lib/memory/memory.store.d.ts

@@ -0,0 +1,5 @@
+import { SqliteTeachablesStore } from './sqlite.store.ts';
+export declare class InMemoryTeachablesStore extends SqliteTeachablesStore {
+    constructor();
+}
+//# sourceMappingURL=memory.store.d.ts.map

package/dist/lib/memory/memory.store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.store.d.ts","sourceRoot":"","sources":["../../../src/lib/memory/memory.store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAE1D,qBAAa,uBAAwB,SAAQ,qBAAqB;;CAIjE"}

package/dist/lib/memory/sqlite.store.d.ts

@@ -0,0 +1,14 @@
+import { type GeneratedTeachable, type Teachables } from '../teach/teachables.ts';
+import { type StoredTeachable, TeachablesStore } from './store.ts';
+export declare class SqliteTeachablesStore extends TeachablesStore {
+    #private;
+    constructor(path: string);
+    remember(userId: string, data: GeneratedTeachable): Promise<StoredTeachable>;
+    recall(userId: string, type?: GeneratedTeachable['type']): Promise<StoredTeachable[]>;
+    get(id: string): Promise<StoredTeachable | null>;
+    update(id: string, data: GeneratedTeachable): Promise<StoredTeachable>;
+    forget(id: string): Promise<void>;
+    forgetAll(userId: string): Promise<void>;
+    toTeachables(userId: string): Promise<Teachables[]>;
+}
+//# sourceMappingURL=sqlite.store.d.ts.map

package/dist/lib/memory/sqlite.store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite.store.d.ts","sourceRoot":"","sources":["../../../src/lib/memory/sqlite.store.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,UAAU,EAEhB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EAAE,KAAK,eAAe,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAsBnE,qBAAa,qBAAsB,SAAQ,eAAe;;gBAG5C,IAAI,EAAE,MAAM;IAMlB,QAAQ,CACZ,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,kBAAkB,GACvB,OAAO,CAAC,eAAe,CAAC;IAarB,MAAM,CACV,MAAM,EAAE,MAAM,EACd,IAAI,CAAC,EAAE,kBAAkB,CAAC,MAAM,CAAC,GAChC,OAAO,CAAC,eAAe,EAAE,CAAC;IAkBvB,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC;IAShD,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,eAAe,CAAC;IAYtE,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIjC,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIxC,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;CAI1D"}

package/dist/lib/memory/store.d.ts

@@ -0,0 +1,40 @@
+import type { GeneratedTeachable, Teachables } from '../teach/teachables.ts';
+export interface StoredTeachable {
+    id: string;
+    userId: string;
+    type: GeneratedTeachable['type'];
+    data: GeneratedTeachable;
+    createdAt: string;
+    updatedAt: string;
+}
+export declare abstract class TeachablesStore {
+    /**
+     * Remember a teachable for a user.
+     */
+    abstract remember(userId: string, data: GeneratedTeachable): Promise<StoredTeachable>;
+    /**
+     * Recall teachables for a user, optionally filtered by type.
+     */
+    abstract recall(userId: string, type?: GeneratedTeachable['type']): Promise<StoredTeachable[]>;
+    /**
+     * Get a specific teachable by ID.
+     */
+    abstract get(id: string): Promise<StoredTeachable | null>;
+    /**
+     * Update an existing teachable.
+     */
+    abstract update(id: string, data: GeneratedTeachable): Promise<StoredTeachable>;
+    /**
+     * Forget (remove) a specific teachable by ID.
+     */
+    abstract forget(id: string): Promise<void>;
+    /**
+     * Forget all teachables for a user.
+     */
+    abstract forgetAll(userId: string): Promise<void>;
+    /**
+     * Convert stored teachables to Teachables array for use with toInstructions().
+     */
+    abstract toTeachables(userId: string): Promise<Teachables[]>;
+}
+//# sourceMappingURL=store.d.ts.map

package/dist/lib/memory/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../src/lib/memory/store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAE7E,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,kBAAkB,CAAC,MAAM,CAAC,CAAC;IACjC,IAAI,EAAE,kBAAkB,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,8BAAsB,eAAe;IACnC;;OAEG;IACH,QAAQ,CAAC,QAAQ,CACf,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,kBAAkB,GACvB,OAAO,CAAC,eAAe,CAAC;IAE3B;;OAEG;IACH,QAAQ,CAAC,MAAM,CACb,MAAM,EAAE,MAAM,EACd,IAAI,CAAC,EAAE,kBAAkB,CAAC,MAAM,CAAC,GAChC,OAAO,CAAC,eAAe,EAAE,CAAC;IAE7B;;OAEG;IACH,QAAQ,CAAC,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC;IAEzD;;OAEG;IACH,QAAQ,CAAC,MAAM,CACb,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,kBAAkB,GACvB,OAAO,CAAC,eAAe,CAAC;IAE3B;;OAEG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAE1C;;OAEG;IACH,QAAQ,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAEjD;;OAEG;IACH,QAAQ,CAAC,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;CAC7D"}

package/dist/lib/prompt.d.ts

@@ -1,7 +1,2 @@
-import type { Introspection } from './adapters/adapter.ts';
-export declare function databaseSchemaPrompt(options: {
-    introspection: Introspection;
-    context?: string;
-    adapterInfo?: string;
-}): string;
+export declare function databaseSchemaPrompt(): void;
 //# sourceMappingURL=prompt.d.ts.map

package/dist/lib/prompt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prompt.d.ts","sourceRoot":"","sources":["../../src/lib/prompt.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AA0H3D,wBAAgB,oBAAoB,CAAC,OAAO,EAAE;IAC5C,aAAa,EAAE,aAAa,CAAC;IAC7B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,UAYA"}
+{"version":3,"file":"prompt.d.ts","sourceRoot":"","sources":["../../src/lib/prompt.ts"],"names":[],"mappings":"AAAA,wBAAgB,oBAAoB,SAYnC"}