@@ -165,6 +165,8 @@ bl knowledge init --workspace-id <workspace-id> --dry-run
 
 知识库从创建成功起持续按时计费。标准版一次性 720 小时额度由多个知识库共享，新用户开通后 30 天内有效，模型调用另计；CLI 不假定账户余额。见[计费规则](https://help.aliyun.com/zh/model-studio/billing-for-knowledge-base)。
 
+初始化成功后，文本输出展示实际样例查询、命中文档名称（服务端提供时）和最多 400 字符的内容摘要。`--output json` 的 `sampleSearch.query` 是实际查询，`sampleSearch.response` 保留该次成功检索的完整响应（包括命中内容、评分和 request_id）；原有 `sampleMatched` 字段保持兼容。展示复用初始化验证中的响应，不额外调用检索接口，也不将检索响应写入恢复记录。
+
 保留返回的 index/agent ID、created/reused 信息和 `.bailian/knowledge/init.json`（可用 `--state-file` 指定）。重复执行先核对已有资源；同名但归属不明或请求结果不确定时不会擅自重建。创建后失败仍会输出已创建资源与计费提醒。按返回的清理动作处理本次新建资源，复用资源不属于默认清理范围；关闭终端不停止计费，成功删除知识库才能停止其规格计费。
 
 ---
 
@@ -0,0 +1,15 @@
+# Init sample search output implementation plan
+
+**Goal:** Display the sample query and retrieved content after successful initialization; expose the complete successful response as `sampleSearch: { query, response }` in JSON.
+
+**Architecture:** Return the successful search response from the existing polling loop. Preserve existing result fields, checkpoint format, error propagation and resource handling. Text output shows the matched sample document and a bounded excerpt with English/Chinese labels. No additional search request or new flags.
+
+**Tech stack:** TypeScript, existing command/runtime output helpers, Vitest.
+
+User approved this design in the current task. Execute inline in the current checkout.
+
+- [x] Extend workflow tests to assert response preservation, including request ID, and exactly one search per successful first/reuse run. Extend command tests for JSON and bilingual text, and runtime E2E for the serialized field. Run the targeted tests and observe missing-output failures.
+- [x] In `init-workflow.ts`, make `waitForSample` return a successful checked value. Return `sampleSearch` alongside `sampleMatched`. In `init.ts`, render the query, document name and a 400-character content excerpt from a node matching the sample; keep full JSON response unchanged.
+- [x] Document output fields in `docs/knowledge/knowledge-cli-guide.md`. Run targeted init tests and `pnpm exec vp check`, inspect the diff and record results. No new cloud resources are needed for this output-only change; historical live transcripts remain unchanged.
+
+Validation: the initial targeted run failed on four missing-output assertions; implementation then passed 69 tests across seven init test files. `vp check --fix` passed with three unrelated pre-existing warnings. Skill assets were regenerated without changes. No new live resources were created.
@@ -220,17 +220,14 @@ export async function runKnowledgeInit(options: InitRunOptions) {
         agent_version: "beta",
         agent_config: completed.config,
       });
-    await waitForSample(
-      async () =>
-        matchesInitSample(
-          await searchKnowledge(client, workspaceId, {
-            agent_id: state.agentId!,
-            agent_version: "beta",
-            query: INIT_SAMPLE.query,
-          }),
-        ),
-      options,
-    );
+    const sampleResponse = await waitForSample(async () => {
+      const response = await searchKnowledge(client, workspaceId, {
+        agent_id: state.agentId!,
+        agent_version: "beta",
+        query: INIT_SAMPLE.query,
+      });
+      return matchesInitSample(response) ? response : false;
+    }, options);
     state.phase = "verified";
     await checkpoint();
     return {
@@ -239,20 +236,22 @@ export async function runKnowledgeInit(options: InitRunOptions) {
       fileId: state.fileId,
       agentVersion: "beta" as const,
       sampleMatched: true as const,
+      sampleSearch: { query: INIT_SAMPLE.query, response: sampleResponse },
       resources,
       stateFile,
       timeToFirstValueMs: Date.now() - startedAt,
     };
   });
 }
 
