@lythos/skill-arena 0.17.10 → 0.18.0

package/README.md

@@ -16,20 +16,20 @@
 ```bash
 bun add -d @lythos/skill-arena
 # or use directly
-bunx @lythos/skill-arena@0.17.10 <command>
+bunx @lythos/skill-arena@0.18.0 <command>
 ```
 
 ## Quick Start
 
 ```bash
 # single — test one deck (most common)
-bunx @lythos/skill-arena@0.17.10 single \
+bunx @lythos/skill-arena@0.18.0 single \
   --deck ./examples/decks/scout.toml \
   --brief "Generate auth flow diagram" \
   --out ./output
 
 # single with explicit player
-bunx @lythos/skill-arena@0.17.10 single \
+bunx @lythos/skill-arena@0.18.0 single \
   --deck ./examples/decks/scout.toml \
   --brief "Generate auth flow diagram" \
   --player kimi \
@@ -37,10 +37,10 @@ bunx @lythos/skill-arena@0.17.10 single \
 
 # cross-deck vs — compare two decks (agent-orchestrated)
 # Create arena.toml declaring sides with different decks, then:
-bunx @lythos/skill-arena@0.17.10 vs --config ./arena.toml
+bunx @lythos/skill-arena@0.18.0 vs --config ./arena.toml
 
 # cross-player vs — compare kimi vs codex (CLI only)
-bunx @lythos/skill-arena@0.17.10 vs --config ./arena.toml --player kimi
+bunx @lythos/skill-arena@0.18.0 vs --config ./arena.toml --player kimi
 ```
 
 **What happens**: Agent creates isolated `/tmp` workdir per side, `deck link` skills, spawns parallel subagents, collects artifacts, judge scores outputs. Parent deck restored after.
@@ -50,14 +50,14 @@ bunx @lythos/skill-arena@0.17.10 vs --config ./arena.toml --player kimi
 ### `single` — one deck, one task
 
 ```bash
-bunx @lythos/skill-arena@0.17.10 single \
+bunx @lythos/skill-arena@0.18.0 single \
   --deck ./deck.toml \
   --brief "Produce a .docx report with radar chart" \
   --timeout 600000 \
   --out ./output
 
 # with explicit player
-bunx @lythos/skill-arena@0.17.10 single \
+bunx @lythos/skill-arena@0.18.0 single \
   --deck ./deck.toml \
   --brief "Produce a .docx report with radar chart" \
   --player kimi \
@@ -67,14 +67,14 @@ bunx @lythos/skill-arena@0.17.10 single \
 ### `vs` — multi-deck comparison
 
 ```bash
-bunx @lythos/skill-arena@0.17.10 vs --config ./arena.toml
-bunx @lythos/skill-arena@0.17.10 vs --config ./arena.toml --dry-run
+bunx @lythos/skill-arena@0.18.0 vs --config ./arena.toml
+bunx @lythos/skill-arena@0.18.0 vs --config ./arena.toml --dry-run
 ```
 
 ### `prepare-workdir` — isolate + link skills (agent-orchestrated)
 
 ```bash
-bunx @lythos/skill-arena@0.17.10 prepare-workdir \
+bunx @lythos/skill-arena@0.18.0 prepare-workdir \
   --deck ./skill-deck.toml \
   --out /tmp/arena-side-a \
   --brief "task description"
@@ -85,7 +85,7 @@ Creates `/tmp`-isolated workdir with deck copied, AGENTS.md written, and `deck l
 ### `archive` — collect agent outputs (agent-orchestrated)
 
 ```bash
-bunx @lythos/skill-arena@0.17.10 archive \
+bunx @lythos/skill-arena@0.18.0 archive \
   --from /tmp/arena-side-a \
   --to ./playground/output \
   --sides side-a
