@codemcp/ade 0.7.0 → 0.8.0

package/packages/cli/package.json

@@ -41,5 +41,5 @@
     "typescript": "catalog:",
     "vitest": "catalog:"
   },
-  "version": "0.7.0"
+  "version": "0.8.0"
 }

package/packages/cli/src/commands/conventions.integration.spec.ts

@@ -1,5 +1,12 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { mkdtemp, rm, readFile, access } from "node:fs/promises";
+import {
+  mkdtemp,
+  rm,
+  readFile,
+  access,
+  writeFile,
+  mkdir
+} from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
@@ -21,6 +28,27 @@ vi.mock("@clack/prompts", () => ({
   spinner: vi.fn().mockReturnValue({ start: vi.fn(), stop: vi.fn() })
 }));
 
+// Mock the knowledge package to avoid real network I/O
+vi.mock("@codemcp/knowledge/packages/cli/dist/exports.js", () => ({
+  createDocset: vi.fn(
+    async (
+      params: { id: string; name: string; url?: string },
+      options: { cwd?: string }
+    ) => {
+      const dir = join(options?.cwd ?? process.cwd(), ".knowledge");
+      await mkdir(dir, { recursive: true });
+      const configPath = join(dir, "config.yaml");
+      await writeFile(
+        configPath,
+        `version: "1.0"\ndocsets:\n  - id: ${params.id}\n`,
+        { flag: "w" }
+      );
+      return { docset: {}, configPath, configCreated: true };
+    }
+  ),
+  initDocset: vi.fn().mockResolvedValue({ alreadyInitialized: false })
+}));
+
 import * as clack from "@clack/prompts";
 import { runSetup } from "./setup.js";
 import { readUserConfig, readLockFile } from "@codemcp/ade-core";
