# How Kimi Code Performs Code Reviews: A Deep Dive into the Plan-Review Workflow

> Discover how Kimi Code executes code reviews using a unique plan-review workflow. Learn about its coordinated subsystems for generation, decision, and persistence.

- Repository: [Moonshot AI/kimi-code](https://github.com/MoonshotAI/kimi-code)
- Tags: deep-dive
- Published: 2026-08-15

---

**Kimi Code performs code reviews through a structured "plan-review" workflow that separates generation, decision, and persistence into three coordinated subsystems: plan mode with ExitPlanMode, the ACP approval engine, and transcript-based session handling.**

Kimi Code, the AI-powered coding assistant from MoonshotAI, implements automated code reviews through a deterministic, auditable architecture. Unlike simple diff-based tools, it uses a **plan-review workflow** that generates actionable plans, routes them through a permission layer, and persists the full interaction for replay and debugging. This article examines the source implementation in the `MoonshotAI/kimi-code` repository.

## The Three Core Subsystems

Kimi Code's review architecture cleanly separates concerns across three subsystems. This separation enables consistent behavior across CLI, VS Code, and web interfaces while maintaining full auditability.

### Plan Mode and ExitPlanMode Tool

The review process begins when a developer invokes the `review` skill—typically via `/review <file>`. This triggers **plan mode**, a special session state where Kimi Code generates a Markdown plan file describing proposed changes.

The critical transition happens in [`packages/agent-core/src/tools/builtin/planning/exit-plan-mode.ts`](https://github.com/MoonshotAI/kimi-code/blob/main/packages/agent-core/src/tools/builtin/planning/exit-plan-mode.ts). When editing completes, the `ExitPlanMode` tool executes and emits a `plan_review` display payload:

```typescript
// From packages/agent-core/src/tools/builtin/planning/exit-plan-mode.ts (line 110)
if (toolName === 'ExitPlanMode' || display?.kind === 'plan_review') {
  const payload: ToolInputDisplay = {
    kind: 'plan_review',
    plan: planMarkdown,              // rendered plan text
    options: [
      { label: 'Approve' },
      { label: 'Revise' }
    ],
  };
  // payload sent to approval subsystem
}

```

This payload contains the rendered plan and a default option set. The `kind: 'plan_review'` discriminator allows downstream components to recognize and handle review-specific displays.

### ACP Permission and Approval Engine

The `plan_review` payload passes to the **ACP (Approval Control Plane)** in [`packages/acp-server/src/approval.ts`](https://github.com/MoonshotAI/kimi-code/blob/main/packages/acp-server/src/approval.ts). Here, the system transforms the display into canonical permission options:

```typescript
// From packages/acp-server/src/approval.ts (lines 78-91)
if (req.display.kind === 'plan_review') {
  const options = [
    { id: 'plan_approve', label: 'Approve' },
    { id: 'plan_revise',  label: 'Revise' },
    // plugin-provided options appear as plan_opt_<i>
  ];
  return { ...req, options };
}

```

The ACP expands the simple display into structured option IDs that the permission service can interpret deterministically. This expansion happens at lines 78-91, where the server detects `display.kind === 'plan_review'` and builds the canonical option set.

### Session Transcript and Persistence

Every review interaction is recorded in the **transcript store**, enabling replay, search, and audit. The `plan_review` display is exposed via [`packages/kap-server/src/routes/transcript.ts`](https://github.com/MoonshotAI/kimi-code/blob/main/packages/kap-server/src/routes/transcript.ts) for TUI and web clients:

```typescript
// From packages/kap-server/src/routes/transcript.ts (lines 562-660)
app.get('/api/v1/transcript/:sessionId', async (req, res) => {
  const d = await transcript.getDisplay(req.params.sessionId);
  if (d.kind !== 'plan_review') return res.status(404).end();
  res.json({ plan: d.plan, options: d.options });
});

```

This endpoint (spanning lines 562-660 in the source) ensures the review state is accessible to any authorized client.

## End-to-End Review Flow

Understanding how Kimi Code performs code reviews requires tracing the complete execution path:

1. **Skill invocation**: User runs `/review src/app.ts`. The skill loader writes a temporary plan file and enters plan mode.

2. **Plan generation**: Kimi Code edits the plan through built-in tools or automated suggestions.

3. **ExitPlanMode execution**: The tool validates `display?.kind === 'plan_review'` and packages the payload.

4. **ACP processing**: `acp-server` detects the review kind, creates option IDs (`plan_approve`, `plan_revise`, `plan_opt_<i>`), and forwards to the UI.

5. **User decision**: The permission service interprets the choice:
   - `plan_approve` → finalize plan, exit plan mode
   - `plan_revise` → re-enter plan mode for editing
   - `plan_opt_<i>` → custom plugin handlers

6. **Transcript recording**: Events like `plan_submitted` and `plan_resolved` persist for later analysis.

## Permission Service Choice Handling

The permission service implements the state transition logic based on user selection:

```typescript
// Permission service interpretation
switch (choice.id) {
  case 'plan_approve':
    // finalize plan, exit plan mode
    session.exitPlanMode({ accepted: true });
    break;
  case 'plan_revise':
    // re-enter plan mode for further edits
    session.enterPlanMode({ revision: true });
    break;
  default:
    // handle custom option IDs from plugins
    pluginRegistry.handleCustomOption(choice.id);
}

```

This design allows **extensible review workflows**: plugins can inject additional options via the `plan_opt_<i>` naming convention without modifying core logic.

## Key Implementation Files

| File | Purpose |
|------|---------|
| [`packages/agent-core/src/tools/builtin/planning/exit-plan-mode.ts`](https://github.com/MoonshotAI/kimi-code/blob/main/packages/agent-core/src/tools/builtin/planning/exit-plan-mode.ts) | Creates `plan_review` display payload (core trigger) |
| [`packages/acp-server/src/approval.ts`](https://github.com/MoonshotAI/kimi-code/blob/main/packages/acp-server/src/approval.ts) | Transforms review requests into permission options |
| [`packages/kap-server/src/routes/transcript.ts`](https://github.com/MoonshotAI/kimi-code/blob/main/packages/kap-server/src/routes/transcript.ts) | Serves review displays via HTTP API |
| [`apps/kimi-code/src/tui/reverse-rpc/approval/adapter.ts`](https://github.com/MoonshotAI/kimi-code/blob/main/apps/kimi-code/src/tui/reverse-rpc/approval/adapter.ts) | TUI client-side review handling |
| [`packages/transcript/src/model/meta.ts`](https://github.com/MoonshotAI/kimi-code/blob/main/packages/transcript/src/model/meta.ts) | Defines `plan` metadata (reviewPath, version) |
| [`packages/node-sdk/test/session-skills.test.ts`](https://github.com/MoonshotAI/kimi-code/blob/main/packages/node-sdk/test/session-skills.test.ts) | End-to-end `review` skill tests |

## Summary

- **Kimi Code performs code reviews** through a three-layer architecture: plan generation, permission routing, and transcript persistence.

- The **ExitPlanMode tool** in `packages/agent-core` creates the canonical `plan_review` payload that triggers the workflow.

- The **ACP server** expands review displays into actionable permission options with stable IDs like `plan_approve` and `plan_revise`.

- Full **session recording** enables debugging, compliance, and replay across all supported front-ends.

- The design supports **plugin-extensible options** via the `plan_opt_<i>` namespace without core modifications.

## Frequently Asked Questions

### How does Kimi Code enter plan mode for a review?

The `review` skill triggers plan mode when invoked with `/review <file>`. The skill loader writes a temporary plan file and switches the session state, as tested in [`packages/node-sdk/test/session-skills.test.ts`](https://github.com/MoonshotAI/kimi-code/blob/main/packages/node-sdk/test/session-skills.test.ts). This initialization happens before any ExitPlanMode tool execution.

### What happens when a user selects "Revise" in a code review?

The permission service receives `choice.id === 'plan_revise'` and re-enters plan mode, allowing further edits to the plan file. This creates a loop where the user can iteratively refine proposals before final approval. The round-trip is recorded in the transcript with `plan_submitted` and subsequent events.

### Can custom review options be added to Kimi Code's workflow?

Yes. Plugins can inject additional options that appear as `plan_opt_<i>` IDs in the ACP expansion. The permission service's `default` case handler routes these to registered plugins, enabling domain-specific review workflows without modifying [`packages/acp-server/src/approval.ts`](https://github.com/MoonshotAI/kimi-code/blob/main/packages/acp-server/src/approval.ts).

### Where is the review state stored for audit purposes?

The transcript subsystem in `packages/transcript` persists all review interactions. Plan metadata including `reviewPath` and version is defined in [`packages/transcript/src/model/meta.ts`](https://github.com/MoonshotAI/kimi-code/blob/main/packages/transcript/src/model/meta.ts), while [`packages/kap-server/src/routes/transcript.ts`](https://github.com/MoonshotAI/kimi-code/blob/main/packages/kap-server/src/routes/transcript.ts) exposes this data via the `/api/v1/transcript` endpoint.