@@ -96,7 +96,7 @@ Copies agent artifacts from workdir(s) to output, skipping internal files (`.cla
 ### `viz` — render results (WIP — HTML report generation pending)
 
 ```bash
-bunx @lythos/skill-arena@0.17.10 viz runs/arena-<id>/
+bunx @lythos/skill-arena@0.18.0 viz runs/arena-<id>/
 ```
 
 ## Parameters

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lythos/skill-arena",
-  "version": "0.17.10",
+  "version": "0.18.0",
   "description": "Skill Arena — benchmark skill effectiveness with controlled-variable comparison",
   "keywords": [
     "ai-agent",
@@ -42,15 +42,15 @@
     "bun": ">=1.0.0"
   },
   "dependencies": {
-    "@lythos/cold-pool": "^0.17.10",
-    "@lythos/infra": "^0.17.10",
-    "@lythos/test-utils": "^0.17.10",
+    "@lythos/cold-pool": "^0.18.0",
+    "@lythos/infra": "^0.18.0",
+    "@lythos/test-utils": "^0.18.0",
     "zod": "^3.24.0",
     "zod-to-json-schema": "^3.25.2"
   },
   "optionalDependencies": {
-    "@lythos/agent-adapter-claude-sdk": "^0.17.10",
-    "@lythos/agent-adapter-deepseek-serve": "^0.17.10",
-    "@lythos/agent-adapter-codex": "^0.17.10"
+    "@lythos/agent-adapter-claude-sdk": "^0.18.0",
+    "@lythos/agent-adapter-deepseek-serve": "^0.18.0",
+    "@lythos/agent-adapter-codex": "^0.18.0"
   }
 }

package/src/cli.test.ts

@@ -74,10 +74,14 @@ describe('main', () => {
 })
 
 describe('singleRun', () => {
+  // Validation-order tests pin --player to force external mode: since
+  // TASK-20260828141622671, mode resolution (host handoff vs no-player error)
+  // precedes flag validation, and the host env of the machine running the
+  // tests would otherwise change which error fires (CI has no host markers).
   it('errors when --deck is missing', async () => {
     const { io, logs, errors } = mockIO()
     const exitCode = await catchExitAsync(async () => {
-      await main(['single', '--brief', 'test task'], io)
+      await main(['single', '--brief', 'test task', '--player', 'kimi'], io)
     })
     expect(exitCode).toBe(1)
     expect(errors.length).toBeGreaterThan(0)
@@ -88,7 +92,7 @@ describe('singleRun', () => {
   it('errors when both --task and --brief are missing', async () => {
     const { io, logs, errors } = mockIO()
     const exitCode = await catchExitAsync(async () => {
-      await main(['single', '--deck', './some-deck.toml'], io)
+      await main(['single', '--deck', './some-deck.toml', '--player', 'kimi'], io)
     })
     expect(exitCode).toBe(1)
     expect(errors.length).toBeGreaterThan(0)
@@ -99,7 +103,7 @@ describe('singleRun', () => {
   it('errors when --brief is empty string', async () => {
     const { io, logs, errors } = mockIO()
     const exitCode = await catchExitAsync(async () => {
-      await main(['single', '--deck', './some-deck.toml', '--brief', ''], io)
+      await main(['single', '--deck', './some-deck.toml', '--brief', '', '--player', 'kimi'], io)
     })
     expect(exitCode).toBe(1)
     expect(errors.length).toBeGreaterThan(0)

package/src/cli.ts

@@ -7,6 +7,7 @@ import { formatPlanOutput, type ArenaResult, buildArenaPrompt } from './runner'
 import { parseArenaToml, buildExecutionPlan } from './arena-toml'
 import { buildArchiveSidePlan, buildCopyPlan, buildPreparePlan, parseDeckSkills } from './preflight'
 import { checkSkillExistence, formatSkillWarnings, resolveColdPoolDir } from './preflight'
+import { resolveSingleMode } from './host'
 
 // ─── ArenaCliIO interface (injected for testability) ───────────────────────
 
@@ -111,6 +112,10 @@ Commands:
   vs       Compare decks via arena.toml (declarative, Pareto-optimal)
   viz      Visualize a completed arena run (HTML + chart)
 
+Modes (single):
+  Inside an agent session  → host-handoff guidance (default; no external spawn)
+  Anywhere else            → pass --player <name> (kimi|kimi-code|codex|claude|deepseek)
+
 Examples:
   lythoskill-arena single --brief "find and research" --deck ./decks/scout.toml
   lythoskill-arena single --brief "find and research" --deck https://raw.githubusercontent.com/lythos-labs/lythoskill/main/examples/decks/scout.toml
@@ -154,6 +159,24 @@ async function singleRun(args: string[], io: ArenaCliIO) {
     else if (args[i] === '--timeout') opts.timeout = args[++i]
   }
 
+  if (opts.player !== undefined && !opts.player) {
+    error(`❌ --player requires a non-empty name (e.g. --player kimi).
+   Player setup: skills/lythoskill-arena/references/player-setup.md`)
+    exit(1)
+  }
+
+  // Mode resolution comes FIRST (ADR-20260828004129143): with no --player, the
+  // relevant failure/guidance is about execution mode, not about flags.
+  const mode = resolveSingleMode(opts.player, process.env)
+  if (mode.mode === 'no-player') {
+    error(`❌ No --player given and no agent host detected.
+   arena single runs in one of two modes:
+     1. Inside an agent session → host-handoff is the default (the host orchestrates the run).
+     2. Anywhere else → pass --player <name> to spawn an external CLI.
+   Player setup: skills/lythoskill-arena/references/player-setup.md`)
+    exit(1)
+  }
+
   if (!opts.deck) {
     error(`❌ --deck <path|url> is required.
    --deck accepts local paths and http/https URLs (auto-fetched).
@@ -218,6 +241,30 @@ async function singleRun(args: string[], io: ArenaCliIO) {
     }
   }
 
