@lythos/skill-arena 0.14.0 → 0.14.2

package/README.md

@@ -16,7 +16,7 @@
 ```bash
 bun add -d @lythos/skill-arena
 # or use directly
-bunx @lythos/skill-arena@0.14.0 <command>
+bunx @lythos/skill-arena@0.14.2 <command>
 ```
 
 ## Quick Start
@@ -65,6 +65,42 @@ bunx @lythos/skill-arena@latest scaffold \
   --decks "./decks/minimal.toml,./decks/rich.toml"
 ```
 
+### `prepare-workdir` — isolate + link skills (agent-orchestrated)
+
+```bash
+bunx @lythos/skill-arena@latest prepare-workdir \
+  --deck ./skill-deck.toml \
+  --out /tmp/arena-side-a \
+  --brief "task description"
+
+# Plan-first: review before executing
+bunx @lythos/skill-arena@latest prepare-workdir \
+  --deck ./skill-deck.toml \
+  --out /tmp/arena-side-a \
+  --brief "task" \
+  --dry-run
+```
+
+Creates `/tmp`-isolated workdir with deck copied, AGENTS.md written, and `deck link` run. `--dry-run` prints the plan (skills, workdir path, link needed) without creating anything.
+
+### `archive` — collect agent outputs (agent-orchestrated)
+
+```bash
+bunx @lythos/skill-arena@latest archive \
+  --from /tmp/arena-side-a \
+  --to ./playground/output \
+  --sides side-a
+
+# Plan-first: review what would be copied
+bunx @lythos/skill-arena@latest archive \
+  --from /tmp/arena-side-a \
+  --to ./playground/output \
+  --sides side-a \
+  --dry-run
+```
+
+Copies agent artifacts from workdir(s) to output, skipping internal files (`.claude`, `skill-deck.toml`, `skill-deck.lock`, `AGENTS.md`). Single-side archives fall back to workdir root when the named side subdirectory doesn't exist. `--dry-run` shows the per-side plan before copying.
+
 ### `viz` — render results
 
 ```bash
@@ -79,9 +115,12 @@ bunx @lythos/skill-arena@latest viz runs/arena-<id>/
 | `--deck <path\|url>` | single | Deck file (URL auto-fetched) |
 | `--player <name>` | single, vs | Only for cross-player: kimi\|codex\|deepseek\|claude |
 | `--timeout <ms>` | single | Subagent timeout (300000–600000 for complex tasks) |
-| `--out <dir>` | single, vs | Output directory |
+| `--from <dir>` | archive | Source workdir |
+| `--to <dir>` | archive | Output directory |
+| `--sides <names>` | archive | Comma-separated side names (default: `.`) |
+| `--out <dir>` | single, vs, prepare-workdir | Output / workdir directory |
 | `--config <path>` | vs | arena.toml |
-| `--dry-run` | vs | Print plan without execution |
+| `--dry-run` | vs, prepare-workdir, archive | Print plan without execution |
 
 ## Prerequisites (cross-player only)
 

package/package.json

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

package/src/cli.ts

@@ -5,7 +5,7 @@ import { homedir, tmpdir } from 'node:os'
 import { ZodError } from 'zod'
 import { formatPlanOutput, type ArenaResult, buildArenaPrompt } from './runner'
 import { parseArenaToml, buildExecutionPlan } from './arena-toml'
-import { buildCopyPlan, parseDeckSkills } from './preflight'
+import { buildArchiveSidePlan, buildCopyPlan, buildPreparePlan, parseDeckSkills } from './preflight'
 import { checkSkillExistence, formatSkillWarnings, resolveColdPoolDir } from './preflight'
 
 // ─── fetchWithProxy (infra dependency, no package boundary) ─────────────────
