fix(kimi-code): flush wire journals before print-mode exit

.changeset/print-wire-flush-on-exit.md

@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": patch
+---
+
+Fix print mode (`kimi -p`) losing a failed turn's closing session records on error exit.

apps/kimi-code/src/cli/v2/run-v2-print.ts

@@ -30,6 +30,7 @@ import {
   IBootstrapService,
   IConfigService,
   IEventBus,
+  IEventDispatcher,
   IOAuthToolkit,
   ISessionIndex,
   ISessionManager,
@@ -196,6 +197,7 @@ export async function runV2Print(
   }
 
   let restorePermission = async (): Promise<void> => {};
+  let flushWires = async (): Promise<void> => {};
   let removeTerminationCleanup: (() => void) | undefined;
   let cleanupPromise: Promise<void> | undefined;
   let telemetryService: ITelemetryService | undefined;
@@ -205,6 +207,13 @@ export async function runV2Print(
       setCrashPhase('shutdown');
       try {
         await restorePermission();
+        // The turn's tail records (step.end / turn.ended / prompt.completed) are
+        // dispatched fire-and-forget and reach the journal only through the wire
+        // service's async persist queue. Without an explicit flush, a cleanup
+        // that returns fast (e.g. telemetry disabled) lets process.exit cut off
+        // that queue before the records land on disk. Best-effort: a persist
+        // failure was already reported where the append failed.
+        await raceWithTimeout(flushWires(), CLI_SHUTDOWN_TIMEOUT_MS).catch(() => {});
       } finally {
         if (telemetryService !== undefined) {
           await raceWithTimeout(telemetryService.shutdown(), CLI_SHUTDOWN_TIMEOUT_MS);
@@ -254,6 +263,7 @@ export async function runV2Print(
 
     const resolved = await resolveNativeSession(app, opts, workDir, defaultModel, stderr);
     restorePermission = resolved.restorePermission;
+    flushWires = () => flushSessionWires(resolved.session, resolved.agent);
 
     telemetryService.setContext({ session_id: resolved.session.id, model: resolved.telemetryModel });
     setTelemetryContext({ sessionId: resolved.session.id });
@@ -869,6 +879,26 @@ function countPendingBackgroundTasks(session: ISessionScopeHandle): number {
   return count;
 }
 
+/**
+ * Flush every session agent's wire journal. The main agent handle is included
+ * explicitly: `IAgentLifecycleService` skips `closing` agents, but a closing
+ * agent's already-dispatched tail records still deserve to land on disk.
+ */
+async function flushSessionWires(
+  session: ISessionScopeHandle,
+  mainAgent: IAgentScopeHandle,
+): Promise<void> {
+  const agentManager = session.accessor.get(IAgentLifecycleService);
+  const handles = new Set<IAgentScopeHandle>([mainAgent]);
+  for (const agent of agentManager.list()) {
+    const handle = agentManager.handleOf(agent.agentId);
+    if (handle !== undefined) handles.add(handle);
+  }
+  await Promise.all(
+    [...handles].map((handle) => handle.accessor.get(IEventDispatcher).flush()),
+  );
+}
+
 async function drainBackgroundTasks(
   session: ISessionScopeHandle,
   ceilingS: number | undefined,

apps/kimi-code/test/cli/v2-run-print.test.ts

@@ -17,6 +17,7 @@ import {
   IBootstrapService,
   IConfigService,
   IEventBus,
+  IEventDispatcher,
   IFileSystemStorageService,
   IOAuthToolkit,
   ISessionIndex,
@@ -186,6 +187,7 @@ function makeFakeHarness() {
     [IAgentTaskService, { list: vi.fn(() => []) }],
     [IAgentCronService, { getNextFireTime: vi.fn(() => null) }],
     [IAgentGoalService, goal],
+    [IEventDispatcher, { flush: vi.fn(async () => {}) }],
     [
       IAgentScopeContext,
       makeAgentScopeContext({ agentId: 'main', agentScope: 'agents/main' }),
@@ -613,4 +615,89 @@ describe('runV2Print', () => {
     expect(initOrder).toBeDefined();
     expect(reconcileOrder).toBeGreaterThan(initOrder!);
   });
+
+  it('flushes the wire journal before disposing the app', async () => {
+    const stdout = writer();
+    const stderr = writer();
+    const { app, agentServices } = makeFakeHarness();
+
+    mocks.bootstrap.mockReturnValue({ app });
+    mocks.ensureMainAgent.mockResolvedValue({ agentId: 'main', generation: 1 });
+
+    await runV2Print(opts() as never, '1.2.3-test', { stdout, stderr });
+
+    const dispatcher = agentServices.get(IEventDispatcher) as {
+      flush: ReturnType<typeof vi.fn>;
+    };
+    expect(dispatcher.flush).toHaveBeenCalled();
+    const flushOrder = dispatcher.flush.mock.invocationCallOrder[0];
+    const disposeOrder = app.dispose.mock.invocationCallOrder[0];
+    expect(flushOrder).toBeDefined();
+    expect(disposeOrder).toBeGreaterThan(flushOrder!);
+  });
+
+  it('flushes the wire journal when the turn fails', async () => {
+    const stdout = writer();
+    const stderr = writer();
+    const { app, agentServices } = makeFakeHarness();
+
+    const promptService = agentServices.get(IAgentPromptService) as {
+      enqueue: ReturnType<typeof vi.fn>;
+    };
+    promptService.enqueue.mockResolvedValueOnce({
+      launched: Promise.resolve({
+        id: 1,
+        result: Promise.resolve({
+          type: 'failed',
+          error: { code: 'provider.overloaded', message: 'llm request failed' },
+        }),
+      }),
+    });
+
+    mocks.bootstrap.mockReturnValue({ app });
+    mocks.ensureMainAgent.mockResolvedValue({ agentId: 'main', generation: 1 });
+
+    await expect(runV2Print(opts() as never, '1.2.3-test', { stdout, stderr })).rejects.toThrow(
+      'provider.overloaded: llm request failed',
+    );
+
+    const dispatcher = agentServices.get(IEventDispatcher) as {
+      flush: ReturnType<typeof vi.fn>;
+    };
+    expect(dispatcher.flush).toHaveBeenCalled();
+    const flushOrder = dispatcher.flush.mock.invocationCallOrder[0];
+    const disposeOrder = app.dispose.mock.invocationCallOrder[0];
+    expect(disposeOrder).toBeGreaterThan(flushOrder!);
+  });
+
+  it('does not let a wire flush failure mask the turn outcome', async () => {
+    const stdout = writer();
+    const stderr = writer();
+    const { app, agentServices } = makeFakeHarness();
+
+    const promptService = agentServices.get(IAgentPromptService) as {
+      enqueue: ReturnType<typeof vi.fn>;
+    };
+    promptService.enqueue.mockResolvedValueOnce({
+      launched: Promise.resolve({
+        id: 1,
+        result: Promise.resolve({
+          type: 'failed',
+          error: { code: 'provider.overloaded', message: 'llm request failed' },
+        }),
+      }),
+    });
+    const dispatcher = agentServices.get(IEventDispatcher) as {
+      flush: ReturnType<typeof vi.fn>;
+    };
+    dispatcher.flush.mockRejectedValueOnce(new Error('disk full'));
+
+    mocks.bootstrap.mockReturnValue({ app });
+    mocks.ensureMainAgent.mockResolvedValue({ agentId: 'main', generation: 1 });
+
+    await expect(runV2Print(opts() as never, '1.2.3-test', { stdout, stderr })).rejects.toThrow(
+      'provider.overloaded: llm request failed',
+    );
+    expect(app.dispose).toHaveBeenCalled();
+  });
 });