+  // Host-handoff: print HATEOAS guidance and return BEFORE any fetch/spawn —
+  // no-spawn is structural (adapter dynamic imports below are never reached,
+  // no agent-output-* dir is ever created).
+  if (mode.mode === 'handoff') {
+    // Fail fast on a bogus LOCAL deck path — the host agent would discover it
+    // later otherwise. URLs are passed through (fetch validation is the host's).
+    if (!/^https?:\/\//.test(opts.deck!) && !existsSync(resolve(opts.deck!))) {
+      error(`❌ Deck file not found: ${resolve(opts.deck!)}
+   Fix the path (or pass a URL) before handing off — the host agent needs a real deck.`)
+      exit(1)
+    }
+    log(`🤝 Host-handoff mode — agent session detected (${mode.host.host}${mode.host.marker ? ` via ${mode.host.marker}` : ''})
+
+   What: arena single is running inside an agent session and hands this run back to the host.
+   Why:  host-orchestrated runs are the default (ADR-20260828004129143) — the host agent
+         spawns subagents per deck and judges outputs itself; no external player CLI needed.
+   How:  1. In a subagent workdir, link the deck: bunx @lythos/skill-deck link --deck ${opts.deck}
+         2. Spawn a subagent with that workdir and this ${opts.task ? `task: ${opts.task}` : `brief: ${opts.brief}`}
+         3. Judge the subagent output(s) against the brief.
+   Docs: skills/lythoskill-arena/references/arena-runtime.md
+   Override: pass --player <name> to force an external CLI run.`)
+    return
+  }
+
   const { existsSync: deckExists, writeFileSync: deckWrite } = await import('node:fs')
   let deckPath: string
   if (opts.deck.startsWith('http://') || opts.deck.startsWith('https://')) {
@@ -271,10 +318,12 @@ async function singleRun(args: string[], io: ArenaCliIO) {
   try { await import('@lythos/agent-adapter-claude-sdk') } catch { /* package not installed */ }
   try { await import('@lythos/agent-adapter-deepseek-serve') } catch { /* package not installed */ }
   try { await import('@lythos/agent-adapter-codex') } catch { /* package not installed */ }
-  const { resolvePlayer } = await import('./player')
+  const { resolvePlayer, playerAliasNote } = await import('./player')
 
-  const player = resolvePlayer(opts.player ?? 'kimi')
+  const player = resolvePlayer(mode.player)
   const agent = useAgent(player)
+  const aliasNote = playerAliasNote(mode.player)
+  if (aliasNote) log(`ℹ️  ${aliasNote}`)
   const outDir = opts.out ? resolve(opts.out) : join(process.cwd(), `agent-output-${new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19)}`)
   mkdirSync(outDir, { recursive: true })
 

package/src/host.test.ts

@@ -0,0 +1,174 @@
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test'
+import { mkdtempSync, readdirSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join, resolve } from 'node:path'
+import { detectHost, resolveSingleMode } from './host'
+import { main, type ArenaCliIO } from './cli'
+
+// ─── Helpers ───────────────────────────────────────────────────────────────
+
+const HOST_VARS = ['CLAUDECODE', 'CLAUDE_CODE_SSE_PORT'] as const
+
+// Tests run inside real agent sessions (kimi-code sets CLAUDE_CODE_SSE_PORT) —
+// every test pins the host markers explicitly instead of inheriting them.
+function withEnv<T>(vars: Record<string, string | undefined>, fn: () => T): T {
+  const saved = new Map<string, string | undefined>()
+  for (const k of HOST_VARS) { saved.set(k, process.env[k]); delete process.env[k] }
+  for (const [k, v] of Object.entries(vars)) {
+    if (v === undefined) delete process.env[k]
+    else process.env[k] = v
+  }
+  try { return fn() } finally {
+    for (const [k, v] of saved.entries()) {
+      if (v === undefined) delete process.env[k]
+      else process.env[k] = v
+    }
+  }
+}
+
+async function catchExitAsync(fn: () => Promise<void>): Promise<number | undefined> {
+  let exitCode: number | undefined
+  try { await fn() } catch (e: any) {
+    if (!String(e).includes('EXIT:')) throw e
+    const m = String(e).match(/EXIT:(\d+)/)
+    if (m) exitCode = parseInt(m[1], 10)
+  }
+  return exitCode
+}
+
+function mockIO() {
+  const logs: string[] = []
+  const errors: string[] = []
+  const io: Required<ArenaCliIO> = {
+    log: (msg: string) => logs.push(msg),
+    error: (msg: string) => errors.push(msg),
+    warn: () => {},
+    exit: (code: number) => { throw new Error(`EXIT:${code}`) },
+  }
+  return { io, logs, errors }
+}
+
+const NO_HOST = { CLAUDECODE: undefined, CLAUDE_CODE_SSE_PORT: undefined } as const
+const QUICK_START_DECK = resolve(import.meta.dir, '..', '..', '..', 'examples', 'decks', 'quick-start.toml')
+
+// ─── detectHost ─────────────────────────────────────────────────────────────
+
+describe('detectHost', () => {
+  it('detects Claude Code via CLAUDECODE', () => {
+    const d = detectHost({ CLAUDECODE: '1' } as NodeJS.ProcessEnv)
+    expect(d.detected).toBe(true)
+    expect(d.host).toBe('Claude Code')
+    expect(d.marker).toBe('CLAUDECODE')
+  })
+
+  it('detects claude-code forks (incl. kimi-code) via CLAUDE_CODE_SSE_PORT as unidentified', () => {
+    const d = detectHost({ CLAUDE_CODE_SSE_PORT: '12345' } as NodeJS.ProcessEnv)
+    expect(d.detected).toBe(true)
+    expect(d.host).toBe('agent host (unidentified)')
+    expect(d.marker).toBe('CLAUDE_CODE_SSE_PORT')
+  })
+
+  it('prefers the specific CLAUDECODE marker when both are set', () => {
+    const d = detectHost({ CLAUDECODE: '1', CLAUDE_CODE_SSE_PORT: '1' } as NodeJS.ProcessEnv)
+    expect(d.host).toBe('Claude Code')
+  })
+
+  it('reports no host when no markers are present', () => {
+    const d = detectHost({} as NodeJS.ProcessEnv)
+    expect(d.detected).toBe(false)
+    expect(d.host).toBe('none')
+  })
+})
+
+// ─── resolveSingleMode: 4-cell env/flag matrix ─────────────────────────────
+
+describe('resolveSingleMode (4-cell matrix)', () => {
+  it('host detected + --player given → external (explicit player always wins)', () => {
+    const m = resolveSingleMode('codex', { CLAUDE_CODE_SSE_PORT: '1' } as NodeJS.ProcessEnv)
+    expect(m).toEqual({ mode: 'external', player: 'codex' })
+  })
+
+  it('no host + --player given → external', () => {
+    const m = resolveSingleMode('kimi', {} as NodeJS.ProcessEnv)
+    expect(m).toEqual({ mode: 'external', player: 'kimi' })
+  })
+
+  it('host detected + no --player → handoff', () => {
+    const m = resolveSingleMode(undefined, { CLAUDECODE: '1' } as NodeJS.ProcessEnv)
+    expect(m.mode).toBe('handoff')
+    if (m.mode === 'handoff') expect(m.host.host).toBe('Claude Code')
+  })
+
+  it('no host + no --player → no-player (loud error upstream)', () => {
+    const m = resolveSingleMode(undefined, {} as NodeJS.ProcessEnv)
+    expect(m.mode).toBe('no-player')
+  })
+})
+
+// ─── CLI integration ────────────────────────────────────────────────────────
+
+describe('singleRun host-handoff integration', () => {
+  let workCwd: string
+  let origCwd: string
+
+  beforeEach(() => {
+    origCwd = process.cwd()
+    workCwd = mkdtempSync(join(tmpdir(), 'arena-handoff-'))
+    process.chdir(workCwd)
+  })
+  afterEach(() => { process.chdir(origCwd) })
+
+  it('host detected, no --player → prints handoff guidance, spawns nothing, exits 0', async () => {
+    await withEnv({ CLAUDE_CODE_SSE_PORT: '1' }, async () => {
+      const { io, logs, errors } = mockIO()
+      const exitCode = await catchExitAsync(async () => {
+        await main(['single', '--deck', QUICK_START_DECK, '--brief', 'test'], io)
+      })
+      // clean return (no exit throw) = exit 0
+      expect(exitCode).toBeUndefined()
+      expect(errors.length).toBe(0)
+      const out = logs.join('\n')
+      expect(out).toContain('Host-handoff mode')
+      expect(out).toContain('arena-runtime.md')
+      expect(out).toContain(QUICK_START_DECK)
+      // Structural no-spawn: branch returns before outDir creation
+      expect(readdirSync(workCwd).filter(e => e.startsWith('agent-output-'))).toEqual([])
+    })
+  })
+
+  it('no host, no --player → loud error pointing at player-setup.md, exit 1', async () => {
+    await withEnv(NO_HOST, async () => {
+      const { io, errors } = mockIO()
+      const exitCode = await catchExitAsync(async () => {
+        await main(['single', '--brief', 'x'], io)
+      })
+      expect(exitCode).toBe(1)
+      expect(errors[0]).toContain('player-setup.md')
+      expect(errors[0]).toContain('--player')
+    })
+  })
+
+  it('handoff mode fails fast on a bogus LOCAL deck path (no guidance, exit 1)', async () => {
+    await withEnv({ CLAUDE_CODE_SSE_PORT: '1' }, async () => {
+      const { io, logs, errors } = mockIO()
+      const exitCode = await catchExitAsync(async () => {
+        await main(['single', '--deck', './no-such-deck.toml', '--brief', 'x'], io)
+      })
+      expect(exitCode).toBe(1)
+      expect(errors[0]).toContain('Deck file not found')
+      expect(logs.join('\n')).not.toContain('Host-handoff mode')
+    })
+  })
+
+  it('empty --player "" is rejected loudly, never falls into handoff', async () => {
+    await withEnv({ CLAUDE_CODE_SSE_PORT: '1' }, async () => {
+      const { io, logs, errors } = mockIO()
+      const exitCode = await catchExitAsync(async () => {
+        await main(['single', '--deck', QUICK_START_DECK, '--brief', 'x', '--player', ''], io)
+      })
+      expect(exitCode).toBe(1)
+      expect(errors[0]).toContain('--player requires a non-empty name')
+      expect(logs.join('\n')).not.toContain('Host-handoff mode')
+    })
+  })
+})

package/src/host.ts

@@ -0,0 +1,52 @@
+// Host detection + single-mode resolution for arena host-handoff mode.
+// Implements ADR-20260828004129143 (Option B): inside an agent session,
+// `arena single` without --player hands off to the host agent instead of
+// shelling out to a hardcoded external player.
+//
+// Pure + injectable: always pass `env` explicitly in tests.
+
+export interface HostDetection {
+  detected: boolean
+  /** Display name — a known host, or a generic label when the fork is unidentified. */
+  host: string
+  /** The env var that fired (for diagnostics). Undefined when not detected. */
+  marker?: string
+}
+
+// Known agent-host env markers, most specific first.
+// Ground truth (verified live 2026-08-28): kimi-code exports NO KIMI* variable;
+// it is a claude-code fork and only inherits CLAUDE_CODE_SSE_PORT. Claude Code
+// proper sets CLAUDECODE=1 (plus CLAUDE_CODE_SSE_PORT). So SSE_PORT alone means
+// "an agent host we cannot name" — and the handoff guidance is host-agnostic
+// by design, so identification never blocks the handoff.
+const KNOWN_MARKERS: ReadonlyArray<{ env: string; host: string }> = [
+  { env: 'CLAUDECODE', host: 'Claude Code' },
+  { env: 'CLAUDE_CODE_SSE_PORT', host: 'agent host (unidentified)' },
+]
+
+export function detectHost(env: NodeJS.ProcessEnv = process.env): HostDetection {
+  for (const { env: key, host } of KNOWN_MARKERS) {
+    if (env[key]) return { detected: true, host, marker: key }
+  }
+  return { detected: false, host: 'none' }
+}
+
+export type SingleMode =
+  | { mode: 'external'; player: string }
+  | { mode: 'handoff'; host: HostDetection }
+  | { mode: 'no-player' }
+
+/**
+ * Default execution-mode resolution for `arena single`:
+ *   explicit --player        → external spawn (current behavior, unchanged)
+ *   host detected, no player → host-handoff guidance
+ *   no host, no player       → loud error (callers point at player-setup.md)
+ */
+export function resolveSingleMode(
+  player: string | undefined,
+  env: NodeJS.ProcessEnv = process.env,
+): SingleMode {
+  if (player) return { mode: 'external', player }
+  const host = detectHost(env)
+  return host.detected ? { mode: 'handoff', host } : { mode: 'no-player' }
+}

package/src/player.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'bun:test'
-import { resolvePlayer, resolveSides, groupBySide, totalRuns } from './player'
+import { resolvePlayer, playerAliasNote, resolveSides, groupBySide, totalRuns } from './player'
 import { parseArenaToml } from './arena-toml'
 
 const toml = parseArenaToml(`
@@ -32,6 +32,22 @@ describe('resolvePlayer', () => {
     expect(resolvePlayer('kimi')).toBe('kimi')
   })
 
+  it('maps kimi-code → kimi (upstream rename alias)', () => {
+    expect(resolvePlayer('kimi-code')).toBe('kimi')
+    expect(resolvePlayer('Kimi-Code')).toBe('kimi')
+  })
+
+  it('playerAliasNote reports alias mappings only', () => {
+    expect(playerAliasNote('kimi-code')).toContain("'kimi-code' = 'kimi'")
+    expect(playerAliasNote('kimi')).toBeNull()
+    expect(playerAliasNote('expert-architect')).toBeNull()
+  })
+
+  it('playerAliasNote covers the other built-in mappings too (claude family)', () => {
+    expect(playerAliasNote('claude')).toContain("'claude' = 'claude-sdk'")
+    expect(playerAliasNote('claude-cli')).toContain("'claude-cli' = 'claude'")
+  })
+
   it('passes through unknown player names', () => {
     expect(resolvePlayer('expert-architect')).toBe('expert-architect')
   })

package/src/player.ts

@@ -16,12 +16,26 @@ const BUILTIN_PLAYERS: Record<string, string> = {
   'claude-code': 'claude-sdk',
   'claude-cli': 'claude',           // legacy CLI spawn — explicitly opt-in
   'kimi': 'kimi',
+  'kimi-code': 'kimi',              // renamed upstream — users guess the new name (ADR-20260828004129233)
   'deepseek': 'deepseek',
   'codex': 'codex',
   'cursor': 'cursor',
   'gemini': 'gemini',
 }
 
+/**
+ * One-line note when a player reference resolves through a built-in mapping
+ * (e.g. 'kimi-code' → 'kimi'), else null. Pure — callers decide whether to print.
+ */
+export function playerAliasNote(name: string): string | null {
+  const normalized = name.toLowerCase().trim()
+  const resolved = BUILTIN_PLAYERS[normalized]
+  if (resolved && resolved !== normalized) {
+    return `player '${normalized}' = '${resolved}' (built-in alias)`
+  }
+  return null
+}
+
 /**
  * Resolve a player reference to its platform identifier.
  * - Built-in names (claude, kimi, cursor) map directly