feat(kap-server): purge deleted sessions from the global search index

Deleting a session removed the core session and its session-index
entry but left its prompt and assistant text in the search MiniDb
until a later writer sync happened to re-scan, so a search right after
a permanent deletion could still return the deleted content. The
delete route now purges the session's documents immediately through a
new IGlobalSearchService.deleteSession, wired through the inline
backend and the search worker protocol, with failures logged rather
than failing the delete.

Also classify the changeset as minor (new user-visible capability) and
drop a redundant undefined union from the kimi-inspect callback type.

Co-authored-by: qer <wbxl2000@outlook.com>

Author: kimi-agent-bot

.changeset/session-delete-action.md

@@ -1,5 +1,5 @@
 ---
-"@moonshot-ai/kimi-code": patch
+"@moonshot-ai/kimi-code": minor
 ---
 
 Expose permanent session deletion via `POST /api/v1/sessions/{session_id}:delete` and broadcast `event.session.deleted` over WebSocket.

apps/kimi-inspect/src/activity/ws.ts

@@ -67,7 +67,7 @@ export interface GlobalEventsWsHandlers {
   /** A session was permanently deleted (list-level signal). Same envelope
    *  shape as `event.session.archived`: the real session id rides in the
    *  payload. */
-  onSessionDeleted?: ((sessionId: string) => void) | undefined;
+  onSessionDeleted?: (sessionId: string) => void;
   /** A workspace was created / updated / deleted (list-level signal). */
   onWorkspaceChanged?: (() => void) | undefined;
   /** A DI unit of the engine's scope tree changed state (debug feed). */

packages/kap-server/src/routes/sessions.ts

@@ -32,6 +32,7 @@ import {
   type SessionSummary,
 } from '@moonshot-ai/agent-core-v2';
 import { SessionMetaUpdated } from '@moonshot-ai/agent-core-v2/session/sessionMetadata/sessionMetaEvents';
+import { IGlobalSearchService } from '../search/searchService';
 import { ErrorCode } from '../protocol/error-codes';
 import { pageResponseSchema } from '../protocol/pagination';
 import { toProtocolMessage } from '../services/messages/messageProjection';
@@ -996,6 +997,7 @@ async function archiveSessionAction(ctx: SessionActionCtx): Promise<void> {
 async function deleteSessionAction(ctx: SessionActionCtx): Promise<void> {
   const { core, req, reply, id } = ctx;
   await core.accessor.get(ISessionManager).delete(id);
+  await core.accessor.get(IGlobalSearchService).deleteSession(id);
   requestLog(req)?.info({ session_id: id, action: 'delete' }, 'session action completed');
   reply.send(okEnvelope({ deleted: true }, req.id));
 }

packages/kap-server/src/search/indexCore.ts

@@ -438,6 +438,14 @@ export class SearchIndexCore {
     return { ...outcome, lockToken: this.lockToken, lifecycle: this.lifecycleState() };
   }
 
+  async deleteSession(sessionId: string): Promise<void> {
+    if (this.disposed) return;
+    await this.ensureOpen();
+    const db = this.db;
+    if (!db || db.readOnly || this.disposed) return;
+    await this.deleteSessionDocs(db, sessionId);
+  }
+
   private async runSync(sessions: readonly SyncSessionInput[]): Promise<CoreSyncPassOutcome> {
     if (this.disposed) return { noop: true, sessions: 0, documents: 0 };
     this.syncReplaced = false;

packages/kap-server/src/search/searchService.ts

@@ -101,6 +101,7 @@ export interface IGlobalSearchService {
   readonly _serviceBrand: undefined;
   search(query: GlobalSearchQuery): Promise<GlobalSearchPage>;
   reindex(): Promise<{ sessions: number; documents: number }>;
+  deleteSession(sessionId: string): Promise<void>;
   status(): Promise<{
     sessions: number;
     documents: number;
@@ -163,6 +164,7 @@ export interface SearchBackend {
   refresh(): Promise<unknown>;
   reindex(): Promise<unknown>;
   status(): Promise<CoreStatus>;
+  deleteSession(sessionId: string): Promise<void>;
   dispose(): Promise<void>;
 }
 
@@ -209,6 +211,10 @@ export class InlineSearchBackend implements SearchBackend {
     return this.core.status();
   }
 
+  deleteSession(sessionId: string): Promise<void> {
+    return this.core.deleteSession(sessionId);
+  }
+
   dispose(): Promise<void> {
     dropLiveLockToken(this.core.lockTokenView);
     return this.core.close();
@@ -262,6 +268,19 @@ export class GlobalSearchService implements IGlobalSearchService {
     this.liveSource = source;
   }
 
+  async deleteSession(sessionId: string): Promise<void> {
+    if (this.disposed) return;
+    this.summaries.delete(sessionId);
+    try {
+      await this.backend.deleteSession(sessionId);
+    } catch (error) {
+      this.log.warn('global search: failed to purge a deleted session from the index', {
+        sessionId,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
   private get indexDir(): string {
     return join(this.bootstrap.homeDir, INDEX_DIR_NAME);
   }

packages/kap-server/src/search/worker/entry.ts

@@ -94,6 +94,11 @@ async function dispatch(request: SearchWorkerCall): Promise<unknown> {
     }
     case 'status':
       return core.status();
+    case 'deleteSession':
+      await core.deleteSession(
+        (request.params as { sessionId: string }).sessionId,
+      );
+      return null;
     case 'close':
       return null;
   }

packages/kap-server/src/search/worker/host.ts

@@ -165,6 +165,10 @@ export class SearchWorkerHost {
     return this.call('status');
   }
 
+  async deleteSession(sessionId: string): Promise<void> {
+    await this.call('deleteSession', { sessionId });
+  }
+
   async killWorkerForTest(): Promise<void> {
     const worker = this.worker;
     if (worker === null) return;

packages/kap-server/src/search/worker/protocol.ts

@@ -23,6 +23,7 @@ export type SearchWorkerCall =
   | { readonly id: number; readonly v: number; readonly type: 'refresh' }
   | { readonly id: number; readonly v: number; readonly type: 'reindex' }
   | { readonly id: number; readonly v: number; readonly type: 'status' }
+  | { readonly id: number; readonly v: number; readonly type: 'deleteSession'; readonly params: { readonly sessionId: string } }
   | { readonly id: number; readonly v: number; readonly type: 'close' };
 
 export type SearchWorkerCallType = SearchWorkerCall['type'];
@@ -47,6 +48,7 @@ export interface SearchWorkerResultMap {
   readonly refresh: SearchWorkerOpenResult;
   readonly reindex: SearchWorkerOpenResult;
   readonly status: CoreStatus;
+  readonly deleteSession: null;
   readonly close: null;
 }
 

packages/kap-server/test/search/searchService.test.ts

@@ -298,6 +298,18 @@ describe('GlobalSearchService', () => {
     expect(injected.items).toEqual([]);
   });
 
+  it('purges a deleted session from the index immediately via deleteSession', async () => {
+    const s1 = summary('s1', '删除测试', T1);
+    await writeWire(home!, 's1', 'main', [userLine('即将被删除的苹果', T1)]);
+    const service = track(makeService(home!, staticIndex([s1])));
+    await service.reindex();
+    expect((await service.search({ query: '苹果' })).items.length).toBeGreaterThan(0);
+
+    await service.deleteSession('s1');
+
+    expect((await service.search({ query: '苹果' })).items).toEqual([]);
+  });
+
   it('hits session titles as title docs', async () => {
     const s1 = summary('s1', '季度总结报告', T1);
     await writeWire(home!, 's1', 'main', [userLine('随便说点什么', T1)]);