@@ -51,7 +79,6 @@ describe("architecture and practices facets integration", () => {
       vi.mocked(clack.multiselect)
         .mockResolvedValueOnce([]) // practices: none
         .mockResolvedValueOnce([]) // backpressure: none
-        .mockResolvedValueOnce([]) // docsets: deselect all
         .mockResolvedValueOnce(["claude-code"]); // harnesses
 
       await runSetup(dir, catalog);
@@ -110,7 +137,6 @@ describe("architecture and practices facets integration", () => {
       .mockResolvedValueOnce("__skip__"); // architecture: skip
     vi.mocked(clack.multiselect)
       .mockResolvedValueOnce(["conventional-commits", "tdd-london"]) // practices
-      .mockResolvedValueOnce([]) // docsets: deselect all (conventional-commits has docset)
       .mockResolvedValueOnce(["claude-code"]); // harnesses
 
     await runSetup(dir, catalog);
@@ -237,7 +263,6 @@ describe("architecture and practices facets integration", () => {
       vi.mocked(clack.multiselect)
         .mockResolvedValueOnce(["tdd-london", "conventional-commits"]) // practices
         .mockResolvedValueOnce([]) // backpressure: none
-        .mockResolvedValueOnce([]) // docsets: deselect all
         .mockResolvedValueOnce(["claude-code"]); // harnesses
 
       await runSetup(dir, catalog);

package/packages/cli/src/commands/extensions.integration.spec.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { mkdtemp, rm, readFile } from "node:fs/promises";
+import { mkdtemp, rm, readFile, writeFile, mkdir } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
@@ -17,6 +17,27 @@ vi.mock("@clack/prompts", () => ({
   spinner: vi.fn().mockReturnValue({ start: vi.fn(), stop: vi.fn() })
 }));
 
+// Mock the knowledge package to avoid real network I/O
+vi.mock("@codemcp/knowledge/packages/cli/dist/exports.js", () => ({
+  createDocset: vi.fn(
+    async (
+      params: { id: string; name: string; url?: string },
+      options: { cwd?: string }
+    ) => {
+      const dir = join(options?.cwd ?? process.cwd(), ".knowledge");
+      await mkdir(dir, { recursive: true });
+      const configPath = join(dir, "config.yaml");
+      await writeFile(
+        configPath,
+        `version: "1.0"\ndocsets:\n  - id: ${params.id}\n`,
+        { flag: "w" }
+      );
+      return { docset: {}, configPath, configCreated: true };
+    }
+  ),
+  initDocset: vi.fn().mockResolvedValue({ alreadyInitialized: false })
+}));
+
 import * as clack from "@clack/prompts";
 import { runSetup } from "./setup.js";
 import {
@@ -43,7 +64,7 @@ describe("extension e2e — option contributes skills and knowledge to setup out
     "extension-contributed architecture option writes inline skill and knowledge source",
     { timeout: 60_000 },
     async () => {
-      // Build an extension with a SAP option that has an inline skill + knowledge
+      // Build an extension with a SAP option that has an inline skill + a docset
       const extensions: AdeExtensions = {
         facetContributions: {
           architecture: [
@@ -65,9 +86,10 @@ describe("extension e2e — option contributes skills and knowledge to setup out
                   }
                 },
                 {
-                  writer: "knowledge",
+                  writer: "docset",
                   config: {
-                    name: "sap-abap-docs",
+                    id: "sap-abap-docs",
+                    label: "SAP ABAP Cloud",
                     origin: "https://help.sap.com/docs/abap-cloud",
                     description: "SAP ABAP Cloud documentation"
                   }

package/packages/cli/src/commands/install.ts

@@ -8,6 +8,7 @@ import {
   installSkills,
   writeInlineSkills
 } from "@codemcp/ade-harnesses";
+import { installKnowledge } from "../knowledge-installer.js";
 
 export async function runInstall(
   projectRoot: string,
@@ -77,6 +78,7 @@ export async function runInstall(
   }
 
   if (logicalConfig.knowledge_sources.length > 0) {
+    await installKnowledge(logicalConfig.knowledge_sources, projectRoot);
     clack.log.info(
       "Knowledge sources configured. Initialize them separately:\n  npx @codemcp/knowledge init"
     );

package/packages/cli/src/commands/knowledge-docset.integration.spec.ts

@@ -0,0 +1,179 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { mkdtemp, rm, readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+/**
+ * E2E regression tests for two issues with docset / knowledge setup:
+ *
+ * Issue 1 — Design inconsistency (now fixed):
+ *   The `knowledge` provision writer was a redundant second way to add
+ *   knowledge sources alongside `option.docsets[]`. It has been removed.
+ *   Docsets are now declared via `{ writer: "docset", config: {...} }` recipe
+ *   entries (the `docset` provision writer), consistent with how skills work.
+ *
+ * Issue 2 — Missing .knowledge/config.yaml (now fixed):
+ *   `installKnowledge` was never called from `setup` or `install`, so
+ *   `createDocset` was never invoked and `.knowledge/config.yaml` was
+ *   never written. Both commands now call `installKnowledge`.
+ */
+
+// Mock the TUI
+vi.mock("@clack/prompts", () => ({
+  intro: vi.fn(),
+  outro: vi.fn(),
+  note: vi.fn(),
+  select: vi.fn(),
+  multiselect: vi.fn(),
+  confirm: vi.fn().mockResolvedValue(false),
+  isCancel: vi.fn().mockReturnValue(false),
+  cancel: vi.fn(),
+  log: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), success: vi.fn() },
+  spinner: vi.fn().mockReturnValue({ start: vi.fn(), stop: vi.fn() })
+}));
+
+// Mock the knowledge package to avoid real network I/O while still letting us
+// assert that createDocset is called with the correct arguments.
+// The mock writes a real .knowledge/config.yaml so file-existence assertions work.
+import { writeFile, mkdir } from "node:fs/promises";
+vi.mock("@codemcp/knowledge/packages/cli/dist/exports.js", () => ({
+  createDocset: vi.fn(
+    async (
+      params: { id: string; name: string; url?: string },
+      options: { cwd?: string }
+    ) => {
+      const dir = join(options?.cwd ?? process.cwd(), ".knowledge");
+      await mkdir(dir, { recursive: true });
+      const configPath = join(dir, "config.yaml");
+      // Append a minimal docset entry so the file is created/updated
+      await writeFile(
+        configPath,
+        `version: "1.0"\ndocsets:\n  - id: ${params.id}\n`,
+        { flag: "w" }
+      );
+      return { docset: {}, configPath, configCreated: true };
+    }
+  ),
+  initDocset: vi.fn().mockResolvedValue({ alreadyInitialized: false })
+}));
+
+import * as clack from "@clack/prompts";
+import { createDocset } from "@codemcp/knowledge/packages/cli/dist/exports.js";
+import { runSetup } from "./setup.js";
+import { runInstall } from "./install.js";
+import { readLockFile, getDefaultCatalog } from "@codemcp/ade-core";
+
+describe("knowledge docset regression tests", () => {
+  let dir: string;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    vi.mocked(clack.confirm).mockResolvedValue(false);
+    dir = await mkdtemp(join(tmpdir(), "ade-knowledge-bug-"));
+  });
+
+  afterEach(async () => {
+    await rm(dir, { recursive: true, force: true });
+  });
+
+  // -------------------------------------------------------------------------
+  // Issue 2 fix: setup writes .knowledge/config.yaml
+  // -------------------------------------------------------------------------
+
+  it(
+    "setup writes .knowledge/config.yaml when knowledge_sources are configured",
+    { timeout: 30_000 },
+    async () => {
+      const catalog = getDefaultCatalog();
+
+      vi.mocked(clack.select)
+        .mockResolvedValueOnce("codemcp-workflows") // process
+        .mockResolvedValueOnce("tanstack"); // architecture — has 4 docsets
+      vi.mocked(clack.multiselect)
+        .mockResolvedValueOnce([]) // practices: none
+        .mockResolvedValueOnce([]) // backpressure: none
+        .mockResolvedValueOnce(["claude-code"]); // harnesses
+      vi.mocked(clack.confirm)
+        .mockResolvedValueOnce(false) // skills: skip
+        .mockResolvedValueOnce(true); // knowledge: initialize now
+
+      await runSetup(dir, catalog);
+
+      // Sanity: knowledge_sources in lock file
+      const lock = await readLockFile(dir);
+      expect(lock!.logical_config.knowledge_sources).toHaveLength(4);
+
+      // createDocset must have been called once per source
+      expect(createDocset).toHaveBeenCalledTimes(4);
+      expect(createDocset).toHaveBeenCalledWith(
+        expect.objectContaining({ id: "tanstack-router-docs" }),
+        expect.objectContaining({ cwd: dir })
+      );
+
+      // .knowledge/config.yaml must exist
+      const configYaml = await readFile(
+        join(dir, ".knowledge", "config.yaml"),
+        "utf-8"
+      );
+      expect(configYaml).toBeTruthy();
+    }
+  );
+
+  it(
+    "install writes .knowledge/config.yaml when knowledge_sources exist in lock file",
+    { timeout: 30_000 },
+    async () => {
+      const catalog = getDefaultCatalog();
+
+      // First setup to produce a lock file with knowledge_sources
+      vi.mocked(clack.select)
+        .mockResolvedValueOnce("codemcp-workflows") // process
+        .mockResolvedValueOnce("tanstack"); // architecture
+      vi.mocked(clack.multiselect)
+        .mockResolvedValueOnce([]) // practices: none
+        .mockResolvedValueOnce([]) // backpressure: none
+        .mockResolvedValueOnce(["claude-code"]); // harnesses
+      // skills: skip, knowledge: skip (install command will handle it)
+      vi.mocked(clack.confirm)
+        .mockResolvedValueOnce(false)
+        .mockResolvedValueOnce(false);
+
+      await runSetup(dir, catalog);
+      vi.clearAllMocks();
+
+      // Wipe agent files so install has something to regenerate
+      await rm(join(dir, ".mcp.json"), { force: true });
+      await rm(join(dir, ".knowledge"), { recursive: true, force: true });
+
+      // Now run install — should also write .knowledge/config.yaml
+      await runInstall(dir, ["claude-code"]);
+
+      // All 4 tanstack docsets are configured via the docset writer (no per-item selection)
+      expect(createDocset).toHaveBeenCalledTimes(4);
+      expect(createDocset).toHaveBeenCalledWith(
+        expect.objectContaining({ id: "tanstack-router-docs" }),
+        expect.objectContaining({ cwd: dir })
+      );
+
+      const configYaml = await readFile(
+        join(dir, ".knowledge", "config.yaml"),
+        "utf-8"
+      );
+      expect(configYaml).toBeTruthy();
+    }
+  );
+
+  // -------------------------------------------------------------------------
+  // Issue 1 fix: knowledge writer removed — docset provision writer is canonical
+  // -------------------------------------------------------------------------
+
+  it("ProvisionWriter type no longer includes 'knowledge'", async () => {
+    // Import the type-level check: if 'knowledge' were still in ProvisionWriter,
+    // this runtime check would catch the registry accepting it silently.
+    const { createDefaultRegistry } = await import("@codemcp/ade-core");
+    const registry = createDefaultRegistry();
+    // The knowledge writer must not be registered
+    const { getProvisionWriter } = await import("@codemcp/ade-core");
+    expect(getProvisionWriter(registry, "knowledge")).toBeUndefined();
+  });
+});

package/packages/cli/src/commands/knowledge.integration.spec.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { mkdtemp, rm, readFile } from "node:fs/promises";
+import { mkdtemp, rm, readFile, writeFile, mkdir } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
@@ -16,6 +16,27 @@ vi.mock("@clack/prompts", () => ({
   spinner: vi.fn().mockReturnValue({ start: vi.fn(), stop: vi.fn() })
 }));
 
+// Mock the knowledge package to avoid real network I/O
+vi.mock("@codemcp/knowledge/packages/cli/dist/exports.js", () => ({
+  createDocset: vi.fn(
+    async (
+      params: { id: string; name: string; url?: string },
+      options: { cwd?: string }
+    ) => {
+      const dir = join(options?.cwd ?? process.cwd(), ".knowledge");
+      await mkdir(dir, { recursive: true });
+      const configPath = join(dir, "config.yaml");
+      await writeFile(
+        configPath,
+        `version: "1.0"\ndocsets:\n  - id: ${params.id}\n`,
+        { flag: "w" }
+      );
+      return { docset: {}, configPath, configCreated: true };
+    }
+  ),
+  initDocset: vi.fn().mockResolvedValue({ alreadyInitialized: false })
+}));
+
 import * as clack from "@clack/prompts";
 import { runSetup } from "./setup.js";
 import { readLockFile } from "@codemcp/ade-core";
@@ -46,17 +67,11 @@ describe("knowledge integration", () => {
       vi.mocked(clack.multiselect)
         .mockResolvedValueOnce([]) // practices: none
         .mockResolvedValueOnce([]) // backpressure: none
-        .mockResolvedValueOnce([
-          "tanstack-router-docs",
-          "tanstack-query-docs",
-          "tanstack-form-docs",
-          "tanstack-table-docs"
-        ])
         .mockResolvedValueOnce(["claude-code"]); // harnesses
 
       await runSetup(dir, catalog);
 
-      // Lock file should contain knowledge_sources
+      // Lock file should contain all 4 knowledge_sources from tanstack docset entries
       const lock = await readLockFile(dir);
       expect(lock!.logical_config.knowledge_sources).toHaveLength(4);
       expect(lock!.logical_config.knowledge_sources.map((s) => s.name)).toEqual(
@@ -84,33 +99,6 @@ describe("knowledge integration", () => {
     }
   );
 
-  it(
-    "excludes deselected docsets from lock file",
-    { timeout: 60_000 },
-    async () => {
-      const catalog = getDefaultCatalog();
-
-      vi.mocked(clack.select)
-        .mockResolvedValueOnce("codemcp-workflows") // process
-        .mockResolvedValueOnce("tanstack"); // architecture
-
-      vi.mocked(clack.multiselect)
-        .mockResolvedValueOnce([]) // practices: none
-        .mockResolvedValueOnce([]) // backpressure: none
-        .mockResolvedValueOnce(["tanstack-router-docs", "tanstack-query-docs"])
-        .mockResolvedValueOnce(["claude-code"]); // harnesses
-
-      await runSetup(dir, catalog);
-
-      // Lock file should only have the 2 selected sources
-      const lock = await readLockFile(dir);
-      expect(lock!.logical_config.knowledge_sources).toHaveLength(2);
-      expect(lock!.logical_config.knowledge_sources.map((s) => s.name)).toEqual(
-        expect.arrayContaining(["tanstack-router-docs", "tanstack-query-docs"])
-      );
-    }
-  );
-
   it("does not show knowledge hint when no docsets are implied", async () => {
     const catalog = getDefaultCatalog();
 
@@ -118,7 +106,7 @@ describe("knowledge integration", () => {
       .mockResolvedValueOnce("native-agents-md") // process
       .mockResolvedValueOnce("__skip__"); // architecture: skip
     vi.mocked(clack.multiselect)
-      .mockResolvedValueOnce(["tdd-london"]) // practices: no docsets
+      .mockResolvedValueOnce(["tdd-london"]) // practices: tdd-london has no docsets
       .mockResolvedValueOnce(["claude-code"]); // harnesses
 
     await runSetup(dir, catalog);

package/packages/cli/src/commands/setup.spec.ts

@@ -31,8 +31,7 @@ vi.mock("@codemcp/ade-core", async (importOriginal) => {
       skills: [],
       git_hooks: [],
       setup_notes: []
-    } satisfies LogicalConfig),
-    collectDocsets: actual.collectDocsets
+    } satisfies LogicalConfig)
   };
 });
 
@@ -112,39 +111,6 @@ const testCatalog: Catalog = {
   ]
 };
 
-const docsetCatalog: Catalog = {
-  facets: [
-    {
-      id: "arch",
-      label: "Architecture",
-      description: "Stack",
-      required: true,
-      options: [
-        {
-          id: "react",
-          label: "React",
-          description: "React framework",
-          recipe: [],
-          docsets: [
-            {
-              id: "react-docs",
-              label: "React Reference",
-              origin: "https://github.com/facebook/react.git",
-              description: "Official React docs"
-            },
-            {
-              id: "react-tutorial",
-              label: "React Tutorial",
-              origin: "https://github.com/reactjs/react.dev.git",
-              description: "React learn guide"
-            }
-          ]
-        }
-      ]
-    }
-  ]
-};
-
 // ── Tests ────────────────────────────────────────────────────────────────────
 
 describe("runSetup", () => {
@@ -239,72 +205,6 @@ describe("runSetup", () => {
     expect(clack.cancel).toHaveBeenCalled();
   });
 
-  describe("docset confirmation step", () => {
-    it("presents implied docsets as a multiselect after facet selection", async () => {
-      vi.mocked(clack.select).mockResolvedValueOnce("react");
-      // User accepts all docsets (returns all ids), then harness selection
-      vi.mocked(clack.multiselect)
-        .mockResolvedValueOnce(["react-docs", "react-tutorial"])
-        .mockResolvedValueOnce(["claude-code"]);
-
-      await runSetup("/tmp/test-project", docsetCatalog);
-
-      // multiselect should have been called for docsets
-      expect(clack.multiselect).toHaveBeenCalledWith(
-        expect.objectContaining({
-          message: expect.stringContaining("Documentation")
-        })
-      );
-    });
-
-    it("stores deselected docsets as excluded_docsets in user config", async () => {
-      vi.mocked(clack.select).mockResolvedValueOnce("react");
-      // User deselects react-tutorial, keeps only react-docs; then harness
-      vi.mocked(clack.multiselect)
-        .mockResolvedValueOnce(["react-docs"])
-        .mockResolvedValueOnce(["claude-code"]);
-
-      await runSetup("/tmp/test-project", docsetCatalog);
-
-      expect(writeUserConfig).toHaveBeenCalledWith(
-        "/tmp/test-project",
-        expect.objectContaining({
-          excluded_docsets: ["react-tutorial"]
-        })
-      );
-    });
-
-    it("does not set excluded_docsets when all docsets are accepted", async () => {
-      vi.mocked(clack.select).mockResolvedValueOnce("react");
-      vi.mocked(clack.multiselect)
-        .mockResolvedValueOnce(["react-docs", "react-tutorial"])
-        .mockResolvedValueOnce(["claude-code"]);
-
-      await runSetup("/tmp/test-project", docsetCatalog);
-
-      const configArg = vi.mocked(writeUserConfig).mock.calls[0][1];
-      expect(configArg.excluded_docsets).toBeUndefined();
-    });
-
-    it("skips docset prompt when no options have docsets", async () => {
-      vi.mocked(clack.select)
-        .mockResolvedValueOnce("workflow-a")
-        .mockResolvedValueOnce("vitest");
-      // Only the harness multiselect should be called (no docsets in testCatalog)
-      vi.mocked(clack.multiselect).mockResolvedValueOnce(["claude-code"]);
-
-      await runSetup("/tmp/test-project", testCatalog);
-
-      // multiselect should have been called exactly once (for harnesses only)
-      expect(clack.multiselect).toHaveBeenCalledTimes(1);
-      expect(clack.multiselect).toHaveBeenCalledWith(
-        expect.objectContaining({
-          message: expect.stringContaining("coding agents")
-        })
-      );
-    });
-  });
-
   it("calls intro and outro from @clack/prompts", async () => {
     vi.mocked(clack.select)
       .mockResolvedValueOnce("workflow-a")

package/packages/cli/src/commands/setup.ts

@@ -8,7 +8,6 @@ import {
   writeUserConfig,
   writeLockFile,
   resolve,
-  collectDocsets,
   createDefaultRegistry,
   getFacet,
   getOption,
@@ -22,6 +21,7 @@ import {
   installSkills,
   writeInlineSkills
 } from "@codemcp/ade-harnesses";
+import { installKnowledge } from "../knowledge-installer.js";
 
 export async function runSetup(
   projectRoot: string,
@@ -107,37 +107,6 @@ export async function runSetup(
     }
   }
 
-  // Docset confirmation step: collect implied docsets, let user deselect
-  const impliedDocsets = collectDocsets(choices, catalog);
-  let excludedDocsets: string[] | undefined;
-
-  if (impliedDocsets.length > 0) {
-    const selected = await clack.multiselect({
-      message:
-        "Documentation sources — Those will be pulled to your local disk for browsing on demand",
-      options: impliedDocsets.map((d) => ({
-        value: d.id,
-        label: d.label,
-        hint: d.description
-      })),
-      initialValues: impliedDocsets.map((d) => d.id),
-      required: false
-    });
-
-    if (typeof selected === "symbol") {
-      clack.cancel("Setup cancelled.");
-      return;
-    }
-
-    const selectedSet = new Set(selected as string[]);
-    const excluded = impliedDocsets
-      .filter((d) => !selectedSet.has(d.id))
-      .map((d) => d.id);
-    if (excluded.length > 0) {
-      excludedDocsets = excluded;
-    }
-  }
-
   // Harness selection — multi-select from all available harnesses
   const existingHarnesses = existingConfig?.harnesses;
   const harnessOptions = harnessWriters.map((w) => ({
@@ -171,7 +140,6 @@ export async function runSetup(
 
   const userConfig: UserConfig = {
     choices,
-    ...(excludedDocsets && { excluded_docsets: excludedDocsets }),
     ...(harnesses.length > 0 && { harnesses })
   };
   const registry = createDefaultRegistry();
@@ -234,9 +202,28 @@ export async function runSetup(
   }
 
   if (logicalConfig.knowledge_sources.length > 0) {
-    clack.log.info(
-      "Knowledge sources selected. Initialize them separately:\n  npx @codemcp/knowledge init"
-    );
+    const initCommands = logicalConfig.knowledge_sources
+      .map((s) => `  npx @codemcp/knowledge init ${s.name}`)
+      .join("\n");
+    const confirmInit = await clack.confirm({
+      message: `Initialize ${logicalConfig.knowledge_sources.length} knowledge source(s) now?`,
+      initialValue: false
+    });
+
+    if (typeof confirmInit === "symbol") {
+      clack.cancel("Setup cancelled.");
+      return;
+    }
+
+    if (confirmInit) {
+      await installKnowledge(logicalConfig.knowledge_sources, projectRoot, {
+        force: true
+      });
+    } else {
+      clack.log.info(
+        `Knowledge sources configured. Initialize them when ready:\n${initCommands}`
+      );
+    }
   }
 
   for (const note of logicalConfig.setup_notes) {