@@ -441,10 +441,12 @@ async function vizRun(args: string[]) {
 
 async function prepareWorkdir(args: string[]) {
   const opts: Record<string, string | undefined> = {}
+  let dryRun = false
   for (let i = 0; i < args.length; i++) {
     if (args[i] === '--deck' || args[i] === '-d') opts.deck = args[++i]
     else if (args[i] === '--out' || args[i] === '-o') opts.out = args[++i]
     else if (args[i] === '--brief' || args[i] === '-b') opts.brief = args[++i]
+    else if (args[i] === '--dry-run') dryRun = true
   }
 
   if (!opts.deck) {
@@ -462,39 +464,36 @@ async function prepareWorkdir(args: string[]) {
   const workDir = opts.out
     ? resolve(opts.out)
     : join(tmpdir(), `arena-${Date.now()}`)
-  mkdirSync(workDir, { recursive: true })
-
-  // Copy deck into workdir
-  writeFileSync(join(workDir, 'skill-deck.toml'), readFileSync(deckPath, 'utf-8'))
+  const deckContent = readFileSync(deckPath, 'utf-8')
+
+  // ── Plan (pure computation — what WOULD be created) ────────────────────
+  const plan = buildPreparePlan({
+    deckPath,
+    deckContent,
+    workDir,
+    skillCount: 0, // computed inside from deckContent
+    brief: opts.brief,
+  })
 
-  // Write AGENTS.md (same contract as CLI singleRun)
-  writeFileSync(join(workDir, 'AGENTS.md'), [
-    '# Arena Test Environment',
-    '**Mode**: agent-orchestrated cell',
-    '',
-    '## Setup Order (why this sequence)',
-    '1. `skill-deck.toml` copied here → declares which skills you can use',
-    '2. `deck link` runs → cold pool skills become visible in `.claude/skills/`',
-    '3. Skill existence checked → warns if any declared skill is missing from cold pool',
-    '4. `AGENTS.md` written last → confirms setup succeeded before agent starts',
-    'If setup fails mid-sequence, the workdir is incomplete and nothing runs.',
-    '',
-    '## How This Works',
-    '- Write ALL output files to this directory (CWD).',
-    '- Use available skills — check `ls .claude/skills/`.',
-    '',
-    '## Output Contract',
-    '- MANDATORY: `decision-log.jsonl` — one JSON line per decision:',
-    '  `{"t":<seconds>,"phase":"setup|content|design|output","decision":"...","reason":"..."}`',
-  ].join('\n'))
+  console.log('📋 Prepare plan:')
+  console.log(`   deck:    ${plan.deckPath}`)
+  console.log(`   workdir: ${plan.workDir}`)
+  console.log(`   skills:  ${plan.skills.length} declared (${plan.skills.map(s => s.name).join(', ') || 'none'})`)
+  console.log(`   link:    ${plan.hasSkills ? 'Bun.spawn deck link' : 'skip (no skills)'}`)
+  console.log(`   AGENTS.md: write (${plan.agentsMd.split('\n').length} lines)`)
+  if (opts.brief) console.log(`   brief:   ${opts.brief!.slice(0, 60)}...`)
+
+  if (dryRun) {
+    console.log(`\n🏁 Dry-run complete (no files created). Remove --dry-run to execute.`)
+    return
+  }
 
-  // Parse deck for link + checks
-  const deckRaw = readFileSync(join(workDir, 'skill-deck.toml'), 'utf-8')
-  let deckParsed: Record<string, any> = {}
-  try { deckParsed = Bun.TOML.parse(deckRaw) as Record<string, any> } catch {}
-  const hasSkills = parseDeckSkills(deckParsed).length > 0
+  // ── Execute: create workdir ──────────────────────────────────────────
+  mkdirSync(workDir, { recursive: true })
+  writeFileSync(join(workDir, 'skill-deck.toml'), deckContent)
+  writeFileSync(join(workDir, 'AGENTS.md'), plan.agentsMd)
 
-  if (hasSkills) {
+  if (plan.hasSkills) {
     const { existsSync: es2 } = await import('node:fs')
     const localDeckCli = join(import.meta.dir, '..', '..', 'lythoskill-deck', 'src', 'cli.ts')
     const linkCmd = es2(localDeckCli)
@@ -517,9 +516,8 @@ async function prepareWorkdir(args: string[]) {
   // Skill existence check
   try {
     const coldPoolDefault = join(homedir(), '.agents', 'skill-repos')
-    const coldPoolDir = resolveColdPoolDir(deckParsed?.deck?.cold_pool, homedir(), coldPoolDefault)
-    const skills = parseDeckSkills(deckParsed)
-    const checks = checkSkillExistence(skills, coldPoolDir, existsSync)
+    const coldPoolDir = resolveColdPoolDir(Bun.TOML.parse(deckContent)?.deck?.cold_pool, homedir(), coldPoolDefault)
+    const checks = checkSkillExistence(plan.skills, coldPoolDir, existsSync)
     for (const warning of formatSkillWarnings(checks)) {
       console.warn(`⚠️  ${warning}`)
     }
@@ -538,11 +536,13 @@ async function prepareWorkdir(args: string[]) {
 
 async function archiveRun(args: string[]) {
   const opts: Record<string, string | undefined> = {}
+  let dryRun = false
   for (let i = 0; i < args.length; i++) {
     if (args[i] === '--from' || args[i] === '-f') opts.from = args[++i]
     else if (args[i] === '--to' || args[i] === '-o') opts.to = args[++i]
     else if (args[i] === '--sides') opts.sides = args[++i]
     else if (args[i] === '--report') opts.report = args[++i]
+    else if (args[i] === '--dry-run') dryRun = true
   }
 
   if (!opts.from || !opts.to) {
@@ -553,40 +553,57 @@ async function archiveRun(args: string[]) {
 
   const fromDir = resolve(opts.from)
   const outDir = resolve(opts.to)
+
+  const sides = opts.sides ? opts.sides.split(',') : ['.']
+  const plan = buildArchiveSidePlan(fromDir, sides, existsSync)
+
+  // ── Plan output (always shown, also serves as dry-run) ──────────────────
+  console.log('📋 Archive plan:')
+  for (const pe of plan) {
+    if (!pe.found) {
+      console.log(`   ⚠️  ${pe.side}: not found (${pe.sourceDir}) — will skip`)
+    } else if (pe.sourceDir === fromDir && pe.side !== '.') {
+      console.log(`   ${pe.side}: ${pe.sourceDir} (fallback → root) → ${join(outDir, pe.side)}`)
+    } else {
+      console.log(`   ${pe.side}: ${pe.sourceDir} → ${join(outDir, pe.side)}`)
+    }
+  }
+  if (dryRun) {
+    console.log(`\n🏁 Dry-run complete (no files copied). Remove --dry-run to execute.`)
+    return
+  }
+
+  // ── Execute: copy files ───────────────────────────────────────────────
   mkdirSync(outDir, { recursive: true })
 
-  // Copy report if provided
   if (opts.report && existsSync(resolve(opts.report))) {
-    const { cpSync } = await import('node:fs')
-    cpSync(resolve(opts.report), join(outDir, 'report.md'))
+    const { cpSync: cpR } = await import('node:fs')
+    cpR(resolve(opts.report), join(outDir, 'report.md'))
     console.log(`📄 report.md → ${outDir}/report.md`)
   }
 
-  // Copy per-side outputs (same skipSet as CLI singleRun)
   const { cpSync, readdirSync } = await import('node:fs')
   const skipSet = new Set(['.claude', 'skill-deck.toml', 'skill-deck.lock', 'AGENTS.md'])
 
-  const sides = opts.sides ? opts.sides.split(',') : ['.']
-  for (const side of sides) {
-    const sideWorkDir = side === '.' ? fromDir : join(fromDir, side)
-    if (!existsSync(sideWorkDir)) {
-      console.warn(`⚠️  Side workdir not found: ${sideWorkDir}`)
+  for (const planEntry of plan) {
+    if (!planEntry.found) {
+      console.warn(`⚠️  Side workdir not found: ${planEntry.sourceDir}`)
       continue
     }
 
-    const sideOutDir = join(outDir, side)
+    const sideOutDir = join(outDir, planEntry.side)
     mkdirSync(sideOutDir, { recursive: true })
 
-    const entries = readdirSync(sideWorkDir, { withFileTypes: true })
+    const entries = readdirSync(planEntry.sourceDir, { withFileTypes: true })
     for (const entry of entries) {
       if (skipSet.has(entry.name)) continue
-      const src = join(sideWorkDir, entry.name)
+      const src = join(planEntry.sourceDir, entry.name)
       const dest = join(sideOutDir, entry.name)
       try {
         cpSync(src, dest, { recursive: entry.isDirectory() })
-        console.log(`   ${side}/${entry.name} → ${dest}`)
+        console.log(`   ${planEntry.side}/${entry.name} → ${dest}`)
       } catch (e) {
-        console.warn(`⚠️  Failed to copy ${side}/${entry.name}: ${e instanceof Error ? e.message : e}`)
+        console.warn(`⚠️  Failed to copy ${planEntry.side}/${entry.name}: ${e instanceof Error ? e.message : e}`)
       }
     }
   }

package/src/preflight.test.ts

@@ -393,3 +393,192 @@ describe('formatSkillWarnings', () => {
     expect(formatSkillWarnings(checks)[0]).toContain('[transient]')
   })
 })
+
+
+// ═══════════════════════════════════════════════════════════════════════════
+// buildArchiveSidePlan
+// ═══════════════════════════════════════════════════════════════════════════
+
+
+// ═══════════════════════════════════════════════════════════════════════════
+// buildArchiveSidePlan
+// ═══════════════════════════════════════════════════════════════════════════
+
+import { buildArchiveSidePlan } from './preflight'
+import { join as pathJoin } from 'node:path'
+
+const TMP = '/tmp/arena-test'
+
+describe('buildArchiveSidePlan', () => {
+
+  test('default: sides=["."] maps to fromDir', () => {
+    const plan = buildArchiveSidePlan(TMP, ['.'], _p => true)
+    expect(plan).toEqual([
+      { side: '.', sourceDir: TMP, found: true },
+    ])
+  })
+
+  test('single side, subdirectory exists → source = fromDir/side', () => {
+    const exists = (p: string) => p === pathJoin(TMP, 'side-a')
+    const plan = buildArchiveSidePlan(TMP, ['side-a'], exists)
+    expect(plan).toEqual([
+      { side: 'side-a', sourceDir: pathJoin(TMP, 'side-a'), found: true },
+    ])
+  })
+
+  test('single side, subdirectory MISSING → fallback to fromDir root', () => {
+    const plan = buildArchiveSidePlan(TMP, ['side-a'], _p => false)
+    expect(plan).toEqual([
+      { side: 'side-a', sourceDir: TMP, found: true },
+    ])
+  })
+
+  test('multi side, all subdirectories exist', () => {
+    const exists = (p: string) =>
+      p === pathJoin(TMP, 'side-a') || p === pathJoin(TMP, 'side-b')
+    const plan = buildArchiveSidePlan(TMP, ['side-a', 'side-b'], exists)
+    expect(plan).toEqual([
+      { side: 'side-a', sourceDir: pathJoin(TMP, 'side-a'), found: true },
+      { side: 'side-b', sourceDir: pathJoin(TMP, 'side-b'), found: true },
+    ])
+  })
+
+  test('multi side, one missing → found=false (caller handles warn+skip)', () => {
+    const exists = (p: string) => p === pathJoin(TMP, 'side-a')
+    const plan = buildArchiveSidePlan(TMP, ['side-a', 'side-b'], exists)
+    expect(plan).toEqual([
+      { side: 'side-a', sourceDir: pathJoin(TMP, 'side-a'), found: true },
+      { side: 'side-b', sourceDir: pathJoin(TMP, 'side-b'), found: false },
+    ])
+  })
+
+  test('"." side does NOT trigger fallback when missing (found=false)', () => {
+    const plan = buildArchiveSidePlan(TMP, ['.'], _p => false)
+    expect(plan).toEqual([
+      { side: '.', sourceDir: TMP, found: false },
+    ])
+  })
+
+  test('empty sides array → empty plan', () => {
+    const plan = buildArchiveSidePlan(TMP, [], _p => true)
+    expect(plan).toEqual([])
+  })
+
+  test('three sides, middle missing', () => {
+    const exists = (p: string) =>
+      p === pathJoin(TMP, 'side-a') || p === pathJoin(TMP, 'side-c')
+    const plan = buildArchiveSidePlan(TMP, ['side-a', 'side-b', 'side-c'], exists)
+    expect(plan).toEqual([
+      { side: 'side-a', sourceDir: pathJoin(TMP, 'side-a'), found: true },
+      { side: 'side-b', sourceDir: pathJoin(TMP, 'side-b'), found: false },
+      { side: 'side-c', sourceDir: pathJoin(TMP, 'side-c'), found: true },
+    ])
+  })
+})
+
+// ═══════════════════════════════════════════════════════════════════════════
+// buildPreparePlan
+// ═══════════════════════════════════════════════════════════════════════════
+
+import { buildPreparePlan } from './preflight'
+
+const DECK_ONE_SKILL = `
+[deck]
+max_cards = 10
+cold_pool = "~/.agents/skill-repos"
+
+[tool.skills.pdf]
+path = "github.com/anthropics/skills/skills/pdf"
+`
+
+const DECK_EMPTY = `
+[deck]
+max_cards = 5
+`
+
+const DECK_TWO_SKILLS = `
+[deck]
+max_cards = 10
+
+[innate.skills.deck]
+path = "github.com/lythos-labs/lythoskill/skills/lythoskill-deck"
+
+[tool.skills.pdf]
+path = "github.com/anthropics/skills/skills/pdf"
+`
+
+describe('buildPreparePlan', () => {
+
+  test('single skill deck → plan with 1 skill, hasSkills=true', () => {
+    const plan = buildPreparePlan({
+      deckPath: '/tmp/test-deck.toml',
+      deckContent: DECK_ONE_SKILL,
+      workDir: '/tmp/arena-test',
+      skillCount: 0,
+    })
+    expect(plan.skills).toHaveLength(1)
+    expect(plan.skills[0].name).toBe('pdf')
+    expect(plan.skills[0].section).toBe('tool')
+    expect(plan.hasSkills).toBe(true)
+    expect(plan.workDir).toBe('/tmp/arena-test')
+    expect(plan.deckPath).toBe('/tmp/test-deck.toml')
+  })
+
+  test('empty deck → skills=[], hasSkills=false', () => {
+    const plan = buildPreparePlan({
+      deckPath: '/tmp/empty.toml',
+      deckContent: DECK_EMPTY,
+      workDir: '/tmp/arena-empty',
+      skillCount: 0,
+    })
+    expect(plan.skills).toEqual([])
+    expect(plan.hasSkills).toBe(false)
+  })
+
+  test('two skills (innate + tool) → both parsed with correct sections', () => {
+    const plan = buildPreparePlan({
+      deckPath: '/tmp/two.toml',
+      deckContent: DECK_TWO_SKILLS,
+      workDir: '/tmp/arena-two',
+      skillCount: 0,
+    })
+    expect(plan.skills).toHaveLength(2)
+    expect(plan.skills[0]).toEqual({ name: 'deck', path: 'github.com/lythos-labs/lythoskill/skills/lythoskill-deck', section: 'innate' })
+    expect(plan.skills[1]).toEqual({ name: 'pdf', path: 'github.com/anthropics/skills/skills/pdf', section: 'tool' })
+    expect(plan.hasSkills).toBe(true)
+  })
+
+  test('AGENTS.md contains mandatory sections', () => {
+    const plan = buildPreparePlan({
+      deckPath: '/tmp/d.toml',
+      deckContent: DECK_ONE_SKILL,
+      workDir: '/tmp/arena-md',
+      skillCount: 0,
+    })
+    expect(plan.agentsMd).toContain('Arena Test Environment')
+    expect(plan.agentsMd).toContain('Setup Order')
+    expect(plan.agentsMd).toContain('decision-log.jsonl')
+    expect(plan.agentsMd).toContain('skill-deck.toml')
+  })
+
+  test('invalid TOML → skills=[], hasSkills=false (no crash)', () => {
+    const plan = buildPreparePlan({
+      deckPath: '/tmp/bad.toml',
+      deckContent: 'this is not toml {{{',
+      workDir: '/tmp/arena-bad',
+      skillCount: 0,
+    })
+    expect(plan.skills).toEqual([])
+    expect(plan.hasSkills).toBe(false)
+  })
+
+  test('deckContent is preserved in plan', () => {
+    const plan = buildPreparePlan({
+      deckPath: '/tmp/d.toml',
+      deckContent: DECK_ONE_SKILL,
+      workDir: '/tmp/arena-preserve',
+      skillCount: 0,
+    })
+    expect(plan.deckContent).toBe(DECK_ONE_SKILL)
+  })
+})

package/src/preflight.ts

@@ -195,6 +195,104 @@ export function resolveColdPoolDir(
   return raw.startsWith('~') ? `${homeDir}${raw.slice(1)}` : raw
 }
 
+// ── buildArchiveSidePlan ──────────────────────────────────────────────────
+
+/**
+ * A single side's source mapping in an archive plan.
+ * Pure data — no IO, no console.
+ */
+export interface ArchiveSideEntry {
+  side: string
+  sourceDir: string
+  found: boolean
+}
+
+/**
+ * Build the per-side source directory plan for archive.
+ *
+ * Pure: strings + existence function → ArchiveSideEntry[].
+ * IO (`existsSync`) is injected via `existsFn` — test with mock, run with real.
+ *
+ * Single-side fallback: when --sides specifies exactly one named side and its
+ * subdirectory doesn't exist (agent put files in workdir root, prepare-workdir
+ * didn't create per-side dirs), fall back to `fromDir` as source (found=true).
+ *
+ * Default (no --sides): sides = ['.'] → sourceDir = fromDir.
+ */
+export function buildArchiveSidePlan(
+  fromDir: string,
+  sides: string[],
+  existsFn: (path: string) => boolean
+): ArchiveSideEntry[] {
+  const plan: ArchiveSideEntry[] = []
+  for (const side of sides) {
+    let sourceDir = side === '.' ? fromDir : join(fromDir, side)
+    let found = existsFn(sourceDir)
+    if (!found && sides.length === 1 && side !== '.') {
+      sourceDir = fromDir
+      found = true
+    }
+    plan.push({ side, sourceDir, found })
+  }
+  return plan
+}
+
+// ── buildPreparePlan ─────────────────────────────────────────────────────
+
+/**
+ * Plan-only result for prepare-workdir — what WOULD be created.
+ * Pure data, no IO. Caller renders this before executing.
+ */
+export interface PreparePlan {
+  deckPath: string
+  deckContent: string
+  workDir: string
+  skills: SkillDecl[]
+  hasSkills: boolean
+  agentsMd: string
+}
+
+/**
+ * Build the prepare-workdir plan from raw inputs.
+ *
+ * Pure computation: deck path + content → what workdir would contain.
+ * Caller does IO (reading deck, computing timestamp) and injects results.
+ */
+export function buildPreparePlan(params: {
+  deckPath: string
+  deckContent: string
+  workDir: string
+  skillCount: number
+  brief?: string
+}): PreparePlan {
+  let deckParsed: Record<string, any> = {}
+  try { deckParsed = Bun.TOML.parse(params.deckContent) as Record<string, any> } catch {}
+  const skills = parseDeckSkills(deckParsed)
+  const hasSkills = skills.length > 0
+
+  const agentsMd = [
+    '# Arena Test Environment',
+    '**Mode**: agent-orchestrated cell',
+    '',
+    '## Setup Order (why this sequence)',
+    '1. `skill-deck.toml` copied here → declares which skills you can use',
+    '2. `deck link` runs → cold pool skills become visible in `.claude/skills/`',
+    '3. Skill existence checked → warns if any declared skill is missing from cold pool',
+    '4. `AGENTS.md` written last → confirms setup succeeded before agent starts',
+    'If setup fails mid-sequence, the workdir is incomplete and nothing runs.',
+    '',
+    '## How This Works',
+    '- Write ALL output files to this directory (CWD).',
+    '- Use available skills — check `ls .claude/skills/`.',
+    '',
+    '## Output Contract',
+    '- MANDATORY: `decision-log.jsonl` — one JSON line per decision:',
+    '  `{"t":<seconds>,"phase":"setup|content|design|output","decision":"...","reason":"..."}`',
+  ].join('\n')
+
+  return { deckPath: params.deckPath, deckContent: params.deckContent, workDir: params.workDir, skills, hasSkills, agentsMd }
+}
+
 // ── formatSkillWarnings ──────────────────────────────────────────────────
 
 /**