veryfront 0.1.83 → 0.1.85

package/src/cli/commands/knowledge/command.ts

@@ -11,22 +11,14 @@ import { putRemoteFileFromLocal } from "../files/command.js";
 import { knowledgeIngestPythonSource } from "./parser-source.js";
 import { createJobUserLogger, type Logger, serverLogger } from "../../../src/utils/index.js";
 import { writeJobResultIfConfigured } from "../../utils/write-job-result.js";
-
-const SUPPORTED_EXTENSIONS = new Set([
-  ".pdf",
-  ".csv",
-  ".tsv",
-  ".docx",
-  ".xlsx",
-  ".xls",
-  ".pptx",
-  ".html",
-  ".htm",
-  ".txt",
-  ".json",
-  ".md",
-  ".mdx",
-]);
+import { classifyKnowledgeDirectoryPath, classifyKnowledgeSourcePath } from "./source-policy.js";
+import {
+  buildKnowledgeIngestJobResult,
+  type KnowledgeIngestFailedFileResult,
+  type KnowledgeIngestFailureReason,
+  type KnowledgeIngestFileResult,
+  type KnowledgeIngestSkippedFileResult,
+} from "./result.js";
 
 export interface KnowledgeParserResult {
   success: true;
@@ -43,22 +35,15 @@ export interface KnowledgeParserResult {
   warnings: string[];
 }
 
-export interface KnowledgeIngestFileResult {
-  source: string;
-  localSourcePath: string;
-  outputPath: string;
-  remotePath: string;
-  slug: string;
-  sourceType: string;
-  summary: string;
-  stats: Record<string, unknown>;
-  warnings: string[];
-}
-
 type KnowledgeSource =
   | { kind: "local"; input: string; localPath: string }
   | { kind: "upload"; input: string; uploadPath: string; localPath: string };
 
+export interface KnowledgeSourceCollection {
+  sources: KnowledgeSource[];
+  skipped: KnowledgeIngestSkippedFileResult[];
+}
+
 type DownloadResult = { uploadPath: string; localPath: string; bytes?: number };
 
 const knowledgeJobLogger = serverLogger.component("knowledge-ingest");
@@ -207,6 +192,18 @@ export function formatKnowledgeUploadSource(uploadPath: string): string {
     : `uploads/${normalizedPath}`;
 }
 
+function resolveExplicitUploadPath(inputPath: string): string {
+  const normalizedInput = normalizeKnowledgeInputPath(inputPath);
+  const displayInput = inputPath.replace(/\\/g, "/");
+  const uploadPath = normalizeProjectUploadPath(inputPath);
+  if (!uploadPath || normalizedInput.endsWith("/")) {
+    throw new Error(
+      `Directory upload references require --path <prefix> --all: ${displayInput}`,
+    );
+  }
+  return uploadPath;
+}
+
 export function isLikelyLocalPath(value: string): boolean {
   return value.startsWith("/") || value.startsWith("./") || value.startsWith("../") ||
     /^[A-Za-z]:[\\/]/.test(value);
@@ -218,10 +215,6 @@ function isProjectUploadReference(value: string): boolean {
   return normalizedValue === "uploads" || normalizedValue.startsWith("uploads/");
 }
 
-function isSupportedKnowledgeFile(path: string): boolean {
-  return SUPPORTED_EXTENSIONS.has(extname(path).toLowerCase());
-}
-
 function slugify(value: string): string {
   return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "document";
 }
@@ -234,32 +227,138 @@ export function resolveKnowledgeDownloadOutputDir(outputDir: string): string {
   return join(outputDir, ".uploads");
 }
 
-async function collectLocalFiles(root: string, recursive: boolean): Promise<string[]> {
+function createSkippedKnowledgeSource(input: {
+  source: string;
+  localSourcePath?: string | null;
+  message: string;
+  reason: KnowledgeIngestSkippedFileResult["reason"];
+}): KnowledgeIngestSkippedFileResult {
+  return {
+    source: input.source,
+    localSourcePath: input.localSourcePath ?? null,
+    message: input.message,
+    reason: input.reason,
+  };
+}
+
+function createFailedKnowledgeSource(input: {
+  source: string;
+  localSourcePath: string;
+  message: string;
+  reason: KnowledgeIngestFailedFileResult["reason"];
+}): KnowledgeIngestFailedFileResult {
+  return {
+    source: input.source,
+    localSourcePath: input.localSourcePath,
+    message: input.message,
+    reason: input.reason,
+  };
+}
+
+function classifySourceOrSkip(input: {
+  source: string;
+  localSourcePath?: string | null;
+}): KnowledgeIngestSkippedFileResult | null {
+  const decision = classifyKnowledgeSourcePath(input.source);
+  if (decision.kind === "ingest") {
+    return null;
+  }
+
+  return createSkippedKnowledgeSource({
+    source: input.source,
+    localSourcePath: input.localSourcePath,
+    message: decision.message,
+    reason: decision.reason,
+  });
+}
+
+function classifyDirectoryOrSkip(input: {
+  source: string;
+}): KnowledgeIngestSkippedFileResult | null {
+  const decision = classifyKnowledgeDirectoryPath(input.source);
+  if (decision.kind === "ingest") {
+    return null;
+  }
+
+  return createSkippedKnowledgeSource({
+    source: input.source,
+    localSourcePath: null,
+    message: decision.message,
+    reason: decision.reason,
+  });
+}
+
+async function collectLocalFiles(
+  root: string,
+  recursive: boolean,
+): Promise<KnowledgeSourceCollection> {
   const fs = createFileSystem();
   const stat = await fs.stat(root);
-  if (stat.isFile) return isSupportedKnowledgeFile(root) ? [root] : [];
-  if (!stat.isDirectory) return [];
+  if (stat.isFile) {
+    const skipped = classifySourceOrSkip({ source: root, localSourcePath: root });
+    return skipped == null
+      ? {
+        sources: [{ kind: "local", input: root, localPath: root }],
+        skipped: [],
+      }
+      : {
+        sources: [],
+        skipped: [skipped],
+      };
+  }
+  if (!stat.isDirectory) {
+    return { sources: [], skipped: [] };
+  }
+
+  const skippedRootDirectory = classifyDirectoryOrSkip({ source: root });
+  if (skippedRootDirectory != null) {
+    return {
+      sources: [],
+      skipped: [skippedRootDirectory],
+    };
+  }
 
-  const files: string[] = [];
+  const collection: KnowledgeSourceCollection = {
+    sources: [],
+    skipped: [],
+  };
   async function walk(dir: string): Promise<void> {
     for await (const entry of fs.readDir(dir)) {
       const entryPath = join(dir, entry.name);
       if (entry.isDirectory) {
+        const skipped = classifyDirectoryOrSkip({ source: entryPath });
+        if (skipped != null) {
+          collection.skipped.push(skipped);
+          continue;
+        }
         if (recursive) await walk(entryPath);
         continue;
       }
-      if (entry.isFile && isSupportedKnowledgeFile(entryPath)) {
-        files.push(entryPath);
+
+      if (!entry.isFile) {
+        continue;
+      }
+
+      const skipped = classifySourceOrSkip({ source: entryPath, localSourcePath: entryPath });
+      if (skipped != null) {
+        collection.skipped.push(skipped);
+        continue;
       }
+
+      collection.sources.push({ kind: "local", input: root, localPath: entryPath });
     }
   }
 
   await walk(root);
-  return files.sort();
+  collection.sources.sort((left, right) => left.localPath.localeCompare(right.localPath));
+  collection.skipped.sort((left, right) => left.source.localeCompare(right.source));
+  return collection;
 }
 
 function buildSourceReference(source: KnowledgeSource): string {
-  return source.kind === "upload" ? formatKnowledgeUploadSource(source.uploadPath) : source.input;
+  return source.kind === "upload"
+    ? formatKnowledgeUploadSource(source.uploadPath)
+    : source.localPath;
 }
 
 function buildSuggestedSlug(source: KnowledgeSource, index: number): string {
@@ -344,42 +443,51 @@ export async function runKnowledgeParser(input: {
   const scriptPath = `${tempDir}/ingest_document_to_knowledge.py`;
 
   try {
-    await dntShim.Deno.writeTextFile(
-      inputJsonPath,
-      JSON.stringify({
-        file_path: input.filePath,
-        output_dir: input.outputDir,
-        description: input.description,
-        slug: input.slug,
-        source_reference: input.sourceReference,
-      }),
-    );
-    await dntShim.Deno.writeTextFile(scriptPath, knowledgeIngestPythonSource);
-
-    let result: dntShim.Deno.CommandOutput;
     try {
-      result = await new dntShim.Deno.Command("python3", {
-        args: [scriptPath, "--input-json", inputJsonPath, "--output-json", outputJsonPath],
-        ...(input.env ? { env: input.env } : {}),
-        stdout: "piped",
-        stderr: "piped",
-      }).output();
+      await dntShim.Deno.writeTextFile(
+        inputJsonPath,
+        JSON.stringify({
+          file_path: input.filePath,
+          output_dir: input.outputDir,
+          description: input.description,
+          slug: input.slug,
+          source_reference: input.sourceReference,
+        }),
+      );
+      await dntShim.Deno.writeTextFile(scriptPath, knowledgeIngestPythonSource);
+
+      let result: dntShim.Deno.CommandOutput;
+      try {
+        result = await new dntShim.Deno.Command("python3", {
+          args: [scriptPath, "--input-json", inputJsonPath, "--output-json", outputJsonPath],
+          ...(input.env ? { env: input.env } : {}),
+          stdout: "piped",
+          stderr: "piped",
+        }).output();
+      } catch (error) {
+        if (error instanceof dntShim.Deno.errors.NotFound) {
+          throw new Error(
+            "python3 is required. Install python3 and the supported parser packages, or run the command inside the Veryfront sandbox.",
+          );
+        }
+        throw error;
+      }
+
+      if (result.code !== 0) {
+        const stderr = new TextDecoder().decode(result.stderr).trim();
+        throw new Error(stderr || "parser exited unsuccessfully");
+      }
+
+      const raw = await dntShim.Deno.readTextFile(outputJsonPath);
+      return JSON.parse(raw) as KnowledgeParserResult;
     } catch (error) {
-      if (error instanceof dntShim.Deno.errors.NotFound) {
-        throw new Error(
-          "knowledge ingest requires python3. Install python3 and the supported parser packages, or run the command inside the Veryfront sandbox.",
-        );
+      if (error instanceof Error && error.message.startsWith("knowledge ingest parser failed")) {
+        throw error;
       }
-      throw error;
-    }
 
-    if (result.code !== 0) {
-      const stderr = new TextDecoder().decode(result.stderr).trim();
-      throw new Error(`knowledge ingest parser failed${stderr ? `: ${stderr}` : ""}`);
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`knowledge ingest parser failed: ${message}`);
     }
-
-    const raw = await dntShim.Deno.readTextFile(outputJsonPath);
-    return JSON.parse(raw) as KnowledgeParserResult;
   } finally {
     await dntShim.Deno.remove(tempDir, { recursive: true }).catch(() => undefined);
   }
@@ -392,23 +500,23 @@ export async function collectKnowledgeSources(
     projectSlug: string;
     downloadUploads: (uploadPaths: string[]) => Promise<DownloadResult[]>;
   },
-): Promise<KnowledgeSource[]> {
+): Promise<KnowledgeSourceCollection> {
   const fs = createFileSystem();
 
   if (options.sources.length > 0) {
     const explicitSources: Array<
-      | { kind: "local"; sources: KnowledgeSource[] }
+      | { kind: "local"; collection: KnowledgeSourceCollection }
       | { kind: "upload"; input: string; uploadPath: string }
     > = [];
     const uploadTargets: string[] = [];
+    const skipped: KnowledgeIngestSkippedFileResult[] = [];
 
     for (const input of options.sources) {
       if (!isProjectUploadReference(input) && await fs.exists(input)) {
-        const localFiles = await collectLocalFiles(input, options.recursive);
-        if (!localFiles.length) throw new Error(`No supported files found at ${input}`);
+        const collection = await collectLocalFiles(input, options.recursive);
         explicitSources.push({
           kind: "local",
-          sources: localFiles.map((localPath) => ({ kind: "local", input, localPath })),
+          collection,
         });
         continue;
       }
@@ -417,7 +525,15 @@ export async function collectKnowledgeSources(
         throw new Error(`Local file not found: ${input}`);
       }
 
-      const uploadPath = normalizeProjectUploadPath(input);
+      const uploadPath = resolveExplicitUploadPath(input);
+      const skippedUpload = classifySourceOrSkip({
+        source: formatKnowledgeUploadSource(uploadPath),
+      });
+      if (skippedUpload != null) {
+        skipped.push(skippedUpload);
+        continue;
+      }
+
       explicitSources.push({ kind: "upload", input, uploadPath });
       uploadTargets.push(uploadPath);
     }
@@ -434,7 +550,14 @@ export async function collectKnowledgeSources(
     const resolvedSources: KnowledgeSource[] = [];
     for (const source of explicitSources) {
       if (source.kind === "local") {
-        resolvedSources.push(...source.sources);
+        for (const localSource of source.collection.sources) {
+          resolvedSources.push({
+            kind: "local",
+            input: localSource.input,
+            localPath: localSource.localPath,
+          });
+        }
+        skipped.push(...source.collection.skipped);
         continue;
       }
 
@@ -452,7 +575,10 @@ export async function collectKnowledgeSources(
       });
     }
 
-    return resolvedSources;
+    return {
+      sources: resolvedSources,
+      skipped,
+    };
   }
 
   if (!options.path || !options.all) {
@@ -460,9 +586,7 @@ export async function collectKnowledgeSources(
   }
 
   if (!isProjectUploadReference(options.path) && await fs.exists(options.path)) {
-    const localFiles = await collectLocalFiles(options.path, options.recursive);
-    if (!localFiles.length) throw new Error(`No supported files found under ${options.path}`);
-    return localFiles.map((localPath) => ({ kind: "local", input: options.path!, localPath }));
+    return collectLocalFiles(options.path, options.recursive);
   }
 
   const displayUploadPrefix = normalizeKnowledgeInputPath(options.path);
@@ -476,28 +600,57 @@ export async function collectKnowledgeSources(
     });
 
   let uploads = await listUploadsForPrefix(uploadPrefix || undefined);
+  let skipped = uploads.flatMap((item: UploadItem) => {
+    if (item.type === "folder") {
+      return [];
+    }
+
+    const skippedUpload = classifySourceOrSkip({
+      source: formatKnowledgeUploadSource(item.path),
+    });
+    return skippedUpload == null ? [] : [skippedUpload];
+  });
   let uploadTargets = uploads
-    .filter((item: UploadItem) => item.type !== "folder" && isSupportedKnowledgeFile(item.path))
-    .map((item: UploadItem) => item.path);
+    .filter((item: UploadItem) => item.type !== "folder")
+    .map((item: UploadItem) => item.path)
+    .filter((uploadPath) =>
+      classifySourceOrSkip({ source: formatKnowledgeUploadSource(uploadPath) }) == null
+    );
 
   if (!uploadTargets.length && uploadPrefix && !uploadPrefix.endsWith("/")) {
     uploads = await listUploadsForPrefix(`${uploadPrefix}/`);
+    skipped = uploads.flatMap((item: UploadItem) => {
+      if (item.type === "folder") {
+        return [];
+      }
+
+      const skippedUpload = classifySourceOrSkip({
+        source: formatKnowledgeUploadSource(item.path),
+      });
+      return skippedUpload == null ? [] : [skippedUpload];
+    });
     uploadTargets = uploads
-      .filter((item: UploadItem) => item.type !== "folder" && isSupportedKnowledgeFile(item.path))
-      .map((item: UploadItem) => item.path);
+      .filter((item: UploadItem) => item.type !== "folder")
+      .map((item: UploadItem) => item.path)
+      .filter((uploadPath) =>
+        classifySourceOrSkip({ source: formatKnowledgeUploadSource(uploadPath) }) == null
+      );
   }
 
-  if (!uploadTargets.length) {
+  if (!uploadTargets.length && skipped.length === 0) {
     throw new Error(`No supported uploads found under ${displayUploadPrefix}`);
   }
 
   const downloads = await deps.downloadUploads(uploadTargets);
-  return downloads.map((download) => ({
-    kind: "upload",
-    input: options.path!,
-    uploadPath: download.uploadPath,
-    localPath: download.localPath,
-  }));
+  return {
+    sources: downloads.map((download) => ({
+      kind: "upload",
+      input: options.path!,
+      uploadPath: download.uploadPath,
+      localPath: download.localPath,
+    })),
+    skipped,
+  };
 }
 
 export async function ingestResolvedSources(
@@ -511,67 +664,111 @@ export async function ingestResolvedSources(
     uploadKnowledgeFile: (remotePath: string, localPath: string) => Promise<{ path: string }>;
     eventLogger?: Logger | null;
   },
-): Promise<KnowledgeIngestFileResult[]> {
+): Promise<{
+  ingested: KnowledgeIngestFileResult[];
+  failed: KnowledgeIngestFailedFileResult[];
+}> {
   if (options.slug && sources.length !== 1) {
     throw new Error("--slug can only be used with a single explicit source.");
   }
 
   const slugs = options.slug ? [options.slug] : ensureUniqueSlugs(sources);
-  const results: KnowledgeIngestFileResult[] = [];
-
-  for (const [index, source] of sources.entries()) {
-    deps.eventLogger?.info("Processing knowledge source", {
-      phase: "file_processing",
+  const ingested: KnowledgeIngestFileResult[] = [];
+  const failed: KnowledgeIngestFailedFileResult[] = [];
+  const recordSourceFailure = (
+    source: KnowledgeSource,
+    sourceReference: string,
+    index: number,
+    message: string,
+    reason: KnowledgeIngestFailureReason,
+  ) => {
+    deps.eventLogger?.error("Knowledge source failed", {
+      phase: "file_failed",
       progress_current: index + 1,
       progress_total: sources.length,
       source_name: buildKnowledgeSourceName(source),
+      error: message,
     });
 
-    const parser = await deps.runParser({
-      filePath: source.localPath,
-      outputDir: deps.outputDir,
-      description: options.description,
-      slug: slugs[index],
-      sourceReference: buildSourceReference(source),
-    });
-    const remotePath = deriveKnowledgeRemotePath(
-      parser.sandbox_output_path,
-      deps.outputDir,
-      options.knowledgePath,
-    );
-    const uploaded = await deps.uploadKnowledgeFile(remotePath, parser.sandbox_output_path);
+    failed.push(createFailedKnowledgeSource({
+      source: sourceReference,
+      localSourcePath: source.localPath,
+      message,
+      reason,
+    }));
+  };
 
-    deps.eventLogger?.info("Knowledge source ingested", {
-      phase: "file_completed",
+  for (const [index, source] of sources.entries()) {
+    const sourceReference = buildSourceReference(source);
+
+    deps.eventLogger?.info("Processing knowledge source", {
+      phase: "file_processing",
       progress_current: index + 1,
       progress_total: sources.length,
       source_name: buildKnowledgeSourceName(source),
-      remote_path: uploaded.path,
-      warning_count: parser.warnings.length,
     });
 
-    if (parser.warnings.length > 0) {
-      deps.eventLogger?.warn("Knowledge source emitted warnings", {
-        phase: "file_warning",
+    let parser: KnowledgeParserResult;
+    try {
+      parser = await deps.runParser({
+        filePath: source.localPath,
+        outputDir: deps.outputDir,
+        description: options.description,
+        slug: slugs[index],
+        sourceReference,
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      recordSourceFailure(source, sourceReference, index, message, "parser_error");
+      continue;
+    }
+
+    try {
+      const remotePath = deriveKnowledgeRemotePath(
+        parser.sandbox_output_path,
+        deps.outputDir,
+        options.knowledgePath,
+      );
+      const uploaded = await deps.uploadKnowledgeFile(remotePath, parser.sandbox_output_path);
+
+      deps.eventLogger?.info("Knowledge source ingested", {
+        phase: "file_completed",
         progress_current: index + 1,
         progress_total: sources.length,
         source_name: buildKnowledgeSourceName(source),
+        remote_path: uploaded.path,
         warning_count: parser.warnings.length,
       });
-    }
 
-    results.push(
-      createKnowledgeIngestResult({
-        source: buildSourceReference(source),
-        localSourcePath: source.localPath,
-        outputPath: parser.sandbox_output_path,
-        remotePath: uploaded.path,
-        parser,
-      }),
-    );
+      if (parser.warnings.length > 0) {
+        deps.eventLogger?.warn("Knowledge source emitted warnings", {
+          phase: "file_warning",
+          progress_current: index + 1,
+          progress_total: sources.length,
+          source_name: buildKnowledgeSourceName(source),
+          warning_count: parser.warnings.length,
+        });
+      }
+
+      ingested.push(
+        createKnowledgeIngestResult({
+          source: sourceReference,
+          localSourcePath: source.localPath,
+          outputPath: parser.sandbox_output_path,
+          remotePath: uploaded.path,
+          parser,
+        }),
+      );
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      recordSourceFailure(source, sourceReference, index, message, "upload_error");
+    }
   }
 
-  return results;
+  return {
+    ingested,
+    failed,
+  };
 }
 
 export async function knowledgeCommand(args: ParsedArgs): Promise<void> {
@@ -601,12 +798,14 @@ export async function knowledgeCommand(args: ParsedArgs): Promise<void> {
         const eventLogger = createKnowledgeIngestEventLogger();
 
         try {
+          const sourceMode = options.path ? "path_prefix" : "explicit_sources";
+
           eventLogger?.info("Starting knowledge ingest", {
             phase: "started",
-            mode: options.path ? "path_prefix" : "explicit_sources",
+            mode: sourceMode,
           });
 
-          const sources = await collectKnowledgeSources(options, {
+          const collection = await collectKnowledgeSources(options, {
             client,
             projectSlug: config.projectSlug,
             downloadUploads: (uploadPaths) =>
@@ -616,13 +815,25 @@ export async function knowledgeCommand(args: ParsedArgs): Promise<void> {
                 ),
               ),
           });
+          const requestedCount = collection.sources.length + collection.skipped.length;
+          if (requestedCount === 0) {
+            throw new Error("No supported knowledge sources were found.");
+          }
 
           eventLogger?.info("Resolved knowledge sources", {
             phase: "sources_resolved",
-            progress_total: sources.length,
+            progress_total: requestedCount,
+            ingestable_count: collection.sources.length,
+            skipped_count: collection.skipped.length,
           });
+          if (collection.skipped.length > 0) {
+            eventLogger?.warn("Skipped knowledge sources", {
+              phase: "sources_skipped",
+              skipped_count: collection.skipped.length,
+            });
+          }
 
-          const results = await ingestResolvedSources(sources, options, {
+          const results = await ingestResolvedSources(collection.sources, options, {
             client,
             projectSlug: config.projectSlug,
             outputDir,
@@ -631,26 +842,51 @@ export async function knowledgeCommand(args: ParsedArgs): Promise<void> {
             uploadKnowledgeFile: (remotePath, localPath) =>
               putRemoteFileFromLocal(client, config.projectSlug, remotePath, localPath),
           });
+          const jobResult = buildKnowledgeIngestJobResult({
+            requestedCount,
+            sourceMode,
+            knowledgePath: options.knowledgePath,
+            ingested: results.ingested,
+            skipped: collection.skipped,
+            failed: results.failed,
+          });
 
           eventLogger?.info("Completed knowledge ingest", {
             phase: "completed",
-            progress_current: results.length,
-            progress_total: results.length,
+            progress_current: requestedCount,
+            progress_total: requestedCount,
+            ingested_count: jobResult.summary.ingested_count,
+            skipped_count: jobResult.summary.skipped_count,
+            failed_count: jobResult.summary.failed_count,
           });
 
-          await writeJobResultIfConfigured(results);
+          await writeJobResultIfConfigured(jobResult);
 
           if (options.json) {
-            printJson(results);
+            printJson(jobResult);
             return;
           }
 
-          for (const result of results) {
+          for (const result of jobResult.ingested) {
             if (!options.quiet) {
               cliLogger.info(`Ingested ${result.source} -> ${result.remotePath}`);
               cliLogger.info(`  ${result.summary}`);
             }
           }
+
+          for (const skipped of jobResult.skipped) {
+            if (!options.quiet) {
+              cliLogger.warn(`Skipped ${skipped.source}`);
+              cliLogger.warn(`  ${skipped.message}`);
+            }
+          }
+
+          for (const failure of jobResult.failed) {
+            if (!options.quiet) {
+              cliLogger.error(`Failed ${failure.source}`);
+              cliLogger.error(`  ${failure.message}`);
+            }
+          }
         } catch (error) {
           eventLogger?.error("Knowledge ingest failed", {
             phase: "failed",