@givolt/i3-composer-agent 2.2.3 → 2.3.0

package/scripts/enterprise-template-test.js

@@ -0,0 +1,139 @@
+'use strict';
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const crypto = require('node:crypto');
+const { spawn, spawnSync } = require('node:child_process');
+const install = path.join(__dirname, 'lib/installation.js');
+const skills = fs.existsSync(install) ? require(install).loadInstallation().skillsDirectory : path.resolve(__dirname, '../skills');
+const skill = path.join(skills, 'i3-ui-prototype');
+const lib = require(path.join(skill, 'scripts/prototype-lib.cjs'));
+const read = (root, file) => JSON.parse(fs.readFileSync(path.join(root, file), 'utf8'));
+function project(t) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'enterprise-template-'));
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+  return root;
+}
+function initialize(t, options = {}) {
+  return lib.initPrototype({ project: project(t), id: 'enterprise-demo', expertMode: 'template', purpose: 'template-review', ...options }).directory;
+}
+test('four prototype families expose the EASEL enterprise template and explicitly defer the other three', () => {
+  const entries = lib.listTemplates();
+  assert.deepEqual(entries.map(x => x.id), ['enterprise-admin', 'ai-workbench', 'digital-twin', 'mobile-app']);
+  assert.deepEqual(entries.filter(x => x.availability === 'available').map(x => x.id), ['enterprise-admin']);
+  for (const entry of entries.slice(1)) assert.equal(entry.availability, 'planned');
+});
+test('default enterprise initializer preserves the complete EASEL runtime and its review scope', t => {
+  const dir = initialize(t), metadata = read(dir, 'prototype.json');
+  assert.equal(metadata.template.id, 'enterprise-admin');
+  assert.equal(metadata.purpose, 'template-review');
+  assert.equal(metadata.review.status, 'pending-review');
+  const inspection = lib.checkPrototype(dir);
+  assert.equal(inspection.status, 'passed', JSON.stringify(inspection));
+  const routes = read(dir, 'app/routes.json').filter(x => x.component && !x.path.startsWith('/module/'));
+  assert.equal(routes.length, 37);
+  assert.equal(new Set(routes.map(x => x.component)).size, 34);
+  for (const file of ['app/runtime/dom.js', 'app/styles/antdv.css', 'app/src/shell/ConsoleShell.html', 'app/licenses/antdv-next.txt', 'design-system/source.json']) {
+    assert.ok(fs.existsSync(path.join(dir, file)), file);
+  }
+});
+test('planned template families refuse initialization without silently generating a desktop demo', t => {
+  const root = project(t);
+  for (const template of ['ai-workbench', 'digital-twin', 'mobile-app']) {
+    assert.throws(() => lib.initPrototype({ project: root, id: template, template, expertMode: 'template' }), /planned|尚未|待建设/);
+  }
+  assert.equal(fs.existsSync(path.join(root, 'prototypes')), false);
+});
+test('all imported reference files retain their declared source hashes', () => {
+  const origin = read(skill, 'assets/templates/enterprise-admin/origin.json');
+  assert.equal(Object.keys(origin.files).length, 326);
+  for (const [file, expected] of Object.entries(origin.files)) {
+    const contents = fs.readFileSync(path.join(skill, 'assets/templates/enterprise-admin/reference', origin.storagePaths?.[file] || file));
+    assert.equal(crypto.createHash('sha256').update(contents).digest('hex'), expected, file);
+  }
+});
+test('an unadapted EASEL example cannot pass new-business acceptance', t => {
+  const dir = initialize(t, { purpose: 'business-prototype' });
+  assert.equal(read(dir, 'prototype.json').business.status, 'needs-adaptation');
+  assert.match(lib.checkPrototype(dir, { acceptance: true }).errors.join(' '), /业务|adapt/);
+});
+test('generated enterprise instances isolate their local demo storage and retain the original route behavior', t => {
+  const dir = initialize(t);
+  const source = fs.readFileSync(path.join(dir, 'app/src/shared/session.js'), 'utf8');
+  assert.match(source, /i3-enterprise-enterprise-demo-/);
+  assert.doesNotMatch(source, /i3-prototype-antdv-/);
+  assert.match(fs.readFileSync(path.join(dir, 'app/index.html'), 'utf8'), /enterprise-bootstrap\.mjs/);
+  assert.match(fs.readFileSync(path.join(dir, 'app/index.html'), 'utf8'), /tokens\.css/);
+  const other = initialize(t);
+  assert.notEqual(read(dir, 'prototype.json').runtime.storagePrefix, read(other, 'prototype.json').runtime.storagePrefix);
+});
+test('missing enterprise runtime imports are rejected while declarative data-bind attributes remain valid', t => {
+  const dir = initialize(t);
+  assert.equal(lib.checkPrototype(dir).status, 'passed');
+  fs.unlinkSync(path.join(dir, 'app/runtime/controls.js'));
+  const result = lib.checkPrototype(dir);
+  assert.equal(result.status, 'failed');
+  assert.match(result.errors.join(' '), /controls\.js/);
+});
+test('tampered template source assets are rejected before a new instance can be trusted', t => {
+  const temp = project(t);
+  const copy = path.join(temp, 'enterprise-admin');
+  fs.cpSync(path.join(skill, 'assets/templates/enterprise-admin'), copy, { recursive: true });
+  fs.appendFileSync(path.join(copy, 'reference/styles/app.css'), '\n/* unexpected source edit */');
+  const { verifyReference } = require(path.join(skill, 'scripts/enterprise-template.cjs'));
+  assert.throws(() => verifyReference(copy), /integrity|来源完整性/);
+});
+test('enterprise preview serves JavaScript modules and SVG assets with browser-compatible MIME types', async t => {
+  const dir = initialize(t);
+  const child = spawn(process.execPath, ['app/serve.cjs'], { cwd: dir, stdio: ['ignore', 'pipe', 'pipe'] });
+  t.after(() => child.kill());
+  const url = await new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error('Preview start timed out')), 5000);
+    child.stdout.on('data', data => { const match = data.toString().match(/http:\/\/127\.0\.0\.1:\d+\//); if (match) { clearTimeout(timer); resolve(match[0]); } });
+    child.once('error', reject);
+  });
+  const js = await fetch(url + 'app/app.js');
+  assert.equal(js.status, 200);
+  assert.match(js.headers.get('content-type'), /javascript/);
+  const svg = await fetch(url + 'app/assets/empty.svg');
+  assert.equal(svg.status, 200);
+  assert.match(svg.headers.get('content-type'), /image\/svg\+xml/);
+});
+test('gallery and generated enterprise instances deliver the same scrolling adapter while retaining the complete reference', t => {
+  const dir = initialize(t);
+  const css = fs.readFileSync(path.join(dir, 'app/usability.css'));
+  assert.equal(css.compare(fs.readFileSync(path.join(skill, 'assets/templates/enterprise-admin/usability.css'))), 0);
+  assert.match(fs.readFileSync(path.join(dir, 'app/index.html'), 'utf8'), /href="usability\.css"/);
+  const preview = lib.listTemplates()[0].preview.split('#')[0];
+  const entry = path.join(skill, 'assets/templates', preview);
+  assert.notEqual(preview, 'enterprise-admin/reference/index.html');
+  const html = fs.readFileSync(entry, 'utf8');
+  assert.match(html, /href="usability\.css"/);
+  for (const match of html.matchAll(/(?:src|href)="([^"#]+)"/g)) {
+    if (match[1].startsWith('data:')) continue;
+    assert.ok(fs.existsSync(path.resolve(path.dirname(entry), match[1])), match[1]);
+  }
+  const { verifyReference } = require(path.join(skill, 'scripts/enterprise-template.cjs'));
+  assert.equal(verifyReference().fileCount, 326);
+});
+test('scrolling behavior remains protected after an enterprise baseline is confirmed', t => {
+  const dir = initialize(t);
+  // Unit fixture only: these records exercise the baseline guard and do not
+  // claim real browser execution or human acceptance of a delivered prototype.
+  fs.writeFileSync(path.join(dir, 'qa/unit-fixture.txt'), 'UNIT FIXTURE ONLY');
+  const manifest = lib.contentManifest(dir);
+  const scenarios = new Set(read(dir, 'requirements-map.json').requirements.flatMap(x => x.scenarios));
+  fs.writeFileSync(path.join(dir, 'qa/browser.json'), JSON.stringify({
+    ...manifest, status: 'passed', source: 'UNIT FIXTURE ONLY', consoleErrors: [],
+    screenshots: ['qa/unit-fixture.txt'], viewports: [390, 1440],
+    journeys: [...scenarios].map(id => ({ id, status: 'passed' })),
+  }));
+  lib.freezeBaseline(dir, { revision: manifest.revision, digest: manifest.digest, reviewer: 'unit fixture', statement: 'UNIT FIXTURE ONLY', source: 'test fixture' });
+  fs.appendFileSync(path.join(dir, 'app/usability.css'), '\n/* changed scrolling behavior */\n');
+  assert.ok(lib.compareBaseline(dir).protectedChanges.includes('app/usability.css'));
+  const guard = spawnSync(process.execPath, [path.join(skill, 'scripts/check-prototype.cjs'), dir, '--enforce-baseline'], { encoding: 'utf8' });
+  assert.equal(guard.status, 1);
+  assert.match(guard.stdout, /Design constraints changed/);
+});

package/scripts/lib/skill-lint-test.js

@@ -9,7 +9,7 @@ const fs   = require('node:fs');
 const os   = require('node:os');
 const path = require('node:path');
 
-const { lintSkillContent, lintSkillLayout, topLevelFrontmatterKeys } = require('./skill-lint.js');
+const { lintSkillContent, lintSkillLayout, topLevelFrontmatterKeys, parseFrontmatter, frontmatterYamlErrors, lintPersonaContent } = require('./skill-lint.js');
 
 const KNOWN = new Set(['alpha', 'beta']);
 
@@ -648,3 +648,115 @@ test('the spec-key check tolerates CRLF frontmatter', () => {
   const { errors } = lintSkillContent('alpha', content, KNOWN);
   assert.equal(errors.filter(e => /key 'temperature'/.test(e)).length, 1);
 });
+
+test('parseFrontmatter ignores comments and nested metadata keys', () => {
+  const content = [
+    '---',
+    'name: alpha',
+    '# note: this is a comment',
+    'description: Designs alphas. Use when building one.',
+    'metadata:',
+    '  name: beta',
+    '  description: Nested details without trigger',
+    '---',
+    '',
+  ].join('\n');
+  assert.deepEqual(parseFrontmatter(content), {
+    name: 'alpha',
+    description: 'Designs alphas. Use when building one.',
+    metadata: '',
+  });
+});
+
+test('frontmatterYamlErrors ignores comment lines containing colons or quotes', () => {
+  const content = [
+    '---',
+    'name: alpha',
+    '# note: a comment: with a colon and "unclosed quote',
+    'description: "Designs alphas. Use when building one."',
+    '---',
+    '',
+  ].join('\n');
+  assert.deepEqual(frontmatterYamlErrors(content), []);
+});
+
+test('a skill with frontmatter comments and nested metadata passes validation', () => {
+  const content = withAllSections([
+    '---',
+    'name: alpha',
+    '# Note: keep description up to date: check docs',
+    'description: Designs alphas. Use when building one.',
+    'metadata:',
+    '  name: beta',
+    '  description: Internal notes',
+    '---',
+  ].join('\n'));
+  const { errors } = lintSkillContent('alpha', content, KNOWN);
+  assert.deepEqual(errors, []);
+});
+
+// ─── Personas (agents/<name>.md) ─────────────────────────────────────────────
+//
+// docs/agents.md: same frontmatter format as a skill, name equal to the file
+// stem, and the file ends with a Composition block. Nothing more is checked.
+
+function personaFile({ name = 'code-reviewer', description = 'Reviews changes. Use before merging.', body } = {}) {
+  const fm = ['---', name === null ? null : `name: ${name}`, description === null ? null : `description: ${description}`, '---']
+    .filter(l => l !== null).join('\n');
+  return `${fm}\n\n${body ?? '# Persona\n\n## Rules\n\nBe precise.\n\n## Composition\n\n- **Invoke via:** `/ship`.\n'}`;
+}
+
+test('a conforming persona produces no errors', () => {
+  assert.deepEqual(lintPersonaContent('code-reviewer', personaFile()).errors, []);
+});
+
+test('persona: frontmatter name must match the file stem', () => {
+  const { errors } = lintPersonaContent('code-reviewer', personaFile({ name: 'reviewer' }));
+  assert.equal(errors.length, 1);
+  assert.match(errors[0], /name 'reviewer' does not match file name 'code-reviewer'/);
+});
+
+test('persona: description is required', () => {
+  const { errors } = lintPersonaContent('code-reviewer', personaFile({ description: null }));
+  assert.equal(errors.length, 1);
+  assert.match(errors[0], /missing required field: 'description'/);
+});
+
+test('persona: a missing frontmatter block is reported and nothing else is attempted', () => {
+  const { errors } = lintPersonaContent('code-reviewer', '# Persona\n\n## Composition\n');
+  assert.equal(errors.length, 1);
+  assert.match(errors[0], /Missing or malformed YAML frontmatter/);
+});
+
+test('persona: frontmatter a host would reject as YAML is reported', () => {
+  const { errors } = lintPersonaContent('code-reviewer', personaFile({ description: 'Reviews: everything. Use before merging.' }));
+  assert.equal(errors.length, 1);
+  assert.match(errors[0], /Frontmatter line/);
+});
+
+test('persona: the Composition section is required', () => {
+  const { errors } = lintPersonaContent('code-reviewer', personaFile({ body: '# Persona\n\n## Rules\n\nBe precise.\n' }));
+  assert.equal(errors.length, 1);
+  assert.match(errors[0], /Missing "## Composition" section/);
+});
+
+test('persona: Composition must be the last section', () => {
+  const { errors } = lintPersonaContent('code-reviewer', personaFile({
+    body: '# Persona\n\n## Composition\n\n- **Invoke via:** `/ship`.\n\n## Output Format\n\nA report.\n',
+  }));
+  assert.equal(errors.length, 1);
+  assert.match(errors[0], /must be the last section, but "## Output Format" follows it/);
+});
+
+test('persona: a heading inside a fenced example after Composition is not a later section', () => {
+  const body = [
+    '# Persona', '', '## Composition', '', '- **Invoke via:** `/ship`. Report in this shape:', '',
+    '```markdown', '## Review: [title]', 'Findings…', '```', '',
+  ].join('\n');
+  assert.deepEqual(lintPersonaContent('code-reviewer', personaFile({ body })).errors, []);
+});
+
+test('persona: the Composition heading match is case-insensitive and tolerates trailing spaces', () => {
+  const body = '# Persona\n\n## composition   \n\n- **Invoke via:** `/ship`.\n';
+  assert.deepEqual(lintPersonaContent('code-reviewer', personaFile({ body })).errors, []);
+});

package/scripts/lib/skill-lint.js

@@ -86,9 +86,7 @@ const REQUIRED_SECTIONS = [
 // Every entry must have a documented reason.
 const SECTION_EXEMPT_SKILLS = {
   'i3-using-agent-skills': 'Branded alias of the reviewed upstream meta-skill.',
-  'i3-idea-refine': 'Branded alias of the reviewed upstream legacy structure.',
   'using-agent-skills': 'Meta-skill — orchestrates other skills; When-to-Use and Verification are not applicable to a routing document.',
-  'idea-refine':        'Legacy structure predating skill-anatomy.md — uses How-It-Works/Usage/Anti-patterns instead of standard headings.',
 };
 
 // Regex patterns that indicate an explicit cross-skill reference.
@@ -186,11 +184,12 @@ function parseFrontmatter(content) {
 
   const result = {};
   for (const line of match[1].split(/\r?\n/)) {
-    const colonIdx = line.indexOf(':');
-    if (colonIdx === -1) continue;
-    const key   = line.slice(0, colonIdx).trim();
-    const value = line.slice(colonIdx + 1).trim().replace(/^['"]|['"]$/g, '');
-    if (key) result[key] = value;
+    if (/^\s*#/.test(line)) continue;
+    const m = line.match(/^([A-Za-z0-9_-]+)\s*:\s*(.*)$/);
+    if (!m) continue;
+    const key   = m[1];
+    const value = m[2].trim().replace(/^['"]|['"]$/g, '');
+    result[key] = value;
   }
   return result;
 }
@@ -236,7 +235,7 @@ function frontmatterYamlErrors(content) {
   const lines = match[1].split(/\r?\n/);
   lines.forEach((line, i) => {
     const lineNo = i + 2; // the opening `---` is line 1
-    if (!line.trim()) return;
+    if (!line.trim() || /^\s*#/.test(line)) return;
 
     if (/^[ ]*\t/.test(line)) {
       errors.push(
@@ -545,6 +544,59 @@ function lintSkillLayout(skillDir) {
   return errors;
 }
 
+/**
+ * Lint a persona file (agents/<name>.md) against the three rules docs/agents.md
+ * states for them: frontmatter in the same format as a skill, with `name`
+ * equal to the file stem (the name is the `subagent_type` commands spawn) and
+ * a `description`; and a closing `## Composition` section. Headings inside
+ * fenced blocks are ignored, so an example after Composition does not count as
+ * a later section. Pure: no filesystem access. Returns { errors }.
+ */
+function lintPersonaContent(stem, content) {
+  const errors = [];
+
+  const fm = parseFrontmatter(content);
+  if (!fm) {
+    errors.push('Missing or malformed YAML frontmatter (expected --- block at top of file)');
+    return { errors };
+  }
+  errors.push(...frontmatterYamlErrors(content));
+
+  if (!fm.name) {
+    errors.push("Frontmatter missing required field: 'name'");
+  } else if (fm.name !== stem) {
+    errors.push(`Frontmatter name '${fm.name}' does not match file name '${stem}' (the name is the subagent_type commands spawn)`);
+  }
+  if (!fm.description) {
+    errors.push("Frontmatter missing required field: 'description'");
+  }
+
+  const headings = [...stripFencedCodeBlocks(content).matchAll(/^## +(.+?)\s*$/gm)].map(m => m[1]);
+  const compositionAt = headings.findIndex(h => /^Composition$/i.test(h));
+  if (compositionAt === -1) {
+    errors.push('Missing "## Composition" section (docs/agents.md: every persona file ends with a Composition block)');
+  } else if (compositionAt !== headings.length - 1) {
+    errors.push(`"## Composition" must be the last section, but "## ${headings[headings.length - 1]}" follows it`);
+  }
+
+  return { errors };
+}
+
+/**
+ * Lint a persona by file name: reads agents/<file>, then delegates to
+ * lintPersonaContent. Returns { errors }.
+ */
+function lintPersona(fileName, agentsDir) {
+  const stem = fileName.replace(/\.md$/, '');
+  let content;
+  try {
+    content = fs.readFileSync(path.join(agentsDir, fileName), 'utf8');
+  } catch (err) {
+    return { errors: [`Unreadable persona file: ${err.message}`] };
+  }
+  return lintPersonaContent(stem, content);
+}
+
 /**
  * Lint a skill by directory name: reads its SKILL.md, then delegates to
  * lintSkillContent. This is the thin filesystem wrapper the CLI uses.
@@ -583,4 +635,6 @@ module.exports = {
   lintSkillContent,
   lintSkillLayout,
   lintSkill,
+  lintPersonaContent,
+  lintPersona,
 };

package/scripts/run-evals-test.js

@@ -56,6 +56,8 @@ function makeSandbox() {
   fs.mkdirSync(path.join(root, 'evals', 'cases'), { recursive: true });
   fs.mkdirSync(path.join(root, 'evals', 'fixtures', 'project'), { recursive: true });
   fs.copyFileSync(RUNNER, path.join(root, 'scripts', 'run-evals.js'));
+  fs.mkdirSync(path.join(root, 'scripts', 'lib'), { recursive: true });
+  fs.copyFileSync(path.join(__dirname, 'lib', 'skill-lint.js'), path.join(root, 'scripts', 'lib', 'skill-lint.js'));
   fs.writeFileSync(path.join(root, 'evals', 'fixtures', 'project', 'context.txt'), 'fixture\n');
   return root;
 }
@@ -67,6 +69,91 @@ function run(root, args = []) {
   });
 }
 
+function runBehavioralWithGrading(root, raw) {
+  writeSkill(root, 'alpha-skill', 'Handles alpha widgets.');
+  const evalCase = completeCase('alpha-skill', 'change alpha widget');
+  evalCase.evals = [{ ...behavioralEval([]), kind: 'dialogue' }];
+  writeJson(path.join(root, 'evals', 'cases', 'alpha-skill.json'), evalCase);
+  const stub = path.join(root, 'stub-claude.cjs');
+  fs.writeFileSync(stub, `
+    const assert = require('node:assert/strict');
+    require('child_process').execFileSync = (command, args) => {
+      assert.equal(command, 'claude');
+      return args.includes('--output-format')
+        ? '{"type":"result","result":"done"}\\n'
+        : ${JSON.stringify(raw)};
+    };
+  `);
+  return spawnSync(process.execPath, [
+    '--require', stub, path.join(root, 'scripts', 'run-evals.js'),
+    '--behavioral', 'alpha-skill',
+  ], { cwd: root, encoding: 'utf8' });
+}
+
+for (const passed of [true, false]) {
+  for (const evidence of ['', ' \t\r\n', '\u00a0\u2003']) {
+    test(`behavioral CLI diagnoses blank evidence for ${passed ? 'passing' : 'failing'} verdict ${JSON.stringify(evidence)}`, () => {
+      const root = makeSandbox();
+      try {
+        const raw = JSON.stringify({
+          expectations: [{ id: 1, text: 'check the result', passed, evidence }],
+          summary: { passed: Number(passed), failed: Number(!passed), total: 1, pass_rate: Number(passed) },
+        });
+        const base = path.join(root, 'evals', 'results', 'alpha-skill.eval-1');
+        writeJson(`${base}.grading.json`, { stale: true });
+
+        const result = runBehavioralWithGrading(root, raw);
+
+        assert.equal(result.status, 1, result.stdout + result.stderr);
+        assert.match(result.stdout, /grader returned blank evidence/);
+        assert.doesNotMatch(result.stdout, /invalid JSON/);
+        assert.match(result.stdout, /raw saved to .*alpha-skill\.eval-1\.grading\.raw\.txt/);
+        assert.equal(fs.readFileSync(`${base}.grading.raw.txt`, 'utf8'), raw);
+        assert.equal(fs.existsSync(`${base}.grading.json`), false);
+      } finally {
+        fs.rmSync(root, { recursive: true, force: true });
+      }
+    });
+  }
+}
+
+for (const raw of ['not JSON', '{"expectations":', '{"expectations":[]}']) {
+  test(`behavioral CLI retains the generic diagnostic for invalid grading ${raw}`, () => {
+    const root = makeSandbox();
+    try {
+      const result = runBehavioralWithGrading(root, raw);
+      assert.equal(result.status, 1, result.stdout + result.stderr);
+      assert.match(result.stdout, /grader returned invalid JSON/);
+      assert.doesNotMatch(result.stdout, /blank evidence/);
+      const base = path.join(root, 'evals', 'results', 'alpha-skill.eval-1');
+      assert.equal(fs.readFileSync(`${base}.grading.raw.txt`, 'utf8'), raw);
+      assert.equal(fs.existsSync(`${base}.grading.json`), false);
+    } finally {
+      fs.rmSync(root, { recursive: true, force: true });
+    }
+  });
+}
+
+test('behavioral CLI still publishes valid grading without a rejection diagnostic', () => {
+  const root = makeSandbox();
+  try {
+    const evidence = '  observed in the trace  ';
+    const raw = JSON.stringify({
+      expectations: [{ id: 1, text: 'check the result', passed: true, evidence }],
+      summary: { passed: 1, failed: 0, total: 1, pass_rate: 1 },
+    });
+    const result = runBehavioralWithGrading(root, raw);
+    assert.equal(result.status, 0, result.stdout + result.stderr);
+    assert.doesNotMatch(result.stdout, /grader returned/);
+    const base = path.join(root, 'evals', 'results', 'alpha-skill.eval-1');
+    const grading = JSON.parse(fs.readFileSync(`${base}.grading.json`, 'utf8'));
+    assert.equal(grading.expectations[0].evidence, evidence);
+    assert.equal(fs.existsSync(`${base}.grading.raw.txt`), false);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
 test('accepts a complete and consistent grader result', () => {
   const raw = JSON.stringify({
     expectations: [
@@ -79,6 +166,44 @@ test('accepts a complete and consistent grader result', () => {
   assert.deepEqual(parseGrading(raw, ['first expectation', 'second expectation']), JSON.parse(raw));
 });
 
+for (const passed of [true, false]) {
+  for (const evidence of ['', ' \t\r\n', '\u00a0\u2003']) {
+    test(`rejects ${passed ? 'passing' : 'failing'} grading with blank evidence ${JSON.stringify(evidence)}`, () => {
+      const raw = JSON.stringify({
+        expectations: [{ id: 1, text: 'check the result', passed, evidence }],
+        summary: { passed: Number(passed), failed: Number(!passed), total: 1, pass_rate: Number(passed) },
+      });
+      assert.equal(parseGrading(raw, ['check the result']), null);
+    });
+  }
+}
+
+test('preserves nonblank evidence including surrounding whitespace', () => {
+  const evidence = '  No matching tool call was found.\n';
+  const raw = JSON.stringify({
+    expectations: [{ id: 1, text: 'check the result', passed: false, evidence }],
+    summary: { passed: 0, failed: 1, total: 1, pass_rate: 0 },
+  });
+  assert.equal(parseGrading(raw, ['check the result']).expectations[0].evidence, evidence);
+});
+
+test('blank evidence retains raw grading without publishing a scored artifact', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'grading-blank-evidence-'));
+  try {
+    const base = path.join(dir, 'my-skill.eval-1');
+    const raw = JSON.stringify({
+      expectations: [{ id: 1, text: 'check the result', passed: true, evidence: '' }],
+      summary: { passed: 1, failed: 0, total: 1, pass_rate: 1 },
+    });
+    clearGradingSlot(base);
+    assert.equal(persistGradingOutcome(base, parseGrading(raw, ['check the result']), raw), false);
+    assert.equal(fs.existsSync(`${base}.grading.json`), false);
+    assert.equal(fs.readFileSync(`${base}.grading.raw.txt`, 'utf8'), raw);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
 test('rejects grader results that omit expectations', () => {
   const raw = JSON.stringify({
     expectations: [
@@ -621,3 +746,85 @@ test('materializes a git baseline and applies a working-tree patch', () => {
     fs.rmSync(workspace, { recursive: true, force: true });
   }
 });
+
+
+test('fixture baseline commits ignore inherited user signing requirements', () => {
+  const root = makeSandbox();
+  const config = path.join(root, 'global.gitconfig');
+  const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'fixture-signing-test-'));
+  try {
+    fs.writeFileSync(config, '[commit]\n\tgpgsign = true\n[gpg]\n\tprogram = definitely-missing-eval-signer\n');
+    const result = spawnSync(process.execPath, ['-e', `
+      const fs = require('node:fs');
+      const { materializeWorkspace } = require(${JSON.stringify(path.join(root, 'scripts', 'run-evals.js'))});
+      let workspace;
+      try { workspace = materializeWorkspace({ files: ['project/context.txt'] }); }
+      finally { if (workspace) fs.rmSync(workspace, { recursive: true, force: true }); }
+    `], { cwd: root, encoding: 'utf8', env: { ...process.env, GIT_CONFIG_GLOBAL: config, TMPDIR: temp, TMP: temp, TEMP: temp } });
+    assert.equal(result.status, 0, result.stdout + result.stderr);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+    fs.rmSync(temp, { recursive: true, force: true });
+  }
+});
+
+test('rejects duplicate behavioral IDs before they can overwrite a grading slot', () => {
+  const root = makeSandbox();
+  try {
+    writeSkill(root, 'alpha-skill', 'Handles alpha widgets. Use when changing alpha widgets.');
+    const evalCase = completeCase('alpha-skill', 'change alpha widget');
+    evalCase.evals.push({ ...behavioralEval(), prompt: 'A different evaluation' });
+    writeJson(path.join(root, 'evals', 'cases', 'alpha-skill.json'), evalCase);
+    const result = run(root);
+    assert.equal(result.status, 1, result.stdout + result.stderr);
+    assert.match(result.stdout, /duplicate behavioral eval id=1/);
+    const dryRun = run(root, ['--behavioral', 'alpha-skill', '--dry-run']);
+    assert.equal(dryRun.status, 1, dryRun.stdout + dryRun.stderr);
+    assert.match(dryRun.stderr, /duplicate behavioral eval id=1/);
+  } finally { fs.rmSync(root, { recursive: true, force: true }); }
+});
+
+test('accepts distinct behavioral IDs including zero', () => {
+  const root = makeSandbox();
+  try {
+    writeSkill(root, 'alpha-skill', 'Handles alpha widgets. Use when changing alpha widgets.');
+    const evalCase = completeCase('alpha-skill', 'change alpha widget');
+    evalCase.evals.push({ ...behavioralEval(), id: 0 });
+    writeJson(path.join(root, 'evals', 'cases', 'alpha-skill.json'), evalCase);
+    const result = run(root);
+    assert.equal(result.status, 0, result.stdout + result.stderr);
+  } finally { fs.rmSync(root, { recursive: true, force: true }); }
+});
+
+test('removes the throwaway workspace when fixture setup fails', () => {
+  const root = makeSandbox();
+  const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'workspace-cleanup-test-'));
+  try {
+    const result = spawnSync(process.execPath, ['-e', `
+      const { materializeWorkspace } = require(${JSON.stringify(path.join(root, 'scripts', 'run-evals.js'))});
+      try { materializeWorkspace({ files: ['project/context.txt', 'missing.txt'] }); }
+      catch (error) { console.error(error.message); }
+    `], { cwd: root, encoding: 'utf8', env: { ...process.env, TMPDIR: temp, TMP: temp, TEMP: temp } });
+    assert.equal(result.status, 0, result.stdout + result.stderr);
+    assert.match(result.stderr, /fixture listed in files\[\] not found/);
+    assert.deepEqual(fs.readdirSync(temp), [], 'partially copied fixture data must be removed');
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+    fs.rmSync(temp, { recursive: true, force: true });
+  }
+});
+
+
+test('loads quoted YAML skill identities using their decoded values', () => {
+  const root = makeSandbox();
+  try {
+    writeSkill(root, 'alpha', 'code unit tests');
+    const skill = path.join(root, 'skills', 'alpha', 'SKILL.md');
+    fs.writeFileSync(skill, fs.readFileSync(skill, 'utf8').replace('name: alpha', "name: 'alpha'")
+      .replace('description: code unit tests', 'description: "code unit tests"'));
+    writeJson(path.join(root, 'evals', 'cases', 'alpha.json'), completeCase('alpha', 'code unit tests'));
+    const result = run(root);
+    assert.equal(result.status, 0, result.stdout + result.stderr);
+    assert.match(result.stdout, /PASSED/);
+  } finally { fs.rmSync(root, { recursive: true, force: true }); }
+});