@deployxai/dxc 0.1.2 → 0.1.4

package/dist/chunks/{knowledge-4ZXXUSDQ.js → knowledge-6LOGJETT.js}

@@ -9,6 +9,11 @@ import {
   LocalStateError,
   contentKnowledgeImportResultSchema,
   contentKnowledgeModelSchema,
+  contentKnowledgeQuoteInitResultSchema,
+  contentKnowledgeQuoteListResultSchema,
+  contentKnowledgeQuoteMutationResultSchema,
+  contentKnowledgeQuoteStatusResultSchema,
+  contentKnowledgeQuoteSyncResultSchema,
   contentKnowledgeRemoveResultSchema,
   contentKnowledgeSearchModeSchema,
   contentKnowledgeSearchResultSchema,
@@ -19,13 +24,14 @@ import {
   readPrivateFile,
   writePrivateBuffer,
   writePrivateJson
-} from "./chunk-ZPBFGBWP.js";
+} from "./chunk-JGUPNE36.js";
 
 // apps/cli/src/knowledge.ts
 import { createHash as createHash2, randomUUID } from "node:crypto";
 import { lstat, readdir, readFile, stat } from "node:fs/promises";
 import path2 from "node:path";
 import { DatabaseSync } from "node:sqlite";
+import { z } from "zod";
 
 // apps/cli/src/knowledge-embedding.ts
 import { createHash } from "node:crypto";
@@ -326,9 +332,14 @@ var LocalBgeKnowledgeEmbedder = class {
 
 // apps/cli/src/knowledge.ts
 var DATABASE_DISPLAY_PATH = "~/.dxc/content-memory.sqlite";
+var QUOTE_SOURCE_DISPLAY_PATH = "~/Documents/DxC/\u91D1\u53E5\u5E93.md";
+var QUOTE_SOURCE_FILE_NAME = "\u91D1\u53E5\u5E93.md";
+var LEGACY_QUOTE_SOURCE_FILE_NAME = "quotes.json";
 var MAXIMUM_ARTICLE_BYTES = 5 * 1024 * 1024;
 var MAXIMUM_CHUNK_CHARACTERS = 420;
 var TARGET_CHUNK_CHARACTERS = 280;
+var MINIMUM_CONTEXTUAL_CHUNK_CHARACTERS = 80;
+var MINIMUM_INDEXABLE_ARTICLE_CHARACTERS = 20;
 var MAXIMUM_RESULTS = 20;
 var SEARCH_CANDIDATE_LIMIT = 80;
 var RRF_CONSTANT = 60;
@@ -346,9 +357,71 @@ var KnowledgeCliError = class extends Error {
   }
   code;
 };
+var quoteMetadataValueSchema = z.string().trim().min(1).max(300).refine((value) => !/[\r\n]/u.test(value) && value !== "\uFF08\u65E0\uFF09", {
+  message: "quote metadata must stay on one line"
+});
+var quoteTagSchema = quoteMetadataValueSchema.max(80).refine((value) => !/[，,]/u.test(value), {
+  message: "quote tags must not contain separators"
+});
+var quoteSourceItemSchema = z.object({
+  attribution: quoteMetadataValueSchema.nullable().optional(),
+  origin: z.enum(["original", "third-party"]),
+  quoteId: z.uuid(),
+  source: quoteMetadataValueSchema.nullable().optional(),
+  status: z.enum(["active", "archived"]),
+  tags: z.array(quoteTagSchema).max(20).default([]),
+  text: z.string().trim().min(1).max(2e3),
+  verbatimUse: z.enum(["original", "needs-verification", "permitted", "do-not-use-verbatim"])
+}).strict().superRefine((quote, context) => {
+  if (quote.origin === "third-party" && quote.attribution == null) {
+    context.addIssue({
+      code: "custom",
+      message: "Third-party quotes require attribution",
+      path: ["attribution"]
+    });
+  }
+  if (quote.origin === "original" && quote.verbatimUse !== "original") {
+    context.addIssue({
+      code: "custom",
+      message: "Original quotes must use the original verbatim-use value",
+      path: ["verbatimUse"]
+    });
+  }
+});
+var quoteSourceDocumentSchema = z.object({
+  quotes: z.array(quoteSourceItemSchema).max(5e3),
+  schemaVersion: z.literal("1")
+}).strict().superRefine((document, context) => {
+  const ids = /* @__PURE__ */ new Set();
+  for (const [index, quote] of document.quotes.entries()) {
+    if (ids.has(quote.quoteId)) {
+      context.addIssue({
+        code: "custom",
+        message: "quoteId values must be unique",
+        path: ["quotes", index, "quoteId"]
+      });
+    }
+    ids.add(quote.quoteId);
+  }
+});
 function errorCode(error) {
   return typeof error === "object" && error !== null && "code" in error ? String(error.code) : void 0;
 }
+function skippedArticle(error, inputPath) {
+  if (!(error instanceof KnowledgeCliError)) {
+    return void 0;
+  }
+  const code = error.code;
+  if (code !== "DXC_KNOWLEDGE_ARTICLE_INVALID" && code !== "DXC_KNOWLEDGE_FILE_TOO_LARGE") {
+    return void 0;
+  }
+  const sourceLabel = path2.basename(inputPath).slice(0, 255).trim();
+  return {
+    code,
+    message: error.message,
+    sourceLabel: sourceLabel.length === 0 ? "(unknown)" : sourceLabel
+  };
+}
 function sha2562(value) {
   return createHash2("sha256").update(value).digest("hex");
 }
@@ -404,10 +477,29 @@ function splitOversizedText(value) {
   flush();
   return parts;
 }
+function characterCount(value) {
+  return [...value].length;
+}
+function combinedHeading(left, right) {
+  const headings = [left, right].filter((heading) => heading !== null);
+  if (headings.length === 0) {
+    return null;
+  }
+  return [...new Set(headings)].join(" / ").slice(0, 300);
+}
+function combineChunks(left, right) {
+  return {
+    body: `${left.body}
+
+${right.body}`,
+    heading: combinedHeading(left.heading, right.heading)
+  };
+}
 function chunkHistoricalArticle(markdown) {
   const value = removeFrontmatter(markdown);
   const lines = value.split("\n");
   const paragraphs = [];
+  let fencedCodeDelimiter = null;
   let heading = null;
   let paragraphLines = [];
   const flushParagraph = () => {
@@ -421,8 +513,22 @@ function chunkHistoricalArticle(markdown) {
     }
   };
   for (const line of lines) {
+    const fenceMarker = line.match(/^\s*(`{3,}|~{3,})/u)?.[1];
+    if (fenceMarker !== void 0) {
+      const delimiter = fenceMarker.startsWith("`") ? "`" : "~";
+      if (fencedCodeDelimiter === null) {
+        fencedCodeDelimiter = delimiter;
+        paragraphLines.push(line);
+        continue;
+      }
+      if (fencedCodeDelimiter === delimiter) {
+        fencedCodeDelimiter = null;
+        paragraphLines.push(line);
+        continue;
+      }
+    }
     const headingMatch = line.match(/^\s{0,3}#{1,6}\s+(.+)$/u);
-    if (headingMatch !== null) {
+    if (fencedCodeDelimiter === null && headingMatch !== null) {
       flushParagraph();
       heading = plainMarkdown(headingMatch[1] ?? "").slice(0, 300).trim() || null;
       continue;
@@ -452,7 +558,31 @@ ${paragraph.text}`;
       });
     }
   }
