kimi-code/packages/agent-core/test/harness/skill-session.test.ts

import { mkdtemp, mkdir, readFile, realpath, rm, writeFile } from 'node:fs/promises';
import { tmpdir } from 'node:os';
import { join } from 'pathe';
import { setTimeout as delay } from 'node:timers/promises';

import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';

import {
  createRPC,
  KimiCore,
  type ApprovalResponse,
  type CoreAPI,
  type CoreRPC,
  type Event,
  type SDKAPI,
  type TelemetryClient,
} from '../../src';
import {
  recordingContextTelemetry,
  type TelemetryContextRecord,
} from '../fixtures/telemetry';

// agent-core renders skill paths with forward slashes (pathe). Mirror that in
// path assertions so they hold on Windows, where node:fs.realpath produces
// backslashes.
const toPosix = (p: string): string => p.replaceAll('\\', '/');

describe('HarnessAPI session skills', () => {
  let tmp: string;
  let homeDir: string;
  let workDir: string;

  beforeEach(async () => {
    tmp = await mkdtemp(join(tmpdir(), 'kimi-core-skills-'));
    homeDir = join(tmp, 'home');
    workDir = join(tmp, 'work');
    await mkdir(workDir, { recursive: true });
  });

  afterEach(async () => {
    await rm(tmp, { recursive: true, force: true });
    vi.unstubAllEnvs();
  });

  it('lists session skills without exposing content', async () => {
    await writeSkill('phase-one-review', [
      '---',
      'name: phase-one-review',
      'description: Review code',
      'disable_model_invocation: true',
      '---',
      '',
      'Review the requested file.',
    ]);
    const { rpc } = await createTestRpc();
    const created = await rpc.createSession({ id: 'ses_skill_list', workDir });

    const skills = await rpc.listSkills({ sessionId: created.id });
    const listed = skills.find((skill) => skill.name === 'phase-one-review');

    expect(listed).toMatchObject({
      name: 'phase-one-review',
      description: 'Review code',
      source: 'project',
      disableModelInvocation: true,
    });
    expect(listed?.path.endsWith('/.kimi-code/skills/phase-one-review/SKILL.md')).toBe(true);
    expect(JSON.stringify(skills)).not.toContain('Review the requested file.');
  });

  it('uses the first body line when a flat skill description is missing', async () => {
    await writeFlatSkill('body-described', [
      '',
      '  First useful line that describes it.  ',
      '',
      'Full instructions stay private.',
    ]);
    const { rpc } = await createTestRpc();
    const created = await rpc.createSession({ id: 'ses_skill_description_fallback', workDir });

    const skills = await rpc.listSkills({ sessionId: created.id });
    const listed = skills.find((skill) => skill.name === 'body-described');

    expect(listed).toMatchObject({
      name: 'body-described',
      description: 'First useful line that describes it.',
      source: 'project',
    });
    expect(JSON.stringify(skills)).not.toContain('Full instructions stay private.');
  });

  it('lists bundled built-in skills by default', async () => {
    const { rpc } = await createTestRpc();
    const created = await rpc.createSession({ id: 'ses_builtin_skill_list', workDir });

    const skills = await rpc.listSkills({ sessionId: created.id });
    const mcpConfig = skills.find((skill) => skill.name === 'mcp-config');
    const importer = skills.find((skill) => skill.name === 'import-from-cc-codex');

    expect(mcpConfig).toMatchObject({
      name: 'mcp-config',
      description: 'Configure MCP servers and handle MCP OAuth login.',
      source: 'builtin',
    });
    expect(mcpConfig?.path).toBe('builtin://mcp-config');
    expect(importer).toMatchObject({
      name: 'import-from-cc-codex',
      description: 'Import Claude Code and Codex instructions, skills, and MCP settings into Kimi Code.',
      source: 'builtin',
      disableModelInvocation: true,
    });
    expect(importer?.path).toBe('builtin://import-from-cc-codex');
    expect(JSON.stringify(skills)).not.toContain('Your tool list contains one synthetic tool');
    expect(JSON.stringify(skills)).not.toContain('Do not migrate Claude custom commands');
  });

  it('resolves user brand skills from the kimi home, not the OS home', async () => {
    const processHome = join(tmp, 'process-home');
    vi.stubEnv('HOME', processHome);
    await writeLegacyUserSkill(processHome, 'real-home-only', 'Real home skill');
    await writeBrandUserSkill(homeDir, 'sandbox-only', 'Sandbox skill');
    const { rpc } = await createTestRpc();
    const created = await rpc.createSession({ id: 'ses_skill_sandbox_home', workDir });

    const names = new Set((await rpc.listSkills({ sessionId: created.id })).map((skill) => skill.name));

    expect(names.has('real-home-only')).toBe(false);
    expect(names.has('sandbox-only')).toBe(true);
  });

  it('resolves user brand skills from KIMI_CODE_HOME when no explicit home is set', async () => {
    const processHome = join(tmp, 'env-process-home');
    vi.stubEnv('HOME', processHome);
    vi.stubEnv('KIMI_CODE_HOME', homeDir);
    await writeLegacyUserSkill(processHome, 'env-real-home-only', 'Env real home skill');
    await writeBrandUserSkill(homeDir, 'env-sandbox-only', 'Env sandbox skill');
    const { rpc } = await createTestRpc({});
    const created = await rpc.createSession({ id: 'ses_skill_env_home', workDir });

    const names = new Set((await rpc.listSkills({ sessionId: created.id })).map((skill) => skill.name));

    expect(names.has('env-real-home-only')).toBe(false);
    expect(names.has('env-sandbox-only')).toBe(true);
  });

  it('activates an inline skill through core and records display origin metadata', async () => {
    await writeSkill('phase-one-review', [
      '---',
      'name: phase-one-review',
      'description: Review code',
      'disable_model_invocation: true',
      '---',
      '',
      'Review the requested file.',
    ]);
    const telemetryRecords: TelemetryContextRecord[] = [];
    const { core, events, rpc } = await createTestRpc({
      homeDir,
      telemetry: recordingContextTelemetry(telemetryRecords),
    });
    const created = await rpc.createSession({ id: 'ses_skill_activate', workDir });

    await rpc.activateSkill({
      sessionId: created.id,
      agentId: 'main',
      name: 'phase-one-review',
      args: 'src/app.ts',
    });
    await waitForEvent(events, (event) => event.type === 'skill.activated');
    await core.sessions.get(created.id)?.flushMetadata();

    const skillEvent = events.find((event) => event.type === 'skill.activated');
    expect(skillEvent).toMatchObject({
      type: 'skill.activated',
      agentId: 'main',
      sessionId: created.id,
      skillName: 'phase-one-review',
      skillArgs: 'src/app.ts',
      trigger: 'user-slash',
      skillSource: 'project',
    });
    expect(JSON.stringify(skillEvent)).not.toContain('Review the requested file.');
    expect(telemetryRecords).toContainEqual({
      event: 'skill_invoked',
      sessionId: created.id,
      properties: {
        skill_name: 'phase-one-review',
        trigger: 'user-slash',
      },
    });
    expect(telemetryRecords.some((record) => record.event === 'flow_invoked')).toBe(false);

    const skillIndex = events.findIndex((event) => event.type === 'skill.activated');
    const turnIndex = events.findIndex((event) => event.type === 'turn.started');
    expect(skillIndex).toBeGreaterThanOrEqual(0);
    expect(turnIndex).toBeGreaterThan(skillIndex);

    const records = await readMainWire(created.sessionDir);
    const prompt = records.find((record) => record['type'] === 'turn.prompt');
    const userMessage = records.find((record) => record['type'] === 'context.append_message');
    const skillDir = toPosix(await realpath(join(workDir, '.kimi-code', 'skills', 'phase-one-review')));
    const expectedPrompt = [
      'User activated the skill "phase-one-review". Follow the loaded skill instructions.',
      '',
      `<kimi-skill-loaded name="phase-one-review" trigger="user-slash" source="project" dir="${skillDir}" args="src/app.ts">`,
      'Review the requested file.',
      '',
      'ARGUMENTS: src/app.ts',
      '</kimi-skill-loaded>',
    ].join('\n');
    expect(prompt).toMatchObject({
      type: 'turn.prompt',
      input: [{ type: 'text', text: expectedPrompt }],
      origin: {
        kind: 'skill_activation',
        skillName: 'phase-one-review',
        skillArgs: 'src/app.ts',
        trigger: 'user-slash',
        skillSource: 'project',
      },
    });
    expect(userMessage).toMatchObject({
      type: 'context.append_message',
      message: {
        role: 'user',
        content: [{ type: 'text', text: expectedPrompt }],
        origin: {
          kind: 'skill_activation',
          skillName: 'phase-one-review',
          skillArgs: 'src/app.ts',
          trigger: 'user-slash',
          skillSource: 'project',
        },
      },
    });
    expect(
      (prompt as { origin?: { activationId?: string } } | undefined)?.origin?.activationId,
    ).toBe((skillEvent as { activationId?: string } | undefined)?.activationId);
    expect((skillEvent as { activationId?: string } | undefined)?.activationId).toBe(
      (userMessage as { message?: { origin?: { activationId?: string } } } | undefined)?.message
        ?.origin?.activationId,
    );

    const context = await rpc.getContext({ sessionId: created.id, agentId: 'main' });
    expect(context.history.at(0)).toMatchObject({
      role: 'user',
      content: [{ type: 'text', text: expectedPrompt }],
      toolCalls: [],
      origin: {
        kind: 'skill_activation',
        skillName: 'phase-one-review',
        skillArgs: 'src/app.ts',
        trigger: 'user-slash',
        skillSource: 'project',
      },
    });
    expect(expectedPrompt).not.toContain('<system-reminder>');
    expect(expectedPrompt).toContain('trigger="user-slash"');
    expect(expectedPrompt).toContain('User activated the skill "phase-one-review".');
  });

  it('expands skill body placeholders on user slash activation', async () => {
    await writeSkill('templated-review', [
      '---',
      'name: templated-review',
      'description: Review with template variables',
      'arguments:',
      '  - target',
      '  - mode',
      '---',
      '',
      'Target: $target',
      'Mode: $mode',
      'Raw: $ARGUMENTS',
      'Dir: ${KIMI_SKILL_DIR}',
      'Session: ${KIMI_SESSION_ID}',
    ]);
    const { core, rpc } = await createTestRpc({ homeDir });
    const created = await rpc.createSession({ id: 'ses_skill_template', workDir });

    await rpc.activateSkill({
      sessionId: created.id,
      agentId: 'main',
      name: 'templated-review',
      args: '"src/app.ts" careful',
    });
    await core.sessions.get(created.id)?.flushMetadata();

    const records = await readMainWire(created.sessionDir);
    const prompt = records.find((record) => record['type'] === 'turn.prompt');
    const skillDir = toPosix(await realpath(join(workDir, '.kimi-code', 'skills', 'templated-review')));
    const expectedPrompt = [
      'User activated the skill "templated-review". Follow the loaded skill instructions.',
      '',
      `<kimi-skill-loaded name="templated-review" trigger="user-slash" source="project" dir="${skillDir}" args="&quot;src/app.ts&quot; careful">`,
      'Target: src/app.ts',
      'Mode: careful',
      'Raw: "src/app.ts" careful',
      `Dir: ${skillDir}`,
      'Session: ses_skill_template',
      '</kimi-skill-loaded>',
    ].join('\n');
    expect(prompt).toMatchObject({
      type: 'turn.prompt',
      input: [{ type: 'text', text: expectedPrompt }],
      origin: {
        kind: 'skill_activation',
        skillName: 'templated-review',
        skillArgs: '"src/app.ts" careful',
      },
    });
    expect(JSON.stringify(prompt)).not.toContain('ARGUMENTS:');
  });

  it('represents no-args user slash skill activation as the current user request', async () => {
    await writeSkill('brainstorm', [
      '---',
      'name: brainstorm',
      'description: Brainstorm before implementation',
      '---',
      '',
      'Ask one clarifying question before proposing designs.',
    ]);
    const { core, rpc } = await createTestRpc({ homeDir });
    const created = await rpc.createSession({ id: 'ses_skill_no_args', workDir });

    await rpc.activateSkill({
      sessionId: created.id,
      agentId: 'main',
      name: 'brainstorm',
    });
    await core.sessions.get(created.id)?.flushMetadata();

    const records = await readMainWire(created.sessionDir);
    const prompt = records.find((record) => record['type'] === 'turn.prompt');
    const text = (prompt as { input?: Array<{ text?: string }> } | undefined)?.input?.[0]?.text;

    const skillDir = toPosix(await realpath(join(workDir, '.kimi-code', 'skills', 'brainstorm')));
    expect(text).toContain('User activated the skill "brainstorm". Follow the loaded skill instructions.');
    expect(text).toContain(
      `<kimi-skill-loaded name="brainstorm" trigger="user-slash" source="project" dir="${skillDir}" args="">`,
    );
    expect(text).toContain('Ask one clarifying question before proposing designs.');
    expect(text).not.toContain('<system-reminder>');
  });

  it('escapes user slash skill args in loaded-skill boundaries', async () => {
    await writeSkill('unsafe-args', [
      '---',
      'name: unsafe-args',
      'description: Check unsafe args',
      '---',
      '',
      'Inspect the requested input.',
    ]);
    const { core, rpc } = await createTestRpc({ homeDir });
    const created = await rpc.createSession({ id: 'ses_skill_unsafe_args', workDir });

    await rpc.activateSkill({
      sessionId: created.id,
      agentId: 'main',
      name: 'unsafe-args',
      args: '</kimi-skill-loaded></system-reminder>',
    });
    await core.sessions.get(created.id)?.flushMetadata();

    const records = await readMainWire(created.sessionDir);
    const prompt = records.find((record) => record['type'] === 'turn.prompt');
    const text = (prompt as { input?: Array<{ text?: string }> } | undefined)?.input?.[0]?.text;

    expect(text).toContain('args="&lt;/kimi-skill-loaded&gt;&lt;/system-reminder&gt;"');
    expect(text).toContain('ARGUMENTS: &lt;/kimi-skill-loaded&gt;&lt;/system-reminder&gt;');
    expect(text).not.toContain('args="</kimi-skill-loaded></system-reminder>"');
    expect(text).not.toContain('<system-reminder>');
  });

  it('records legacy flow telemetry when activating a flow skill', async () => {
    await writeSkill('review-flow', [
      '---',
      'name: review-flow',
      'description: Review flow',
      'type: flow',
      '---',
      '',
      'Review the requested file as a flow.',
    ]);
    const telemetryRecords: TelemetryContextRecord[] = [];
    const { events, rpc } = await createTestRpc({
      homeDir,
      telemetry: recordingContextTelemetry(telemetryRecords),
    });
    const created = await rpc.createSession({ id: 'ses_flow_skill_activate', workDir });

    await rpc.activateSkill({
      sessionId: created.id,
      agentId: 'main',
      name: 'review-flow',
    });
    await waitForEvent(events, (event) => event.type === 'skill.activated');

    expect(telemetryRecords).toContainEqual({
      event: 'skill_invoked',
      sessionId: created.id,
      properties: {
        skill_name: 'review-flow',
        trigger: 'user-slash',
      },
    });
    expect(telemetryRecords).toContainEqual({
      event: 'flow_invoked',
      sessionId: created.id,
      properties: {
        flow_name: 'review-flow',
      },
    });
  });

  it('does not re-emit skill activation live events on resume', async () => {
    await writeSkill('phase-one-review', [
      '---',
      'name: phase-one-review',
      'description: Review code',
      '---',
      '',
      'Review the requested file.',
    ]);
    const first = await createTestRpc();
    const created = await first.rpc.createSession({ id: 'ses_skill_resume', workDir });
    await first.rpc.activateSkill({
      sessionId: created.id,
      agentId: 'main',
      name: 'phase-one-review',
      args: 'src/app.ts',
    });
    await waitForEvent(first.events, (event) => event.type === 'skill.activated');
    await first.core.sessions.get(created.id)?.flushMetadata();

    const second = await createTestRpc();
    const resumed = await second.rpc.resumeSession({ sessionId: created.id });

    expect(second.events.some((event) => event.type === 'skill.activated')).toBe(false);
    const skillDir = toPosix(await realpath(join(workDir, '.kimi-code', 'skills', 'phase-one-review')));
    const context = await second.rpc.getContext({ sessionId: created.id, agentId: 'main' });
    expect(context.history).toMatchObject([
      {
        role: 'user',
        content: [
          {
            type: 'text',
            text: [
              'User activated the skill "phase-one-review". Follow the loaded skill instructions.',
              '',
              `<kimi-skill-loaded name="phase-one-review" trigger="user-slash" source="project" dir="${skillDir}" args="src/app.ts">`,
              'Review the requested file.',
              '',
              'ARGUMENTS: src/app.ts',
              '</kimi-skill-loaded>',
            ].join('\n'),
          },
        ],
        origin: {
          kind: 'skill_activation',
          skillName: 'phase-one-review',
          skillArgs: 'src/app.ts',
          trigger: 'user-slash',
          skillSource: 'project',
        },
      },
    ]);
    const replay = resumed.agents['main']?.replay ?? [];
    expect(replay).toContainEqual(
      expect.objectContaining({
        type: 'message',
        message: expect.objectContaining({
          origin: expect.objectContaining({
            kind: 'skill_activation',
            skillName: 'phase-one-review',
          }),
        }),
      }),
    );
    expect(replay).not.toContainEqual(
      expect.objectContaining({
        type: 'turn.prompt',
        origin: expect.objectContaining({ kind: 'skill_activation' }),
      }),
    );
  });

  it('keeps the skill directory in the resumed conversation context so bundled resources stay locatable', async () => {
    // A skill that ships a helper script but does NOT embed ${KIMI_SKILL_DIR}
    // in its body. The only way the agent can learn where the script lives is
    // the `dir` attribute on the loaded block — and it must survive a resume.
    await writeSkill('bundled-tool', [
      '---',
      'name: bundled-tool',
      'description: A skill with a bundled script',
      '---',
      '',
      'Run the bundled helper script to do the work.',
    ]);
    const scriptDir = join(workDir, '.kimi-code', 'skills', 'bundled-tool', 'scripts');
    await mkdir(scriptDir, { recursive: true });
    await writeFile(join(scriptDir, 'run.sh'), '#!/bin/sh\necho hi\n');

    const first = await createTestRpc();
    const created = await first.rpc.createSession({ id: 'ses_skill_resource_resume', workDir });
    await first.rpc.activateSkill({
      sessionId: created.id,
      agentId: 'main',
      name: 'bundled-tool',
    });
    await waitForEvent(first.events, (event) => event.type === 'skill.activated');
    await first.core.sessions.get(created.id)?.flushMetadata();

    // Resume in a completely fresh runtime — nothing in memory, the context is
    // rebuilt from disk exactly as the model would see it on the next turn.
    const second = await createTestRpc();
    await second.rpc.resumeSession({ sessionId: created.id });
    const context = await second.rpc.getContext({ sessionId: created.id, agentId: 'main' });

    const skillDir = toPosix(await realpath(join(workDir, '.kimi-code', 'skills', 'bundled-tool')));
    const skillMessage = context.history.find(
      (entry) =>
        entry.origin?.kind === 'skill_activation' &&
        (entry.origin as { skillName?: string }).skillName === 'bundled-tool',
    );
    expect(skillMessage).toBeDefined();
    const text = (skillMessage?.content?.[0] as { text?: string } | undefined)?.text ?? '';

    // The directory is present in the resumed context...
    expect(text).toContain(`dir="${skillDir}"`);
    // ...and it is the directory that actually holds the bundled script, so an
    // agent reading the context can resolve the resource by relative path.
    expect(join(skillDir, 'scripts', 'run.sh')).toBe(
      toPosix(await realpath(join(scriptDir, 'run.sh'))),
    );
    // Guard the regression: the path is surfaced by the wrapper, not because
    // the skill body happened to mention it.
    expect(text).toContain('Run the bundled helper script to do the work.');
  });

  it('registers builtin mcp-config skill, hides it from the model, and activates it via slash', async () => {
    const { core, events, rpc } = await createTestRpc();
    const created = await rpc.createSession({ id: 'ses_skill_builtin', workDir });

    const skills = await rpc.listSkills({ sessionId: created.id });
    const builtin = skills.find((skill) => skill.name === 'mcp-config');
    expect(builtin).toMatchObject({
      name: 'mcp-config',
      source: 'builtin',
      disableModelInvocation: true,
    });

    const session = core.sessions.get(created.id);
    expect(session).toBeDefined();
    const invocable = session!.skills.listInvocableSkills();
    expect(invocable.some((skill) => skill.name === 'mcp-config')).toBe(false);
    expect(session!.skills.getModelSkillListing()).not.toContain('mcp-config');

    await rpc.activateSkill({
      sessionId: created.id,
      agentId: 'main',
      name: 'mcp-config',
    });
    const activated = await waitForEvent(events, (event) => event.type === 'skill.activated');
    expect(activated).toMatchObject({
      type: 'skill.activated',
      skillName: 'mcp-config',
      trigger: 'user-slash',
      skillSource: 'builtin',
    });

    await session?.flushMetadata();
    const records = await readMainWire(created.sessionDir);
    const prompt = records.find((record) => record['type'] === 'turn.prompt');
    expect(prompt).toMatchObject({
      type: 'turn.prompt',
      origin: {
        kind: 'skill_activation',
        skillName: 'mcp-config',
        skillSource: 'builtin',
      },
    });
    const promptInput = (prompt as { input?: ReadonlyArray<{ text?: string }> } | undefined)?.input;
    expect(promptInput?.[0]?.text).toContain('Interactive MCP server configuration');
    expect(promptInput?.[0]?.text).toContain('AskUserQuestion');
  });

  it('lets a user-supplied skill override the builtin of the same name', async () => {
    await writeSkill('mcp-config', [
      '---',
      'name: mcp-config',
      'description: Project-local override',
      '---',
      '',
      'Local override body.',
    ]);
    const { rpc } = await createTestRpc();
    const created = await rpc.createSession({ id: 'ses_skill_builtin_override', workDir });

    const skills = await rpc.listSkills({ sessionId: created.id });
    const listed = skills.find((skill) => skill.name === 'mcp-config');
    expect(listed).toMatchObject({
      name: 'mcp-config',
      source: 'project',
      description: 'Project-local override',
    });
  });

  it('rejects missing and non-inline skills with structured errors', async () => {
    const { core, rpc } = await createTestRpc();
    const created = await rpc.createSession({ id: 'ses_skill_errors', workDir });

    await expect(
      rpc.activateSkill({ sessionId: created.id, agentId: 'main', name: 'missing' }),
    ).rejects.toMatchObject({
      name: 'KimiError',
      code: 'skill.not_found',
    });

    const session = core.sessions.get(created.id);
    session?.skills.registerBuiltinSkill({
      name: 'forked',
      description: 'Forked skill',
      path: '/skills/forked/SKILL.md',
      dir: '/skills/forked',
      content: 'fork body',
      metadata: { type: 'fork' },
      source: 'builtin',
    });

    await expect(
      rpc.activateSkill({ sessionId: created.id, agentId: 'main', name: 'forked' }),
    ).rejects.toMatchObject({
      name: 'KimiError',
      code: 'skill.type_unsupported',
    });
  });

  async function writeSkill(name: string, lines: readonly string[]): Promise<void> {
    const dir = join(workDir, '.kimi-code', 'skills', name);
    await mkdir(dir, { recursive: true });
    await writeFile(join(dir, 'SKILL.md'), lines.join('\n'));
  }

  async function writeLegacyUserSkill(
    userHomeDir: string,
    name: string,
    description: string,
  ): Promise<void> {
    await writeSkillFile(join(userHomeDir, '.kimi-code', 'skills', name), name, description);
  }

  async function writeBrandUserSkill(
    brandHomeDir: string,
    name: string,
    description: string,
  ): Promise<void> {
    await writeSkillFile(join(brandHomeDir, 'skills', name), name, description);
  }

  async function writeSkillFile(dir: string, name: string, description: string): Promise<void> {
    await mkdir(dir, { recursive: true });
    await writeFile(
      join(dir, 'SKILL.md'),
      ['---', `name: ${name}`, `description: ${description}`, '---', '', `${description}.`].join(
        '\n',
      ),
    );
  }

  async function writeFlatSkill(name: string, lines: readonly string[]): Promise<void> {
    const dir = join(workDir, '.kimi-code', 'skills');
    await mkdir(dir, { recursive: true });
    await writeFile(join(dir, `${name}.md`), lines.join('\n'));
  }

  async function createTestRpc(options?: {
    readonly homeDir?: string;
    readonly telemetry?: TelemetryClient;
  }): Promise<{
    core: KimiCore;
    events: Event[];
    rpc: CoreRPC;
  }> {
    const [coreRpc, sdkRpc] = createRPC<CoreAPI, SDKAPI>();
    const events: Event[] = [];
    const configuredHomeDir = options === undefined ? homeDir : options.homeDir;
    const core = new KimiCore(
      coreRpc,
      { homeDir: configuredHomeDir, telemetry: options?.telemetry },
    );
    const rpc = await sdkRpc({
      emitEvent: (event) => {
        events.push(event);
      },
      requestApproval: vi.fn(async (): Promise<ApprovalResponse> => ({ decision: 'rejected' })),
      requestQuestion: vi.fn(async () => null),
      toolCall: vi.fn(async () => ({ output: '' })),
    });
    return { core, events, rpc };
  }
});

async function waitForEvent(
  events: readonly Event[],
  predicate: (event: Event) => boolean,
): Promise<Event> {
  const deadline = Date.now() + 1_000;
  while (Date.now() < deadline) {
    const event = events.find(predicate);
    if (event !== undefined) return event;
    await delay(10);
  }
  throw new Error('Timed out waiting for event');
}

async function readMainWire(sessionDir: string): Promise<Array<Record<string, unknown>>> {
  const raw = await readFile(join(sessionDir, 'agents', 'main', 'wire.jsonl'), 'utf-8');
  return raw
    .split('\n')
    .filter((line) => line.length > 0)
    .map((line) => JSON.parse(line) as Record<string, unknown>);
}