-async function waitForSample(
-  check: () => Promise<boolean>,
+async function waitForSample<Result>(
+  check: () => Promise<Result | false>,
   options: InitRunOptions,
-): Promise<void> {
+): Promise<Result> {
   const deadline = Date.now() + options.settings.timeout * 1000;
   while (Date.now() < deadline) {
-    if (await check()) return;
+    const result = await check();
+    if (result) return result;
     const remaining = deadline - Date.now();
     if (remaining <= 0) break;
     await new Promise((resolve) =>
 
@@ -11,6 +11,7 @@ import { emitBare, emitResult } from "bailian-cli-runtime";
 import { knowledgeCreationRisk, localizedKnowledgeBillingNotice } from "./billing.ts";
 import { prepareKnowledgeInit, type InitPrepared } from "./init-prepare.ts";
 import { runKnowledgeInit, type InitResource } from "./init-workflow.ts";
+import { matchesInitSample } from "./init-sample.ts";
 import { resolveWorkspaceId, WORKSPACE_FLAG } from "./shared.ts";
 import deleteIndex from "./kb-delete.ts";
 import deleteService from "./service-delete.ts";
@@ -214,6 +215,26 @@ export default defineCommand<typeof INIT_FLAGS, InitPrepared>({
     emitBare(
       `indexId: ${result.indexId}\nagentId: ${result.agentId}\nstateFile: ${result.stateFile}`,
     );
+    const sampleNode = result.sampleSearch.response.data.nodes.find((node) =>
+      matchesInitSample({ data: { nodes: [node] } }),
+    );
+    const content = sampleNode?.metadata?.content || sampleNode?.text || "";
+    const excerpt = content.length > 400 ? `${content.slice(0, 400)}…` : content;
+    emitBare(context.localize({ "en-US": "Sample search", "zh-CN": "样例检索" }));
+    emitBare(
+      context.localize({
+        "en-US": `Query: ${result.sampleSearch.query}`,
+        "zh-CN": `查询：${result.sampleSearch.query}`,
+      }),
+    );
+    if (sampleNode?.metadata?.doc_name)
+      emitBare(
+        context.localize({
+          "en-US": `Document: ${sampleNode.metadata.doc_name}`,
+          "zh-CN": `文档：${sampleNode.metadata.doc_name}`,
+        }),
+      );
+    emitBare(context.localize({ "en-US": `Content: ${excerpt}`, "zh-CN": `内容：${excerpt}` }));
     if (nextSearch) emitBare(renderAction(context.identity.binName, nextSearch));
     emitBare(notices[0]!.message);
     if (cleanup.length)
 
@@ -88,6 +88,10 @@ test("confirmed init uses the full runtime and reuses the same resources on a se
     indexId: "index-test",
     agentId: "agent-test",
     sampleMatched: true,
+    sampleSearch: {
+      response: { data: { nodes: expect.any(Array) } },
+      query: expect.stringContaining("RAG"),
+    },
   });
   expect(payload.cleanup).toContainEqual({
     path: ["knowledge", "delete"],
 
@@ -5,8 +5,22 @@ import deleteIndex from "../../src/commands/knowledge/kb-delete.ts";
 import deleteService from "../../src/commands/knowledge/service-delete.ts";
 import deleteFile from "../../src/commands/knowledge/file-delete.ts";
 import search from "../../src/commands/knowledge/search.ts";
+import { INIT_SAMPLE } from "../../src/commands/knowledge/init-sample.ts";
 import * as workflow from "../../src/commands/knowledge/init-workflow.ts";
 
+const sampleSearch = {
+  query: INIT_SAMPLE.query,
+  response: {
+    code: "Success",
+    status_code: 200,
+    request_id: "search-request-1",
+    data: {
+      total: 1,
+      cost_time: 12,
+      nodes: [{ text: INIT_SAMPLE.content, score: 0.9, metadata: { doc_name: "sample-document" } }],
+    },
+  },
+};
 afterEach(() => vi.restoreAllMocks());
 function fixture(binName = "kscli") {
   const registry = new CommandRegistry(
@@ -53,12 +67,14 @@ test.each(["kscli", "bl"])(
       fileId: "file-1",
       agentVersion: "beta",
       sampleMatched: true,
+      sampleSearch,
       resources: [...resources],
       stateFile: "state.json",
       timeToFirstValueMs: 1,
     });
     await command.run(context);
     const output = JSON.parse(stdout.mock.calls.map(([text]) => text).join(""));
+    expect(output.sampleSearch).toEqual(sampleSearch);
     expect(output.cleanup).toEqual([
       {
         path: binName === "kscli" ? ["kb", "delete"] : ["knowledge", "delete"],
@@ -102,6 +118,7 @@ test("missing product route omits the command instead of inventing one", async (
     fileId: "file-1",
     agentVersion: "beta",
     sampleMatched: true,
+    sampleSearch,
     resources: [{ kind: "knowledge-base", id: "index-1", created: true }],
     stateFile: "state.json",
     timeToFirstValueMs: 1,
@@ -123,3 +140,63 @@ test.each([
 ])("invalid initialization flags fail before preparation %#", (flags) => {
   expect(command.validate?.(flags)).toBeDefined();
 });
+
+test.each(["en-US", "zh-CN"] as const)(
+  "text output shows actual sample query and retrieved content in %s",
+  async (language) => {
+    const { context, stdout } = fixture();
+    context.settings.output = "text";
+    context.settings.quiet = false;
+    context.localize = (text) => (typeof text === "string" ? text : text[language]);
+    vi.spyOn(workflow, "runKnowledgeInit").mockResolvedValue({
+      indexId: "index-1",
+      agentId: "agent-1",
+      fileId: "file-1",
+      agentVersion: "beta",
+      sampleMatched: true,
+      sampleSearch,
+      resources: [],
+      stateFile: "state.json",
+      timeToFirstValueMs: 1,
+    });
+    await command.run(context);
+    const output = stdout.mock.calls.map(([text]) => text).join("");
+    expect(output).toContain(INIT_SAMPLE.query);
+    expect(output).toContain("sample-document");
+    expect(output).toContain("RAG means retrieval-augmented generation.");
+    expect(output).toContain(language === "zh-CN" ? "样例检索" : "Sample search");
+  },
+);
+
+test("text summary selects the matched node, prefers metadata content and bounds the excerpt", async () => {
+  const { context, stdout } = fixture();
+  context.settings.output = "text";
+  const content = "BAILIAN_CLI_INIT_SAMPLE_V1 " + "retrieved content ".repeat(40);
+  const response = {
+    ...sampleSearch.response,
+    data: {
+      ...sampleSearch.response.data,
+      nodes: [
+        { text: "Unrelated result", score: 1, metadata: { doc_name: "unrelated" } },
+        { text: "Alternative representation", score: 0.9, metadata: { content } },
+      ],
+    },
+  };
+  vi.spyOn(workflow, "runKnowledgeInit").mockResolvedValue({
+    indexId: "index-1",
+    agentId: "agent-1",
+    fileId: "file-1",
+    agentVersion: "beta",
+    sampleMatched: true,
+    sampleSearch: { query: INIT_SAMPLE.query, response },
+    resources: [],
+    stateFile: "state.json",
+    timeToFirstValueMs: 1,
+  });
+  await command.run(context);
+  const output = stdout.mock.calls.map(([text]) => text).join("");
+  expect(output).toContain(`Content: ${content.slice(0, 400)}…`);
+  expect(output).not.toContain(content);
+  expect(output).not.toContain("Unrelated result");
+  expect(output).not.toContain("Document: undefined");
+});
@@ -42,6 +42,8 @@ async function fixture() {
     serviceFailure: undefined as Error | undefined,
     searchFailure: undefined as Error | undefined,
     emptySearch: false,
+    emptySearchesRemaining: 0,
+    searchCount: 0,
     unknownIndexResult: false,
   };
   const calls: string[] = [];
@@ -125,7 +127,11 @@ async function fixture() {
     if (body.query !== undefined) {
       if (remote.searchFailure) throw remote.searchFailure;
       expect(body.agent_version).toBe("beta");
+      remote.searchCount += 1;
+      if (remote.emptySearchesRemaining-- > 0)
+        return { request_id: "not-ready", data: { nodes: [] } };
       return {
+        request_id: "search-request-1",
         data: { nodes: remote.emptySearch ? [] : [{ text: INIT_SAMPLE.content, score: 0.9 }] },
       };
     }
@@ -153,14 +159,21 @@ async function fixture() {
 }
 
 test("first execution creates and verifies resources; second execution performs no creation or update", async () => {
-  const { execute, calls, options, report } = await fixture();
+  const { execute, calls, options, report, requestJson } = await fixture();
   const first = await execute();
   expect(first).toMatchObject({
     indexId: "index-1",
     fileId: "file-1",
     agentId: "agent-1",
     agentVersion: "beta",
     sampleMatched: true,
+    sampleSearch: {
+      query: INIT_SAMPLE.query,
+      response: {
+        request_id: "search-request-1",
+        data: { nodes: [{ text: INIT_SAMPLE.content, score: 0.9 }] },
+      },
+    },
   });
   expect(await stateStore.readStateFile(options.stateFile, localize)).toMatchObject({
     phase: "verified",
@@ -171,12 +184,18 @@ test("first execution creates and verifies resources; second execution performs
   expect(report).toHaveBeenCalledWith(
     expect.objectContaining({ kind: "knowledge-base", id: "index-1", created: true }),
   );
+  expect(
+    requestJson.mock.calls.filter(([request]) => request.body?.query !== undefined),
+  ).toHaveLength(1);
   const previousLength = calls.length;
   expect(await execute()).toMatchObject({
     indexId: first.indexId,
     agentId: first.agentId,
     sampleMatched: true,
   });
+  expect(
+    requestJson.mock.calls.filter(([request]) => request.body?.query !== undefined),
+  ).toHaveLength(2);
   expect(calls.slice(previousLength)).not.toEqual(
     expect.arrayContaining([RAG_PATHS.indexCreateV2]),
   );
@@ -284,3 +303,15 @@ test("state changes between prepare and execution stop before any cloud mutation
   ).rejects.toThrow(/changed/);
   expect(requestJson).not.toHaveBeenCalled();
 });
+
+test("returns the successful polling response without another search and does not persist it", async () => {
+  const { execute, remote, options } = await fixture();
+  remote.emptySearchesRemaining = 1;
+  const result = await execute();
+  expect(result.sampleSearch.response.request_id).toBe("search-request-1");
+  expect(result.sampleSearch.response.data.nodes[0].text).toBe(INIT_SAMPLE.content);
+  expect(remote.searchCount).toBe(2);
+  expect(await stateStore.readStateFile(options.stateFile, localize)).not.toHaveProperty(
+    "sampleSearch",
+  );
+});