@ionivetech/mugiwara 0.5.0 → 0.5.2

package/scripts/retrieval-eval.ts

@@ -24,25 +24,25 @@ function tokenize(text: string): string[] {
 function buildIndex(): Index {
   const index: Index = { terms: new Map(), docs: new Map(), docCount: 0 };
   const dirs = readdirSync(skillsDir).filter(d => statSync(join(skillsDir, d)).isDirectory());
-  
+
   for (const dir of dirs) {
     const file = join(skillsDir, dir, 'SKILL.md');
     if (!existsSync(file)) continue;
-    
+
     const { data } = parseFrontmatter(readFileSync(file, 'utf8'));
     const desc = data.description ?? '';
     const tokens = tokenize(desc);
     const tf = new Map<string, number>();
-    
+
     for (const t of tokens) {
       tf.set(t, (tf.get(t) || 0) + 1);
       index.terms.set(t, (index.terms.get(t) || 0) + 1);
     }
-    
+
     index.docs.set(dir, tf);
     index.docCount++;
   }
-  
+
   return index;
 }
 
@@ -56,7 +56,7 @@ function tfidf(index: Index, doc: string, term: string): number {
 function score(index: Index, prompt: string): { skill: string; score: number }[] {
   const promptTerms = tokenize(prompt);
   const results: { skill: string; score: number }[] = [];
-  
+
   for (const [doc] of index.docs) {
     let total = 0;
     for (const t of promptTerms) {
@@ -64,89 +64,198 @@ function score(index: Index, prompt: string): { skill: string; score: number }[]
     }
     results.push({ skill: doc, score: total });
   }
-  
-  return results.sort((a, b) => b.score - a.score);
+
+  return results.sort((a, b) => b.score - a.score || a.skill.localeCompare(b.skill));
 }
 
-// --- eval cases ---
-interface EvalCase {
-  prompt: string;
+// --- case schema ---
+interface CaseFile {
+  name: string;
+  skill: string;
+  type?: string;
+  task: string;
+  rubric: string[];
+  expect_lane?: string;
+  trigger?: {
+    positive?: { prompt: string; top_k?: number }[];
+    negative?: { prompt: string }[];
+  };
+  behavioral?: { task: string; rubric: string[] }[];
+}
+
+interface Probe {
+  kind: 'positive' | 'negative';
   skill: string;
-  type: 'positive' | 'negative';
-  top_k?: number;
+  prompt: string;
+  topK: number;
 }
 
+// --- build index ---
 const index = buildIndex();
 
-// Load existing case files
-const cases: EvalCase[] = [];
-if (existsSync(evalsDir)) {
-  const files = readdirSync(evalsDir).filter(f => f.endsWith('.json'));
-  for (const f of files) {
-    try {
-      const c = JSON.parse(readFileSync(join(evalsDir, f), 'utf8'));
-      if (c.prompt && c.skill) {
-        cases.push({ prompt: c.prompt, skill: c.skill, type: c.type || 'positive', top_k: c.top_k || 3 });
-      }
-    } catch { /* skip */ }
+// --- load cases ---
+const skills = readdirSync(skillsDir).filter(d => statSync(join(skillsDir, d)).isDirectory());
+const files = readdirSync(evalsDir).filter(f => f.endsWith('.json'));
+const probes: Probe[] = [];
+const noSkillProbes: Probe[] = [];
+const covered = new Set<string>();
+
+for (const f of files) {
+  let c: CaseFile;
+  try {
+    c = JSON.parse(readFileSync(join(evalsDir, f), 'utf8'));
+  } catch (e) {
+    throw new Error(`eval case ${f} is not valid JSON: ${e}`);
   }
-}
+  if (!c.skill) throw new Error(`eval case ${f} has no "skill"`);
+  covered.add(c.skill);
 
-// Add negative cases (must NOT rank first for irrelevant prompts)
-const negativeCases: EvalCase[] = [
-  { prompt: "tell me a joke about programmers", skill: "any", type: "negative", top_k: 1 },
-  { prompt: "convert this image to webp format", skill: "any", type: "negative", top_k: 1 },
-  { prompt: "schedule a meeting for next Tuesday", skill: "any", type: "negative", top_k: 1 },
-  { prompt: "translate this document to Japanese", skill: "any", type: "negative", top_k: 1 },
-];
+  const target = c.skill === '_no-skill' ? noSkillProbes : probes;
+  for (const p of c.trigger?.positive ?? [])
+    target.push({ kind: 'positive', skill: c.skill, prompt: p.prompt, topK: p.top_k ?? 3 });
+  for (const p of c.trigger?.negative ?? [])
+    target.push({ kind: 'negative', skill: c.skill, prompt: p.prompt, topK: 3 });
+}
 
-const allCases = [...cases, ...negativeCases];
+// --- coverage gate ---
+const missing = skills.filter(s => !covered.has(s));
+if (missing.length) {
+  console.error(`missing eval cases for ${missing.length} skills:`);
+  for (const s of missing) console.error(`  ${s}`);
+  process.exit(1);
+}
 
-// --- run ---
-let passed = 0;
-let failed = 0;
+// --- run probes ---
+let rank1 = 0, inTopK = 0, negPass = 0, noSkillPass = 0;
+const positives = probes.filter(p => p.kind === 'positive');
+const negatives = probes.filter(p => p.kind === 'negative');
+const nsPositives = noSkillProbes.filter(p => p.kind === 'positive');
+const nsNegatives = noSkillProbes.filter(p => p.kind === 'negative');
+const failures: string[] = [];
 const results: Record<string, { rank: number; score: number; top_k: number; passed: boolean }> = {};
 
-for (const tc of allCases) {
-  const rankings = score(index, tc.prompt);
-  const rank = rankings.findIndex(r => r.skill === tc.skill) + 1;
-  const entry = rankings[0];
-  
-  if (tc.type === 'negative') {
-    const gotMugiwara = entry && entry.skill.startsWith('mugiwara-') && entry.score > 3.5;
-    const p = !gotMugiwara;
-    const k = tc.top_k ?? 1;
-    results[tc.prompt] = { rank: 1, score: entry?.score ?? 0, top_k: k, passed: p };
-    if (p) passed++; else { failed++; console.error(`FAIL negative: "${tc.prompt}" → rank 1: ${entry?.skill} (score ${entry?.score?.toFixed(2)})`); }
+for (const p of positives) {
+  const ranked = score(index, p.prompt);
+  const rank = ranked.findIndex(r => r.skill === p.skill) + 1;
+  const key = `${p.skill}: ${p.prompt}`;
+  const entryScore = rank > 0 ? ranked[rank - 1].score : 0;
+  const topScore = ranked[0]?.score ?? 0;
+  const passed = entryScore > 0 && rank > 0 && rank <= p.topK;
+  results[key] = { rank, score: entryScore, top_k: p.topK, passed };
+  if (passed && rank === 1) rank1++;
+  if (passed) inTopK++;
+  else failures.push(`positive "${p.prompt}" → ${p.skill} ranked ${rank || 'unranked'} (want <=${p.topK}), got ${ranked[0]?.skill ?? 'none'}`);
+}
+
+for (const p of negatives) {
+  const ranked = score(index, p.prompt);
+  const top = ranked[0];
+  const pass = (top?.score ?? 0) === 0 || top?.skill !== p.skill;
+  const key = `!${p.skill}: ${p.prompt}`;
+  results[key] = { rank: 0, score: top?.score ?? 0, top_k: 3, passed: pass };
+  if (pass) negPass++;
+  else failures.push(`negative "${p.prompt}" wrongly ranked ${p.skill} first`);
+}
+
+for (const p of nsPositives) {
+  const ranked = score(index, p.prompt);
+  const top = ranked[0];
+  const pass = !top || top.score < 3.5;
+  const key = `_no-skill+: ${p.prompt}`;
+  results[key] = { rank: 0, score: top?.score ?? 0, top_k: 3, passed: pass };
+  if (pass) noSkillPass++;
+  else failures.push(`no-skill positive "${p.prompt}" → ${top.skill} score ${top.score.toFixed(2)} (want <3.5)`);
+}
+
+for (const p of nsNegatives) {
+  const ranked = score(index, p.prompt);
+  const top = ranked[0];
+  const pass = !!top && top.skill.startsWith('mugiwara-') && top.score >= 3.5;
+  const key = `_no-skill-: ${p.prompt}`;
+  results[key] = { rank: 0, score: top?.score ?? 0, top_k: 3, passed: pass };
+  if (pass) noSkillPass++;
+  else failures.push(`no-skill negative "${p.prompt}" → ${top?.skill ?? 'none'} score ${top?.score?.toFixed(2) ?? '0'} (want mugiwara skill >=3.5)`);
+}
+
+// --- compute rates ---
+const rank1Rate = positives.length ? (rank1 / positives.length) * 100 : 0;
+const topKRate  = positives.length ? (inTopK / positives.length) * 100 : 0;
+const negRate   = negatives.length ? (negPass / negatives.length) * 100 : 0;
+const nsTotal   = nsPositives.length + nsNegatives.length;
+const nsRate    = nsTotal ? (noSkillPass / nsTotal) * 100 : 100;
+
+const allPassed = Object.values(results).filter(r => r.passed).length;
+const allFailed = Object.values(results).filter(r => !r.passed).length;
+const totalProbes = Object.keys(results).length;
+
+// --- floor / ratchet ---
+const floorPath = join(root, 'evals', 'floor.json');
+const updateFloor = process.argv.includes('--update-floor');
+
+if (!existsSync(floorPath)) {
+  if (updateFloor) {
+    const initial = { rank1: Math.round(rank1Rate * 10) / 10, topk: Math.round(topKRate * 10) / 10, negatives: Math.round(negRate * 10) / 10, updated: new Date().toISOString().split('T')[0] };
+    writeJson(floorPath, initial);
+  }
+} else {
+  const floor = JSON.parse(readFileSync(floorPath, 'utf8'));
+  const TOL = 0.5;
+
+  if (updateFloor) {
+    floor.rank1 = Math.round(rank1Rate * 10) / 10;
+    floor.topk = Math.round(topKRate * 10) / 10;
+    floor.negatives = Math.round(negRate * 10) / 10;
+    floor.updated = new Date().toISOString().split('T')[0];
+    writeJson(floorPath, floor);
   } else {
-    const k = tc.top_k ?? 3;
-    const p = rank > 0 && rank <= k;
-    results[`${tc.skill}: ${tc.prompt}`] = { rank, score: rankings[rank - 1]?.score ?? 0, top_k: k, passed: p };
-    if (p) passed++; else { failed++; console.error(`FAIL: "${tc.prompt}" → "${tc.skill}" rank ${rank} (top ${k})`); }
+    const regressions: string[] = [];
+    if (rank1Rate < floor.rank1 - TOL) regressions.push(`rank-1 ${rank1Rate.toFixed(1)}% < floor ${floor.rank1}%`);
+    if (topKRate < floor.topk - TOL) regressions.push(`top-k ${topKRate.toFixed(1)}% < floor ${floor.topk}%`);
+    if (negRate < floor.negatives - TOL) regressions.push(`negatives ${negRate.toFixed(1)}% < floor ${floor.negatives}%`);
+
+    console.log(`rank-1 ${rank1Rate.toFixed(1)}%  top-3 ${topKRate.toFixed(1)}%  negatives ${negRate.toFixed(1)}%  no-skill ${nsRate.toFixed(1)}%  (${positives.length}p / ${negatives.length}n / ${nsTotal}ns over ${skills.length} skills)`);
+    for (const f of failures) console.error(`  FAIL ${f}`);
+    if (regressions.length) {
+      regressions.forEach(r => console.error(`REGRESSION: ${r}`));
+      process.exit(1);
+    }
   }
 }
 
 // --- report ---
-const rank1Count = Object.values(results).filter(r => 'rank' in r && r.rank === 1).length;
-const total = allCases.length;
-const rank1Rate = total > 0 ? (rank1Count / total * 100).toFixed(1) : '0';
-
-const report = {
-  index_size: index.docCount,
-  index_terms: index.terms.size,
-  cases: total,
-  passed,
-  failed,
-  rank1_count: rank1Count,
-  rank1_rate: `${rank1Rate}%`,
-  results,
-};
-
-// Output JSON for CI
 const ciArg = process.argv.indexOf('--json');
 if (ciArg !== -1) {
+  const report = {
+    index_size: index.docCount,
+    index_terms: index.terms.size,
+    probes: totalProbes,
+    positives: positives.length,
+    negatives: negatives.length,
+    no_skill: nsTotal,
+    rank1_count: rank1,
+    rank1_rate: `${rank1Rate.toFixed(1)}%`,
+    topk_count: inTopK,
+    topk_rate: `${topKRate.toFixed(1)}%`,
+    negative_pass: negPass,
+    negative_rate: `${negRate.toFixed(1)}%`,
+    no_skill_pass: noSkillPass,
+    no_skill_rate: `${nsRate.toFixed(1)}%`,
+    passed: allPassed,
+    failed: allFailed,
+    failures: failures.length > 0 ? failures : undefined,
+    results,
+  };
   console.log(JSON.stringify(report, null, 2));
 } else {
-  console.log(`Retrieval eval: ${passed}/${total} passed, ${rank1Rate} rank-1`);
-  if (failed > 0) process.exit(1);
+  console.log(`\nRetrieval eval: ${allPassed}/${totalProbes} passed, rank-1 ${rank1Rate.toFixed(1)}%, top-3 ${topKRate.toFixed(1)}%, neg ${negRate.toFixed(1)}%, ns ${nsRate.toFixed(1)}%`);
+  if (failures.length > 0) {
+    console.error(`\n${failures.length} failures:`);
+    for (const f of failures) console.error(`  ${f}`);
+    process.exit(1);
+  }
+}
+
+function writeJson(path: string, obj: object) {
+  const { writeFileSync } = require('node:fs');
+  writeFileSync(path, JSON.stringify(obj, null, 2) + '\n');
 }

package/scripts/run-evals.ts

@@ -16,12 +16,16 @@ const casesDir = join(root, 'evals', 'cases');
 const skillsDir = join(root, 'content', 'skills');
 const errors: string[] = [];
 
+type BehavioralTest = {
+  task: string;
+  rubric: string[];
+};
+
 type Case = {
   name: string;
   skill: string;
   type?: 'positive' | 'negative' | 'adversarial' | 'lane';
-  task: string;
-  rubric: string[];
+  behavioral?: BehavioralTest[];
   expect_lane?: string;
 };
 
@@ -40,34 +44,65 @@ function validateSuite(): Case[] {
   const cases: Case[] = [];
   const files = listCases(casesDir).sort();
   for (const rel of files) {
-    let c: Case;
-    try { c = JSON.parse(readFileSync(join(casesDir, rel), 'utf8')); }
+    let raw: any;
+    try { raw = JSON.parse(readFileSync(join(casesDir, rel), 'utf8')); }
     catch (e) { errors.push(`${rel}: invalid JSON (${(e as Error).message})`); continue; }
-    if (!c.name || !c.skill || !c.task || !Array.isArray(c.rubric) || !c.rubric.length)
-      errors.push(`${rel}: missing name/skill/task/nonempty rubric`);
-    else if (!existsSync(join(skillsDir, c.skill))) errors.push(`${rel}: unknown skill "${c.skill}"`);
-    if (c.type && !['positive', 'negative', 'adversarial', 'lane'].includes(c.type))
-      errors.push(`${rel}: bad type "${c.type}"`);
-    cases.push(c);
+    if (!raw.name || !raw.skill) { errors.push(`${rel}: missing name/skill`); continue; }
+
+    // skip files with no behavioral section (e.g. _no-skill.json)
+    if (!raw.behavioral || !Array.isArray(raw.behavioral) || raw.behavioral.length === 0) continue;
+    if (raw.skill === '_no-skill') continue;
+
+    // infer type from filename if not declared
+    const type = raw.type ?? (
+      rel.includes('positive') ? 'positive' :
+      rel.includes('negative') ? 'negative' :
+      rel.includes('adversarial') ? 'adversarial' :
+      rel.includes('lane') ? 'lane' :
+      undefined
+    );
+
+    // validate skill exists
+    if (!existsSync(join(skillsDir, raw.skill)))
+      errors.push(`${rel}: unknown skill "${raw.skill}"`);
+
+    if (type && !['positive', 'negative', 'adversarial', 'lane'].includes(type))
+      errors.push(`${rel}: bad type "${type}"`);
+
+    // register one case per behavioral test
+    for (const b of raw.behavioral) {
+      if (!b.task || !Array.isArray(b.rubric) || !b.rubric.length) {
+        errors.push(`${rel}: behavioral entry missing task/nonempty rubric`);
+        continue;
+      }
+      cases.push({
+        name: raw.name,
+        skill: raw.skill,
+        type,
+        behavioral: [b],
+        expect_lane: raw.expect_lane,
+      });
+    }
   }
-  if (!cases.length) { errors.push('no cases in evals/cases/'); }
+
+  if (!cases.length) { errors.push('no behavioral cases in evals/cases/'); }
 
   // coverage gates: the suite must exercise routing in all directions.
-  const types = new Set(cases.map(c => c.type).filter(Boolean));
-  if (cases.filter(c => c.type === 'positive').length < 2) errors.push('need ≥2 positive cases');
-  if (cases.filter(c => c.type === 'negative').length < 2) errors.push('need ≥2 negative cases');
-  if (cases.filter(c => c.type === 'adversarial').length < 2) errors.push('need ≥2 adversarial cases');
-  if (!types.has('lane')) errors.push('need ≥1 lane case');
+  const explicitTypes = cases.filter(c => c.type);
+  const allTypes = new Set(explicitTypes.map(c => c.type).filter(Boolean));
+  if (explicitTypes.filter(c => c.type === 'adversarial').length < 2) errors.push('need >=2 adversarial cases');
+  if (!allTypes.has('lane')) errors.push('need >=1 lane case');
   return cases;
 }
 
 function scoreRubric(answer: string, c: Case): { pass: number; total: number; matched: string[] } {
   const a = answer.toLowerCase();
-  const matched = c.rubric.filter(r => {
+  const rubric = c.behavioral?.[0]?.rubric ?? [];
+  const matched = rubric.filter(r => {
     const terms = r.toLowerCase().split(/[^a-z0-9]+/).filter(w => w.length > 3 && !['does', 'not', 'with', 'into', 'from'].includes(w));
     return terms.some(t => a.includes(t));
   });
-  return { pass: matched.length, total: c.rubric.length, matched };
+  return { pass: matched.length, total: rubric.length, matched };
 }
 
 async function runCases(env: { execFileSync: typeof import('node:child_process').execFileSync; bin: string; pre: string[] }): Promise<void> {
@@ -76,7 +111,8 @@ async function runCases(env: { execFileSync: typeof import('node:child_process')
   const { execFileSync, bin, pre } = env;
   let total = 0, passed = 0;
   for (const c of cases) {
-    const prompt = `Task: ${c.task}\n\nWhich mugiwara skill should run and why? Be concrete.`;
+    const task = c.behavioral?.[0]?.task ?? '';
+    const prompt = `Task: ${task}\n\nWhich mugiwara skill should run and why? Be concrete.`;
     let raw = '';
     try {
       raw = execFileSync(bin, [...pre, prompt], { encoding: 'utf8', timeout: 60000, maxBuffer: 10 * 1024 * 1024 });
@@ -89,7 +125,7 @@ async function runCases(env: { execFileSync: typeof import('node:child_process')
     const pct = Math.round((pass / t) * 100);
     console.log(`${pct >= 70 ? '✓' : '✗'} ${c.name} — ${pass}/${t} rubric (${pct}%)`);
     if (pass < t) {
-      console.log(`    task: ${c.task}`);
+      console.log(`    task: ${task}`);
       console.log(`    matched: ${matched.length ? matched.join('; ') : 'none'}`);
     }
   }

package/scripts/savepoint.sh

@@ -35,7 +35,7 @@ fi
 [ -d .git ] || die "not a git repository"
 
 # --- computed fields ---
-BASE_SHA=$(git merge-base HEAD main 2>/dev/null || git merge-base HEAD master 2>/dev/null || git rev-parse HEAD~1 2>/dev/null || echo "unknown")
+BASE_SHA=$(git merge-base HEAD main 2>/dev/null || git merge-base HEAD master 2>/dev/null || git merge-base HEAD "$(git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null | sed 's|refs/remotes/origin/||')" 2>/dev/null || git rev-parse HEAD~1 2>/dev/null || echo "unknown")
 HEAD_SHA=$(git rev-parse HEAD 2>/dev/null || echo "unknown")
 
 CHANGED_FILES=$(git diff --name-only "$BASE_SHA"..HEAD 2>/dev/null || git diff --name-only --cached 2>/dev/null || true)
@@ -43,11 +43,12 @@ FILES_TOUCHED=$( [ -n "$CHANGED_FILES" ] && echo "$CHANGED_FILES" | wc -l | tr -
 
 LOC_DELTA=0
 if [ "$BASE_SHA" != "unknown" ]; then
-  LOC_DELTA=$(git diff --shortstat "$BASE_SHA"..HEAD 2>/dev/null | \
-    awk '{ins=0; del=0; for(i=1;i<=NF;i++){if($i=="insertion") ins=$(i-1); if($i=="deletion") del=$(i-1)} print ins-del}' || echo 0)
+  STAT=$(git diff --shortstat "$BASE_SHA"..HEAD 2>/dev/null || echo "")
+  INS=$(echo "$STAT" | grep -oE '[0-9]+ insertion' | grep -oE '[0-9]+' || echo 0)
+  DEL=$(echo "$STAT" | grep -oE '[0-9]+ deletion'  | grep -oE '[0-9]+' || echo 0)
+  LOC_DELTA=$(( ${INS:-0} - ${DEL:-0} ))
 fi
 [ -z "$LOC_DELTA" ] && LOC_DELTA=0
-[ "$LOC_DELTA" = "0" ] || LOC_DELTA=${LOC_DELTA//[^0-9-]/}
 
 SENSITIVE_PATTERNS="auth/|payment/|billing/|crypto/|secrets/|\.env|config/|migration/|\.sql$|schema\.|\.prisma$"
 SENSITIVE_PATHS=$(echo "$CHANGED_FILES" | grep -E "$SENSITIVE_PATTERNS" 2>/dev/null | tr '\n' ',' | sed 's/,$//' || true)

package/src/targets/opencode.ts

@@ -3,6 +3,44 @@ import { join } from 'node:path';
 import { stringifyFrontmatter, type FrontmatterData } from '../frontmatter.ts';
 import type { Target } from '../installer.ts';
 
+type CrewConfig = {
+  color: string;
+  temperature: number;
+  steps: number;
+  permission?: Record<string, string>;
+};
+
+const CREW: Record<string, CrewConfig> = {
+  'using-mugiwara': { color: '#84cc16', temperature: 0.2, steps: 10 },
+  'luffy-orchestrator': { color: '#ef4444', temperature: 0.2, steps: 15 },
+  'usopp-brainstorm': { color: '#f59e0b', temperature: 0.6, steps: 15 },
+  'nami-planner': { color: '#f97316', temperature: 0.2, steps: 15 },
+  'zoro-execution': { color: '#22c55e', temperature: 0.1, steps: 30 },
+  'chopper-checkpoint': { color: '#3b82f6', temperature: 0.1, permission: { edit: 'deny' }, steps: 15 },
+  'sanji-quality': { color: '#a855f7', temperature: 0.1, permission: { edit: 'deny' }, steps: 10 },
+  'franky-gates': { color: '#06b6d4', temperature: 0.1, permission: { edit: 'deny' }, steps: 10 },
+  'robin-reviewer': { color: '#8b5cf6', temperature: 0.2, permission: { edit: 'deny' }, steps: 15 },
+  'jinbe-security': { color: '#6366f1', temperature: 0.2, permission: { edit: 'deny' }, steps: 15 },
+  'brook-healing': { color: '#ec4899', temperature: 0.1, steps: 20 },
+  'skeptic-verifier': { color: '#64748b', temperature: 0.1, permission: { edit: 'deny' }, steps: 12 },
+  'eval-runner': { color: '#14b8a6', temperature: 0.2, steps: 15 },
+  'resume-coordinator': { color: '#d97706', temperature: 0.2, steps: 10 },
+  'memory-keeper': { color: '#d946ef', temperature: 0.2, steps: 8 },
+};
+
+function agentFrontmatter(name: string, description: string) {
+  const crew = CREW[name];
+  const lines = [`description: ${description}`, `mode: all`];
+  if (crew) {
+    lines.push(`color: '${crew.color}'`, `temperature: ${crew.temperature}`, `steps: ${crew.steps}`);
+    if (crew.permission) {
+      lines.push('permission:');
+      for (const [k, v] of Object.entries(crew.permission)) lines.push(`  ${k}: ${v}`);
+    }
+  }
+  return lines.join('\n');
+}
+
 export const target: Target = {
   id: 'opencode',
   label: 'opencode',
@@ -18,9 +56,8 @@ export const target: Target = {
     };
   },
   transformAgent(data: FrontmatterData, body: string) {
-    const fm: FrontmatterData = { name: data.name, description: data.description };
-    if (data.tools) fm.tools = data.tools;
-    return { relPath: `${data.name}.md`, text: stringifyFrontmatter(fm, body) };
+    const fm = agentFrontmatter(data.name, data.description);
+    return { relPath: `${data.name}.md`, text: `---\n${fm}\n---\n${body}` };
   },
   refsDir({ scope, projectDir, home }, skillName: string) {
     const root = scope === 'global' ? join(home, '.config', 'opencode') : join(projectDir, '.opencode');

package/evals/cases/negative-secrets-typo.json

@@ -1,12 +0,0 @@
-{
-  "name": "negative-secrets-typo",
-  "skill": "mugiwara-git",
-  "type": "negative",
-  "task": "Fix a typo in a comment in src/index.ts (one word). This is a trivial change.",
-  "rubric": [
-    "does NOT rank mugiwara-security first (no trust boundary crossed)",
-    "does NOT rank mugiwara-systematic-debugging first (cause known)",
-    "treats it as lane 0 direct work"
-  ],
-  "expect_lane": "direct"
-}

package/evals/cases/negative-security-docs-change.json

@@ -1,12 +0,0 @@
-{
-  "name": "negative-security-docs-change",
-  "skill": "mugiwara-git",
-  "type": "negative",
-  "task": "Update the README to fix a broken link. No code, no config, no data flow changes.",
-  "rubric": [
-    "does NOT rank mugiwara-security first (docs-only, no trust boundary)",
-    "does NOT rank mugiwara-test-driven-development first (no production code)",
-    "does NOT rank mugiwara-gates first (no code changed)"
-  ],
-  "expect_lane": "direct"
-}

package/evals/cases/routing-typo.json

@@ -1,13 +0,0 @@
-{
-  "name": "routing-typo",
-  "skill": "mugiwara-git",
-  "task": "Fix a typo in a comment in src/index.ts (one word).",
-  "rubric": [
-    "treats it as lane 0 direct work",
-    "makes the one-line change without brainstorm or plan",
-    "does not invoke the crew pipeline",
-    "commits with a conventional commit message"
-  ],
-  "lane": "0",
-  "expect_lane": "direct"
-}