-  return merged.map((chunk, ordinal) => ({
+  const contextualized = [];
+  let pending;
+  for (const chunk of merged) {
+    if (pending === void 0) {
+      pending = chunk;
+      continue;
+    }
+    const combined = combineChunks(pending, chunk);
+    if (characterCount(pending.body) < MINIMUM_CONTEXTUAL_CHUNK_CHARACTERS && characterCount(combined.body) <= MAXIMUM_CHUNK_CHARACTERS) {
+      pending = combined;
+      continue;
+    }
+    contextualized.push(pending);
+    pending = chunk;
+  }
+  if (pending !== void 0) {
+    const previous = contextualized.at(-1);
+    const combined = previous === void 0 ? void 0 : combineChunks(previous, pending);
+    if (previous !== void 0 && combined !== void 0 && characterCount(pending.body) < MINIMUM_CONTEXTUAL_CHUNK_CHARACTERS && characterCount(combined.body) <= MAXIMUM_CHUNK_CHARACTERS) {
+      contextualized[contextualized.length - 1] = combined;
+    } else {
+      contextualized.push(pending);
+    }
+  }
+  return contextualized.map((chunk, ordinal) => ({
     ...chunk,
     ordinal,
     sha256: sha2562(chunk.body)
@@ -496,10 +626,10 @@ async function prepareArticle(currentDirectory, inputPath) {
   }
   const sourceLabel = path2.basename(absolutePath).slice(0, 255);
   const chunks = chunkHistoricalArticle(content);
-  if (chunks.length === 0) {
+  if (chunks.length === 0 || chunks.reduce((total, chunk) => total + characterCount(chunk.body), 0) < MINIMUM_INDEXABLE_ARTICLE_CHARACTERS) {
     throw new KnowledgeCliError(
       "DXC_KNOWLEDGE_ARTICLE_INVALID",
-      "Article has no indexable content"
+      "Article has too little indexable content"
     );
   }
   return {
@@ -649,10 +779,54 @@ function chunkRow(value) {
     title: stringColumn(row, "title")
   };
 }
+function quoteRow(value) {
+  const row = sqlRow(value);
+  const nullableString = (name) => {
+    const value2 = row[name];
+    if (value2 === null) {
+      return null;
+    }
+    return stringColumn(row, name);
+  };
+  const parseValue = (schema, value2) => {
+    const parsed = schema.safeParse(value2);
+    if (!parsed.success) {
+      throw new KnowledgeCliError(
+        "DXC_KNOWLEDGE_STATE_INVALID",
+        "Knowledge quote state is invalid"
+      );
+    }
+    return parsed.data;
+  };
+  return {
+    attribution: nullableString("attribution"),
+    contentSha256: stringColumn(row, "content_sha256"),
+    embedding: vectorFromColumn(row["embedding"]),
+    id: stringColumn(row, "quote_id"),
+    origin: parseValue(z.enum(["original", "third-party"]), row["origin"]),
+    sourceLabel: nullableString("source_label"),
+    status: parseValue(z.enum(["active", "archived"]), row["status"]),
+    tags: (() => {
+      try {
+        return parseValue(z.array(z.string()), JSON.parse(stringColumn(row, "tags_json")));
+      } catch {
+        throw new KnowledgeCliError(
+          "DXC_KNOWLEDGE_STATE_INVALID",
+          "Knowledge quote state is invalid"
+        );
+      }
+    })(),
+    text: stringColumn(row, "body"),
+    verbatimUse: parseValue(
+      z.enum(["original", "needs-verification", "permitted", "do-not-use-verbatim"]),
+      row["verbatim_use"]
+    )
+  };
+}
 function databaseSchema(database) {
   const versionRow = sqlRow(database.prepare("PRAGMA user_version").get());
   const version = numberColumn(versionRow, "user_version");
-  if (version !== 0 && version !== Number(CONTENT_KNOWLEDGE_SCHEMA_VERSION)) {
+  if (version < 0 || version > Number(CONTENT_KNOWLEDGE_SCHEMA_VERSION)) {
     throw new KnowledgeCliError(
       "DXC_KNOWLEDGE_SCHEMA_UNSUPPORTED",
       "Knowledge database version is unsupported"
@@ -723,8 +897,53 @@ function databaseSchema(database) {
       tokenize = 'trigram'
     );
 
-    PRAGMA user_version = 1;
   `);
+  if (version < 2) {
+    database.exec(`
+      CREATE TABLE IF NOT EXISTS quote_sources (
+        source_key TEXT PRIMARY KEY,
+        content_sha256 TEXT NOT NULL,
+        synced_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS quotes (
+        quote_id TEXT PRIMARY KEY,
+        status TEXT NOT NULL CHECK (status IN ('active', 'archived')),
+        body TEXT NOT NULL,
+        tags_json TEXT NOT NULL,
+        source_label TEXT,
+        origin TEXT NOT NULL CHECK (origin IN ('original', 'third-party')),
+        attribution TEXT,
+        verbatim_use TEXT NOT NULL CHECK (verbatim_use IN ('original', 'needs-verification', 'permitted', 'do-not-use-verbatim')),
+        content_sha256 TEXT NOT NULL,
+        imported_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        embedding BLOB,
+        embedding_model TEXT,
+        embedding_revision TEXT,
+        embedding_quantization TEXT,
+        embedding_dimensions INTEGER,
+        CHECK (
+          (embedding IS NULL AND embedding_model IS NULL AND embedding_revision IS NULL AND embedding_quantization IS NULL AND embedding_dimensions IS NULL)
+          OR
+          (embedding IS NOT NULL AND embedding_model IS NOT NULL AND embedding_revision IS NOT NULL AND embedding_quantization IS NOT NULL AND embedding_dimensions IS NOT NULL)
+        )
+      );
+
+      CREATE INDEX IF NOT EXISTS quotes_status_idx ON quotes(status);
+
+      CREATE VIRTUAL TABLE IF NOT EXISTS quote_search USING fts5(
+        quote_id UNINDEXED,
+        body,
+        tags,
+        source_label,
+        attribution,
+        tokenize = 'trigram'
+      );
+
+      PRAGMA user_version = 2;
+    `);
+  }
 }
 async function openDatabase(target) {
   try {
@@ -761,6 +980,310 @@ async function databaseExists(target) {
     throw new KnowledgeCliError("DXC_KNOWLEDGE_IO_FAILED", "Unable to inspect knowledge database");
   }
 }
+function quoteSourcePath(homeDirectory) {
+  return path2.join(homeDirectory, "Documents", "DxC", QUOTE_SOURCE_FILE_NAME);
+}
+function legacyQuoteSourcePath(homeDirectory) {
+  return path2.join(homeDirectory, ".dxc", LEGACY_QUOTE_SOURCE_FILE_NAME);
+}
+function quoteContentHash(quote) {
+  return sha2562(
+    JSON.stringify({
+      attribution: quote.attribution ?? null,
+      origin: quote.origin,
+      quoteId: quote.quoteId,
+      source: quote.source ?? null,
+      status: quote.status,
+      tags: [...quote.tags],
+      text: quote.text,
+      verbatimUse: quote.verbatimUse
+    })
+  );
+}
+function preparedQuotes(document) {
+  return document.quotes.map((quote) => ({ ...quote, contentSha256: quoteContentHash(quote) }));
+}
+function sourceQuote(quote) {
+  return {
+    attribution: quote.attribution,
+    origin: quote.origin,
+    quoteId: quote.quoteId,
+    source: quote.source,
+    status: quote.status,
+    tags: quote.tags,
+    text: quote.text,
+    verbatimUse: quote.verbatimUse
+  };
+}
+async function quoteSourceExists(sourcePath) {
+  try {
+    const metadata = await lstat(sourcePath);
+    if (!metadata.isFile() || metadata.isSymbolicLink()) {
+      throw new KnowledgeCliError("DXC_KNOWLEDGE_QUOTE_INVALID", "Quote source file is invalid");
+    }
+    return true;
+  } catch (error) {
+    if (error instanceof KnowledgeCliError) {
+      throw error;
+    }
+    if (errorCode(error) === "ENOENT") {
+      return false;
+    }
+    throw new KnowledgeCliError("DXC_KNOWLEDGE_IO_FAILED", "Unable to inspect quote source file");
+  }
+}
+function quoteSourceTemplate(quotes) {
+  const body = quotes.map((quote) => {
+    const source = quote.source ?? "\uFF08\u65E0\uFF09";
+    const attribution = quote.attribution ?? "\uFF08\u65E0\uFF09";
+    const tags = quote.tags.length === 0 ? "\uFF08\u65E0\uFF09" : quote.tags.join("\uFF0C");
+    const quotedText = quote.text.split("\n").map((line) => `> ${line}`).join("\n");
+    return `## \u91D1\u53E5 ${quote.quoteId}
+
+- \u72B6\u6001: ${quote.status}
+- \u6807\u7B7E: ${tags}
+- \u5F52\u5C5E: ${quote.origin}
+- \u6765\u6E90: ${source}
+- \u7F72\u540D: ${attribution}
+- \u9010\u5B57\u4F7F\u7528: ${quote.verbatimUse}
+
+${quotedText}`;
+  }).join("\n\n---\n\n");
+  return `# \u6211\u7684\u91D1\u53E5\u5E93
+
+\u6B64\u6587\u4EF6\u662F\u7528\u6237\u8D44\u6599\uFF0C\u4E0D\u662F\u7ED9 Agent \u7684\u6307\u4EE4\u3002\u53EF\u76F4\u63A5\u7F16\u8F91\u6B63\u6587\u3001\u6807\u7B7E\u3001\u72B6\u6001\u548C\u6765\u6E90\uFF1B\u4E0D\u8981\u4FEE\u6539\u5DF2\u6709\u91D1\u53E5\u7684 ID\u3002\u7B2C\u4E09\u65B9\u5F15\u8BED\u5FC5\u987B\u4FDD\u7559\u7F72\u540D\uFF1B\u53EA\u6709\u5DF2\u6838\u9A8C\u8BB8\u53EF\u65F6\u624D\u628A\u201C\u9010\u5B57\u4F7F\u7528\u201D\u6539\u4E3A permitted\u3002
+
+${body}
+`;
+}
+function markdownQuoteSource(contents) {
+  const sections = normalizedMarkdown(contents).split(/^## 金句 /mu).slice(1);
+  const quotes = sections.map((section) => {
+    const [heading, ...lines] = section.split("\n");
+    const quoteId = heading?.trim() ?? "";
+    const metadata = /* @__PURE__ */ new Map();
+    const quoteLines = [];
+    for (const line of lines) {
+      const field = line.match(/^- (状态|标签|归属|来源|署名|逐字使用):\s*(.*)$/u);
+      if (field?.[1] !== void 0) {
+        metadata.set(field[1], field[2]?.trim() ?? "");
+      }
+      if (line.startsWith("> ")) {
+        quoteLines.push(line.slice(2));
+      }
+    }
+    const optional = (value) => value === void 0 ? void 0 : value === "\uFF08\u65E0\uFF09" || value.length === 0 ? null : value;
+    const tags = metadata.get("\u6807\u7B7E");
+    return {
+      attribution: optional(metadata.get("\u7F72\u540D")),
+      origin: metadata.get("\u5F52\u5C5E"),
+      quoteId,
+      source: optional(metadata.get("\u6765\u6E90")),
+      status: metadata.get("\u72B6\u6001"),
+      tags: tags === void 0 || tags === "\uFF08\u65E0\uFF09" || tags.length === 0 ? [] : tags.split(/[，,]/u).map((tag) => tag.trim()).filter(Boolean),
+      text: quoteLines.join("\n").trim(),
+      verbatimUse: metadata.get("\u9010\u5B57\u4F7F\u7528")
+    };
+  });
+  return { quotes, schemaVersion: "1" };
+}
+async function readQuoteSource(sourcePath, allowLegacyPermissions = false) {
+  let contents;
+  try {
+    if (allowLegacyPermissions) {
+      const metadata = await lstat(sourcePath);
+      if (!metadata.isFile() || metadata.isSymbolicLink() || metadata.size > MAXIMUM_ARTICLE_BYTES) {
+        throw new KnowledgeCliError("DXC_KNOWLEDGE_QUOTE_INVALID", "Quote source file is invalid");
+      }
+      contents = await readFile(sourcePath, "utf8");
+    } else {
+      contents = await readPrivateFile(sourcePath, MAXIMUM_ARTICLE_BYTES);
+    }
+  } catch {
+    throw new KnowledgeCliError("DXC_KNOWLEDGE_IO_FAILED", "Unable to read quote source file");
+  }
+  let parsed;
+  try {
+    parsed = sourcePath.endsWith(".json") ? JSON.parse(contents) : markdownQuoteSource(contents);
+  } catch {
+    throw new KnowledgeCliError("DXC_KNOWLEDGE_QUOTE_INVALID", "Quote source file is invalid");
+  }
+  const document = quoteSourceDocumentSchema.safeParse(parsed);
+  if (!document.success) {
+    throw new KnowledgeCliError("DXC_KNOWLEDGE_QUOTE_INVALID", "Quote source file is invalid");
+  }
+  return {
+    contentSha256: sha2562(contents),
+    quotes: preparedQuotes(document.data)
+  };
+}
+async function writeQuoteSource(sourcePath, quotes) {
+  try {
+    await writePrivateBuffer(sourcePath, Buffer.from(quoteSourceTemplate(quotes), "utf8"));
+  } catch {
+    throw new KnowledgeCliError("DXC_KNOWLEDGE_IO_FAILED", "Unable to write quote source file");
+  }
+}
+function quoteRecord(quote) {
+  return {
+    attribution: quote.attribution ?? null,
+    origin: quote.origin,
+    quoteId: quote.quoteId,
+    source: quote.source ?? null,
+    status: quote.status,
+    tags: [...quote.tags],
+    text: quote.text,
+    verbatimUse: quote.verbatimUse
+  };
+}
+function quoteSourceSummary(database, sourceInitialized) {
+  const counts = sqlRow(
+    database.prepare(
+      `SELECT
+          COALESCE(SUM(CASE WHEN status = 'active' THEN 1 ELSE 0 END), 0) AS active_count,
+          COALESCE(SUM(CASE WHEN status = 'archived' THEN 1 ELSE 0 END), 0) AS archived_count
+        FROM quotes`
+    ).get()
+  );
+  const source = database.prepare("SELECT content_sha256 FROM quote_sources WHERE source_key = 'default' LIMIT 1").get();
+  return {
+    activeCount: numberColumn(counts, "active_count"),
+    archivedCount: numberColumn(counts, "archived_count"),
+    sourceInitialized,
+    sourcePath: QUOTE_SOURCE_DISPLAY_PATH,
+    sourceSha256: source === void 0 ? null : stringColumn(sqlRow(source), "content_sha256")
+  };
+}
+function quoteEmbeddingText(quote) {
+  return [quote.text, ...quote.tags, quote.source ?? "", quote.attribution ?? ""].filter((value) => value.length > 0).join("\n");
+}
+async function embedQuotes(embedder, quotes) {
+  const activeQuotes = quotes.filter((quote) => quote.status === "active");
+  if (activeQuotes.length === 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  let vectors;
+  try {
+    vectors = await embedder.embedDocuments(activeQuotes.map(quoteEmbeddingText));
+  } catch {
+    throw new KnowledgeCliError(
+      "DXC_KNOWLEDGE_MODEL_FAILED",
+      "Local semantic model could not index quotes"
+    );
+  }
+  if (vectors.length !== activeQuotes.length || vectors.some((vector) => vector.length !== CONTENT_KNOWLEDGE_EMBEDDING_DIMENSIONS)) {
+    throw new KnowledgeCliError(
+      "DXC_KNOWLEDGE_MODEL_FAILED",
+      "Local semantic model returned invalid quote vectors"
+    );
+  }
+  return new Map(
+    activeQuotes.map((quote, index) => [quote.quoteId, vectors[index]])
+  );
+}
+function syncQuotes(database, quotes, sourceSha256, vectors, timestamp, allowUnchanged) {
+  const priorSource = database.prepare("SELECT content_sha256 FROM quote_sources WHERE source_key = 'default' LIMIT 1").get();
+  if (allowUnchanged && priorSource !== void 0 && stringColumn(sqlRow(priorSource), "content_sha256") === sourceSha256) {
+    return "unchanged";
+  }
+  database.exec("BEGIN IMMEDIATE");
+  try {
+    const existingRows = database.prepare("SELECT quote_id, content_sha256, imported_at FROM quotes").all().map((value) => sqlRow(value));
+    const existing = new Map(
+      existingRows.map((row) => [
+        stringColumn(row, "quote_id"),
+        {
+          contentSha256: stringColumn(row, "content_sha256"),
+          importedAt: stringColumn(row, "imported_at")
+        }
+      ])
+    );
+    const sourceIds = new Set(quotes.map((quote) => quote.quoteId));
+    database.prepare("DELETE FROM quote_search").run();
+    const upsert = database.prepare(`
+      INSERT INTO quotes (
+        quote_id, status, body, tags_json, source_label, origin, attribution, verbatim_use,
+        content_sha256, imported_at, updated_at, embedding, embedding_model, embedding_revision,
+        embedding_quantization, embedding_dimensions
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(quote_id) DO UPDATE SET
+        status = excluded.status, body = excluded.body, tags_json = excluded.tags_json,
+        source_label = excluded.source_label, origin = excluded.origin, attribution = excluded.attribution,
+        verbatim_use = excluded.verbatim_use, content_sha256 = excluded.content_sha256,
+        updated_at = excluded.updated_at, embedding = excluded.embedding,
+        embedding_model = excluded.embedding_model, embedding_revision = excluded.embedding_revision,
+        embedding_quantization = excluded.embedding_quantization, embedding_dimensions = excluded.embedding_dimensions
+    `);
+    const insertSearch = database.prepare(`
+      INSERT INTO quote_search (quote_id, body, tags, source_label, attribution) VALUES (?, ?, ?, ?, ?)
+    `);
+    for (const quote of quotes) {
+      const vector = quote.status === "active" ? vectors?.get(quote.quoteId) : void 0;
+      upsert.run(
+        quote.quoteId,
+        quote.status,
+        quote.text,
+        JSON.stringify(quote.tags),
+        quote.source ?? null,
+        quote.origin,
+        quote.attribution ?? null,
+        quote.verbatimUse,
+        quote.contentSha256,
+        existing.get(quote.quoteId)?.importedAt ?? timestamp,
+        timestamp,
+        vector === void 0 ? null : vectorBuffer(vector),
+        vector === void 0 ? null : CONTENT_KNOWLEDGE_EMBEDDING_MODEL,
+        vector === void 0 ? null : CONTENT_KNOWLEDGE_EMBEDDING_REVISION,
+        vector === void 0 ? null : CONTENT_KNOWLEDGE_EMBEDDING_QUANTIZATION,
+        vector === void 0 ? null : CONTENT_KNOWLEDGE_EMBEDDING_DIMENSIONS
+      );
+      if (quote.status === "active") {
+        insertSearch.run(
+          quote.quoteId,
+          quote.text,
+          quote.tags.join(" "),
+          quote.source ?? "",
+          quote.attribution ?? ""
+        );
+      }
+    }
+    const archiveMissing = database.prepare(`
+      UPDATE quotes
+      SET status = 'archived', updated_at = ?, embedding = NULL, embedding_model = NULL,
+        embedding_revision = NULL, embedding_quantization = NULL, embedding_dimensions = NULL
+      WHERE status = 'active' AND quote_id NOT IN (${quotes.map(() => "?").join(",") || "''"})
+    `);
+    archiveMissing.run(timestamp, ...sourceIds);
+    database.prepare(
+      `INSERT INTO quote_sources (source_key, content_sha256, synced_at) VALUES ('default', ?, ?)
+         ON CONFLICT(source_key) DO UPDATE SET content_sha256 = excluded.content_sha256, synced_at = excluded.synced_at`
+    ).run(sourceSha256, timestamp);
+    database.exec("COMMIT");
+  } catch {
+    try {
+      database.exec("ROLLBACK");
+    } catch {
+    }
+    throw new KnowledgeCliError("DXC_KNOWLEDGE_IO_FAILED", "Unable to synchronize quote index");
+  }
+  return priorSource === void 0 ? "created" : "updated";
+}
+function quoteSemanticIndexComplete(database) {
+  const row = sqlRow(
+    database.prepare(
+      `SELECT COUNT(*) AS total, COALESCE(SUM(CASE
+          WHEN embedding IS NOT NULL AND embedding_model = ? AND embedding_revision = ?
+            AND embedding_quantization = ? AND embedding_dimensions = ? THEN 1 ELSE 0 END), 0) AS indexed
+        FROM quotes WHERE status = 'active'`
+    ).get(
+      CONTENT_KNOWLEDGE_EMBEDDING_MODEL,
+      CONTENT_KNOWLEDGE_EMBEDDING_REVISION,
+      CONTENT_KNOWLEDGE_EMBEDDING_QUANTIZATION,
+      CONTENT_KNOWLEDGE_EMBEDDING_DIMENSIONS
+    )
+  );
+  return numberColumn(row, "total") === numberColumn(row, "indexed");
+}
 function embeddingText(article, chunk) {
   return [article.title.slice(0, 120), chunk.heading?.slice(0, 120) ?? "", chunk.body].filter((value) => value.length > 0).join("\n");
 }
@@ -972,6 +1495,28 @@ function loadChunks(database) {
     CONTENT_KNOWLEDGE_EMBEDDING_DIMENSIONS
   ).map(chunkRow);
 }
+function loadActiveQuotes(database) {
+  return database.prepare(
+    `
+      SELECT
+        quote_id, status, body, tags_json, source_label, origin, attribution, verbatim_use,
+        content_sha256,
+        CASE
+          WHEN embedding_model = ? AND embedding_revision = ? AND embedding_quantization = ?
+            AND embedding_dimensions = ?
+          THEN embedding ELSE NULL
+        END AS embedding
+      FROM quotes
+      WHERE status = 'active'
+      ORDER BY imported_at ASC, quote_id ASC
+    `
+  ).all(
+    CONTENT_KNOWLEDGE_EMBEDDING_MODEL,
+    CONTENT_KNOWLEDGE_EMBEDDING_REVISION,
+    CONTENT_KNOWLEDGE_EMBEDDING_QUANTIZATION,
+    CONTENT_KNOWLEDGE_EMBEDDING_DIMENSIONS
+  ).map(quoteRow);
+}
 function ftsExpression(query) {
   const terms = query.normalize("NFKC").split(/[\s,，。！？!?；;：:、/\\|()[\]{}]+/u).map((term) => term.trim()).filter((term) => [...term].length >= 3).slice(0, 12);
   if (terms.length === 0) {
@@ -1001,6 +1546,24 @@ function lexicalRanking(database, query) {
     throw new KnowledgeCliError("DXC_KNOWLEDGE_QUERY_INVALID", "Knowledge query is invalid");
   }
 }
+function quoteLexicalRanking(database, query) {
+  const expression = ftsExpression(query);
+  if (expression === null) {
+    return [];
+  }
+  try {
+    return database.prepare(
+      `
+        SELECT quote_id FROM quote_search
+        WHERE quote_search MATCH ?
+        ORDER BY bm25(quote_search, 4.0, 1.5, 0.5, 0.5, 0.5)
+        LIMIT ?
+      `
+    ).all(expression, SEARCH_CANDIDATE_LIMIT).map((value, rank) => ({ id: stringColumn(sqlRow(value), "quote_id"), rank }));
+  } catch {
+    throw new KnowledgeCliError("DXC_KNOWLEDGE_QUERY_INVALID", "Knowledge query is invalid");
+  }
+}
 function dotProduct(left, right) {
   let result = 0;
   for (let index = 0; index < left.length; index += 1) {
@@ -1009,9 +1572,7 @@ function dotProduct(left, right) {
   return result;
 }
 function semanticRanking(chunks, queryVector) {
-  const candidates = chunks.filter(
-    (chunk) => chunk.embedding !== null
-  ).map((chunk) => ({
+  const candidates = chunks.filter((chunk) => chunk.embedding !== null).map((chunk) => ({
     id: chunk.id,
     similarity: dotProduct(queryVector, chunk.embedding)
   })).sort((left, right) => right.similarity - left.similarity || left.id.localeCompare(right.id)).slice(0, SEARCH_CANDIDATE_LIMIT);
@@ -1065,6 +1626,7 @@ function fusedResults(chunks, mode, lexical, semantic, limit) {
       rank: results.length + 1,
       snippet: snippet(chunk.body),
       sourceLabel: chunk.sourceLabel,
+      sourceType: "history-article",
       title: chunk.title
     });
     if (results.length >= limit) {
@@ -1073,10 +1635,66 @@ function fusedResults(chunks, mode, lexical, semantic, limit) {
   }
   return results;
 }
+function fusedQuoteResults(quotes, mode, lexical, semantic, limit) {
+  const scores = /* @__PURE__ */ new Map();
+  const addRanking = (ranking, lane, weight) => {
+    for (const candidate of ranking) {
+      const current = scores.get(candidate.id) ?? { lanes: /* @__PURE__ */ new Set(), score: 0 };
+      current.lanes.add(lane);
+      current.score += weight / (RRF_CONSTANT + candidate.rank + 1);
+      scores.set(candidate.id, current);
+    }
+  };
+  addRanking(semantic, "semantic", mode === "hybrid" ? 0.7 : mode === "semantic" ? 1 : 0);
+  addRanking(lexical, "lexical", mode === "hybrid" ? 0.3 : mode === "lexical" ? 1 : 0);
+  const byId = new Map(quotes.map((quote) => [quote.id, quote]));
+  const results = [];
+  for (const [quoteId, score] of [...scores.entries()].sort(
+    (left, right) => right[1].score - left[1].score || left[0].localeCompare(right[0])
+  )) {
+    const quote = byId.get(quoteId);
+    if (quote === void 0) {
+      continue;
+    }
+    results.push({
+      attribution: quote.attribution,
+      contentSha256: quote.contentSha256,
+      lanes: [...score.lanes].sort(),
+      origin: quote.origin,
+      quoteId: quote.id,
+      rank: results.length + 1,
+      snippet: snippet(quote.text),
+      sourceLabel: quote.sourceLabel,
+      sourceType: "quote",
+      status: quote.status,
+      tags: [...quote.tags],
+      verbatimUse: quote.verbatimUse
+    });
+    if (results.length >= limit) {
+      break;
+    }
+  }
+  return results;
+}
+function mergeSearchResults(history, quotes, limit) {
+  const merged = [];
+  for (let index = 0; merged.length < limit && (index < history.length || index < quotes.length); index += 1) {
+    const historyItem = history[index];
+    if (historyItem !== void 0 && merged.length < limit) {
+      merged.push({ ...historyItem, rank: merged.length + 1 });
+    }
+    const quoteItem = quotes[index];
+    if (quoteItem !== void 0 && merged.length < limit) {
+      merged.push({ ...quoteItem, rank: merged.length + 1 });
+    }
+  }
+  return merged;
+}
 var KnowledgeCli = class {
   #currentDirectory;
   #databasePath;
   #embedder;
+  #homeDirectory;
   #isModelCached;
   #now;
   #randomUUID;
@@ -1085,6 +1703,7 @@ var KnowledgeCli = class {
     const now = dependencies.now ?? (() => /* @__PURE__ */ new Date());
     const modelCacheDirectory = dependencies.modelCacheDirectory ?? path2.join(dependencies.homeDirectory, ".dxc", "models", "bge-small-zh-v1.5");
     this.#currentDirectory = dependencies.currentDirectory;
+    this.#homeDirectory = dependencies.homeDirectory;
     this.#databasePath = dependencies.databasePath ?? path2.join(dependencies.homeDirectory, ".dxc", "content-memory.sqlite");
     this.#embedder = dependencies.embedder ?? new LocalBgeKnowledgeEmbedder(modelCacheDirectory, now);
     this.#isModelCached = dependencies.isModelCached ?? (() => isKnowledgeModelCached(modelCacheDirectory));
@@ -1099,16 +1718,23 @@ var KnowledgeCli = class {
         "At least one article file is required"
       );
     }
-    if (!options.lexicalOnly) {
-      this.#writeStderr(
-        "Preparing the local semantic index; first use downloads a quantized model of about 24 MB.\n"
-      );
-    }
     const database = await openDatabase(this.#databasePath);
     try {
       const imported = [];
+      const skipped = [];
+      let semanticPreparationAnnounced = false;
       for (const file of options.files) {
-        const article = await prepareArticle(this.#currentDirectory, file);
+        let article;
+        try {
+          article = await prepareArticle(this.#currentDirectory, file);
+        } catch (error) {
+          const skippedItem = skippedArticle(error, file);
+          if (skippedItem !== void 0) {
+            skipped.push(skippedItem);
+            continue;
+          }
+          throw error;
+        }
         const existing = findExistingArticle(database, article);
         const unchanged = existing?.contentSha256 === article.contentSha256 && existing.chunkerVersion === CONTENT_KNOWLEDGE_CHUNKER_VERSION;
         const semanticComplete = existing === void 0 ? false : semanticIndexComplete(database, existing.id);
@@ -1120,6 +1746,12 @@ var KnowledgeCli = class {
           });
           continue;
         }
+        if (!options.lexicalOnly && !semanticPreparationAnnounced) {
+          this.#writeStderr(
+            "Preparing the local semantic index; first use downloads a quantized model of about 24 MB.\n"
+          );
+          semanticPreparationAnnounced = true;
+        }
         const vectors = options.lexicalOnly ? void 0 : await embedArticle(this.#embedder, article);
         const saved = saveArticle(
           database,
@@ -1139,7 +1771,8 @@ var KnowledgeCli = class {
         command: "knowledge.import",
         data: {
           imported,
-          model: options.lexicalOnly ? null : this.#embedder.model
+          model: options.lexicalOnly ? null : this.#embedder.model,
+          skipped
         },
         ok: true
       });
@@ -1153,6 +1786,236 @@ var KnowledgeCli = class {
       lexicalOnly
     });
   }
+  async initQuotes() {
+    const sourcePath = quoteSourcePath(this.#homeDirectory);
+    const exists = await quoteSourceExists(sourcePath);
+    if (!exists) {
+      const legacyPath = legacyQuoteSourcePath(this.#homeDirectory);
+      const legacyExists = await quoteSourceExists(legacyPath);
+      const quotes = legacyExists ? (await readQuoteSource(legacyPath, true)).quotes : [
+        {
+          quoteId: this.#randomUUID(),
+          status: "active",
+          text: "\u628A\u8FD9\u53E5\u66FF\u6362\u6210\u4F60\u81EA\u5DF1\u7684\u91D1\u53E5\uFF1B\u91D1\u53E5 ID \u4E00\u65E6\u521B\u5EFA\u5C31\u4E0D\u8981\u4FEE\u6539\u3002",
+          tags: ["\u793A\u4F8B"],
+          source: "\u4E2A\u4EBA\u539F\u521B",
+          origin: "original",
+          attribution: null,
+          verbatimUse: "original"
+        }
+      ];
+      await writeQuoteSource(sourcePath, quotes);
+    }
+    const database = await openDatabase(this.#databasePath);
+    try {
+      return contentKnowledgeQuoteInitResultSchema.parse({
+        command: "knowledge.quotes.init",
+        data: { ...quoteSourceSummary(database, true), created: !exists },
+        ok: true
+      });
+    } finally {
+      database.close();
+    }
+  }
+  async listQuotes() {
+    const sourcePath = quoteSourcePath(this.#homeDirectory);
+    if (!await quoteSourceExists(sourcePath)) {
+      throw new KnowledgeCliError(
+        "DXC_KNOWLEDGE_QUOTE_SOURCE_NOT_INITIALIZED",
+        "Quote source file is not initialized; run knowledge quotes init first"
+      );
+    }
+    const source = await readQuoteSource(sourcePath);
+    return contentKnowledgeQuoteListResultSchema.parse({
+      command: "knowledge.quotes.list",
+      data: { quotes: source.quotes.map(quoteRecord) },
+      ok: true
+    });
+  }
+  async addQuote(options) {
+    const sourcePath = quoteSourcePath(this.#homeDirectory);
+    if (!await quoteSourceExists(sourcePath)) {
+      throw new KnowledgeCliError(
+        "DXC_KNOWLEDGE_QUOTE_SOURCE_NOT_INITIALIZED",
+        "Quote source file is not initialized; run knowledge quotes init first"
+      );
+    }
+    const source = await readQuoteSource(sourcePath);
+    const quote = quoteSourceItemSchema.safeParse({
+      attribution: options.attribution ?? null,
+      origin: options.origin ?? "original",
+      quoteId: this.#randomUUID(),
+      source: options.source ?? null,
+      status: "active",
+      tags: options.tags ?? [],
+      text: options.text,
+      verbatimUse: options.verbatimUse ?? (options.origin === "third-party" ? "needs-verification" : "original")
+    });
+    if (!quote.success) {
+      throw new KnowledgeCliError("DXC_KNOWLEDGE_QUOTE_INVALID", "Quote input is invalid");
+    }
+    await writeQuoteSource(sourcePath, [...source.quotes, quote.data]);
+    return contentKnowledgeQuoteMutationResultSchema.parse({
+      command: "knowledge.quotes.add",
+      data: { pendingSync: true, quote: quoteRecord(quote.data) },
+      ok: true
+    });
+  }
+  async updateQuote(quoteId, options) {
+    if (!UUID_PATTERN.test(quoteId) || Object.keys(options).length === 0) {
+      throw new KnowledgeCliError("DXC_KNOWLEDGE_QUOTE_INVALID", "Quote update is invalid");
+    }
+    const sourcePath = quoteSourcePath(this.#homeDirectory);
+    if (!await quoteSourceExists(sourcePath)) {
+      throw new KnowledgeCliError(
+        "DXC_KNOWLEDGE_QUOTE_SOURCE_NOT_INITIALIZED",
+        "Quote source file is not initialized; run knowledge quotes init first"
+      );
+    }
+    const source = await readQuoteSource(sourcePath);
+    const index = source.quotes.findIndex((quote) => quote.quoteId === quoteId);
+    if (index < 0) {
+      throw new KnowledgeCliError("DXC_KNOWLEDGE_QUOTE_INVALID", "Quote ID was not found");
+    }
+    const existing = source.quotes[index];
+    if (existing === void 0) {
+      throw new KnowledgeCliError(
+        "DXC_KNOWLEDGE_STATE_INVALID",
+        "Knowledge quote state is invalid"
+      );
+    }
+    const updated = quoteSourceItemSchema.safeParse({
+      ...sourceQuote(existing),
+      ...options,
+      attribution: options.attribution === void 0 ? existing.attribution ?? null : options.attribution,
+      source: options.source === void 0 ? existing.source ?? null : options.source,
+      tags: options.tags === void 0 ? existing.tags : options.tags,
+      verbatimUse: options.verbatimUse ?? (options.origin === "third-party" && existing.origin !== "third-party" ? "needs-verification" : existing.verbatimUse)
+    });
+    if (!updated.success) {
+      throw new KnowledgeCliError("DXC_KNOWLEDGE_QUOTE_INVALID", "Quote update is invalid");
+    }
+    const quotes = source.quotes.map(sourceQuote);
+    quotes[index] = updated.data;
+    await writeQuoteSource(sourcePath, quotes);
+    return contentKnowledgeQuoteMutationResultSchema.parse({
+      command: "knowledge.quotes.update",
+      data: { pendingSync: true, quote: quoteRecord(updated.data) },
+      ok: true
+    });
+  }
+  async archiveQuote(quoteId) {
+    if (!UUID_PATTERN.test(quoteId)) {
+      throw new KnowledgeCliError("DXC_KNOWLEDGE_QUOTE_INVALID", "Quote ID is invalid");
+    }
+    const sourcePath = quoteSourcePath(this.#homeDirectory);
+    if (!await quoteSourceExists(sourcePath)) {
+      throw new KnowledgeCliError(
+        "DXC_KNOWLEDGE_QUOTE_SOURCE_NOT_INITIALIZED",
+        "Quote source file is not initialized; run knowledge quotes init first"
+      );
+    }
+    const source = await readQuoteSource(sourcePath);
+    const index = source.quotes.findIndex((quote) => quote.quoteId === quoteId);
+    if (index < 0) {
+      throw new KnowledgeCliError("DXC_KNOWLEDGE_QUOTE_INVALID", "Quote ID was not found");
+    }
+    const existing = source.quotes[index];
+    if (existing === void 0) {
+      throw new KnowledgeCliError(
+        "DXC_KNOWLEDGE_STATE_INVALID",
+        "Knowledge quote state is invalid"
+      );
+    }
+    const archived = { ...sourceQuote(existing), status: "archived" };
+    const quotes = source.quotes.map(sourceQuote);
+    quotes[index] = archived;
+    await writeQuoteSource(sourcePath, quotes);
+    return contentKnowledgeQuoteMutationResultSchema.parse({
+      command: "knowledge.quotes.archive",
+      data: { pendingSync: true, quote: quoteRecord(archived) },
+      ok: true
+    });
+  }
+  async quoteStatus() {
+    const sourceInitialized = await quoteSourceExists(quoteSourcePath(this.#homeDirectory));
+    if (!await databaseExists(this.#databasePath)) {
+      return contentKnowledgeQuoteStatusResultSchema.parse({
+        command: "knowledge.quotes.status",
+        data: {
+          activeCount: 0,
+          archivedCount: 0,
+          sourceInitialized,
+          sourcePath: QUOTE_SOURCE_DISPLAY_PATH,
+          sourceSha256: null
+        },
+        ok: true
+      });
+    }
+    const database = await openDatabase(this.#databasePath);
+    try {
+      return contentKnowledgeQuoteStatusResultSchema.parse({
+        command: "knowledge.quotes.status",
+        data: quoteSourceSummary(database, sourceInitialized),
+        ok: true
+      });
+    } finally {
+      database.close();
+    }
+  }
+  async syncQuotes(lexicalOnly) {
+    const sourcePath = quoteSourcePath(this.#homeDirectory);
+    if (!await quoteSourceExists(sourcePath)) {
+      throw new KnowledgeCliError(
+        "DXC_KNOWLEDGE_QUOTE_SOURCE_NOT_INITIALIZED",
+        "Quote source file is not initialized; run knowledge quotes init first"
+      );
+    }
+    if (!lexicalOnly) {
+      this.#writeStderr(
+        "Preparing the local semantic quote index; first use downloads a quantized model of about 24 MB.\n"
+      );
+    }
+    const source = await readQuoteSource(sourcePath);
+    const database = await openDatabase(this.#databasePath);
+    try {
+      const sourceRow = database.prepare("SELECT content_sha256 FROM quote_sources WHERE source_key = 'default' LIMIT 1").get();
+      const unchanged = sourceRow !== void 0 && stringColumn(sqlRow(sourceRow), "content_sha256") === source.contentSha256 && (lexicalOnly || quoteSemanticIndexComplete(database));
+      const currentQuotes = new Map(loadActiveQuotes(database).map((quote) => [quote.id, quote]));
+      const quotesToEmbed = source.quotes.filter((quote) => {
+        const current = currentQuotes.get(quote.quoteId);
+        return quote.status === "active" && (current?.contentSha256 !== quote.contentSha256 || current.embedding === null);
+      });
+      const vectors = unchanged || lexicalOnly ? void 0 : await embedQuotes(this.#embedder, quotesToEmbed);
+      if (vectors !== void 0) {
+        for (const quote of source.quotes) {
+          const current = currentQuotes.get(quote.quoteId);
+          if (quote.status === "active" && !vectors.has(quote.quoteId) && current?.contentSha256 === quote.contentSha256 && current.embedding !== null) {
+            vectors.set(quote.quoteId, current.embedding);
+          }
+        }
+      }
+      const status = syncQuotes(
+        database,
+        source.quotes,
+        source.contentSha256,
+        vectors,
+        this.#now().toISOString(),
+        unchanged
+      );
+      return contentKnowledgeQuoteSyncResultSchema.parse({
+        command: "knowledge.quotes.sync",
+        data: {
+          ...quoteSourceSummary(database, true),
+          model: lexicalOnly ? null : this.#embedder.model,
+          status
+        },
+        ok: true
+      });
+    } finally {
+      database.close();
+    }
+  }
   async remove(articleId) {
     if (!UUID_PATTERN.test(articleId)) {
       throw new KnowledgeCliError(
@@ -1214,16 +2077,19 @@ var KnowledgeCli = class {
     const database = await openDatabase(this.#databasePath);
     try {
       const chunks = loadChunks(database);
+      const quotes = loadActiveQuotes(database);
       const usesSemantic = mode.data !== "lexical";
-      if (usesSemantic && chunks.some((chunk) => chunk.embedding === null)) {
+      if (usesSemantic && (chunks.some((chunk) => chunk.embedding === null) || quotes.some((quote) => quote.embedding === null))) {
         throw new KnowledgeCliError(
           "DXC_KNOWLEDGE_SEMANTIC_NOT_READY",
-          "All articles must have a semantic index before hybrid search"
+          "All active knowledge items must have a semantic index before hybrid search"
         );
       }
       const lexical = mode.data === "semantic" ? [] : lexicalRanking(database, query);
+      const quoteLexical = mode.data === "semantic" ? [] : quoteLexicalRanking(database, query);
       let semantic = [];
-      if (usesSemantic && chunks.length > 0) {
+      let quoteSemantic = [];
+      if (usesSemantic && (chunks.length > 0 || quotes.length > 0)) {
         let queryVector;
         try {
           queryVector = await this.#embedder.embedQuery(query);
@@ -1234,6 +2100,7 @@ var KnowledgeCli = class {
           );
         }
         semantic = semanticRanking(chunks, queryVector);
+        quoteSemantic = semanticRanking(quotes, queryVector);
       }
       return contentKnowledgeSearchResultSchema.parse({
         command: "knowledge.search",
@@ -1241,7 +2108,11 @@ var KnowledgeCli = class {
           mode: mode.data,
           model: usesSemantic ? this.#embedder.model : null,
           query,
-          results: fusedResults(chunks, mode.data, lexical, semantic, limitInput)
+          results: mergeSearchResults(
+            fusedResults(chunks, mode.data, lexical, semantic, limitInput),
+            fusedQuoteResults(quotes, mode.data, quoteLexical, quoteSemantic, limitInput),
+            limitInput
+          )
         },
         ok: true
       });
@@ -1253,6 +2124,13 @@ var KnowledgeCli = class {
     let articleCount = 0;
     let chunkCount = 0;
     let semanticIndexedChunkCount = 0;
+    let quoteSummary = {
+      activeCount: 0,
+      archivedCount: 0,
+      sourceInitialized: await quoteSourceExists(quoteSourcePath(this.#homeDirectory)),
+      sourcePath: QUOTE_SOURCE_DISPLAY_PATH,
+      sourceSha256: null
+    };
     if (await databaseExists(this.#databasePath)) {
       const database = await openDatabase(this.#databasePath);
       try {
@@ -1287,6 +2165,7 @@ var KnowledgeCli = class {
         articleCount = numberColumn(articleRowValue, "count");
         chunkCount = numberColumn(chunkRowValue, "count");
         semanticIndexedChunkCount = numberColumn(chunkRowValue, "semantic_count");
+        quoteSummary = quoteSourceSummary(database, quoteSummary.sourceInitialized);
       } finally {
         database.close();
       }
@@ -1304,7 +2183,8 @@ var KnowledgeCli = class {
           revision: CONTENT_KNOWLEDGE_EMBEDDING_REVISION
         }),
         modelCached: await this.#isModelCached(),
-        semanticIndexedChunkCount
+        semanticIndexedChunkCount,
+        quotes: quoteSummary
       },
       ok: true
     });