@givolt/i3-composer-agent 3.1.0 → 4.0.0

package/scripts/ui-prototype-dependencies-test.js

@@ -1,226 +0,0 @@
-'use strict';
-const test = require('node:test');
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const installation = path.join(__dirname, 'lib/installation.js');
-const skills = fs.existsSync(installation) ? require(installation).loadInstallation().skillsDirectory : path.resolve(__dirname, '../skills');
-const deps = require(path.join(skills, 'i3-ui-prototype/scripts/prototype-dependencies.cjs'));
-const installer = require(path.join(skills, 'i3-ui-prototype/scripts/optional-skill-install.cjs'));
-function workspace(t) {
-  const root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'i3-optional-deps-')));
-  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
-  const project = path.join(root, 'business'), home = path.join(root, 'home');
-  fs.mkdirSync(project); fs.mkdirSync(home);
-  return { project, home, env: {
-    ...process.env,
-    HOME: home, USERPROFILE: home,
-    XDG_CONFIG_HOME: path.join(home, '.config'),
-    CODEBUDDY_CONFIG_DIR: path.join(home, '.codebuddy'),
-    WORKBUDDY_CONFIG_DIR: path.join(home, '.workbuddy'),
-    CLAUDE_CONFIG_DIR: path.join(home, '.claude'),
-    CODEX_HOME: path.join(home, '.codex'),
-  } };
-}
-test('missing optional Skills do not fail read-only inspection or write files', t => {
-  const options = workspace(t), before = fs.readdirSync(options.project);
-  const result = deps.check(options);
-  assert.equal(result.status, 'checked');
-  assert.equal(result.professionalReady, false);
-  assert.equal(result.antdv.skill.availability, 'missing');
-  assert.equal(result.antdv.tool.availability, 'missing');
-  assert.deepEqual(fs.readdirSync(options.project), before);
-});
-test('later installed antDv Skill is detected without reinstalling i3 or claiming the CLI ready', t => {
-  const options = workspace(t);
-  assert.equal(deps.check(options).antdv.skill.availability, 'missing');
-  const root = path.join(options.project, '.codebuddy/skills/antdv');
-  fs.mkdirSync(root, { recursive: true }); fs.writeFileSync(path.join(root, 'SKILL.md'), 'official Skill fixture');
-  const result = deps.check(options);
-  assert.equal(result.antdv.skill.root, root);
-  assert.equal(result.antdv.skill.availability, 'available');
-  assert.equal(result.antdv.skill.invocationVerified, false);
-  assert.equal(result.antdv.tool.availability, 'missing');
-});
-test('CodeBuddy global antDv is reusable and current project entry has precedence', t => {
-  const options = workspace(t);
-  options.env.CODEBUDDY_CONFIG_DIR = path.join(options.home, 'legacy CodeBuddy config');
-  const global = path.join(options.env.CODEBUDDY_CONFIG_DIR, 'skills/antdv');
-  fs.mkdirSync(global, { recursive: true }); fs.writeFileSync(path.join(global, 'SKILL.md'), 'global');
-  assert.equal(deps.skillAt(options.project, 'antdv', options).source, 'global-skill');
-  const local = path.join(options.project, '.codebuddy/skills/antdv');
-  fs.mkdirSync(local, { recursive: true }); fs.writeFileSync(path.join(local, 'SKILL.md'), 'local');
-  assert.equal(deps.skillAt(options.project, 'antdv', options).root, local);
-});
-test('global UIUX detection reuses enabled user plugins, preserves disabled status and excludes business plugins', t => {
-  const options = { ...workspace(t), host: 'codebuddy', scope: 'global' }, config = path.join(options.home, '.codebuddy');
-  const plugin = path.join(options.home, 'uiux-plugin'), root = path.join(plugin, 'skills/ui-ux-pro-max'), id = 'ui-ux-pro-max@fixture';
-  const write = (file, content) => { fs.mkdirSync(path.dirname(file), { recursive: true }); fs.writeFileSync(file, typeof content === 'string' ? content : JSON.stringify(content)); };
-  write(path.join(plugin, '.codebuddy-plugin/plugin.json'), { name: 'ui-ux-pro-max', version: '2.15.0' });
-  for (const file of ['SKILL.md', 'scripts/core.py', 'scripts/design_system.py', ...['ux-guidelines','styles','colors','typography','products','landing','ui-reasoning'].map(name => `data/${name}.csv`)]) write(path.join(root, file), 'synthetic fixture');
-  write(path.join(root, 'scripts/search.py'), 'import json\nprint(json.dumps({"domain":"ux","results":[{"id":"synthetic-probe-only"}]}))\n');
-  write(path.join(config, 'settings.json'), { enabledPlugins: { [id]: true } });
-  const record = { scope: 'user', installPath: plugin, version: '2.15.0' };
-  write(path.join(config, 'plugins/installed_plugins.json'), { version: 2, plugins: { [id]: [record] } });
-  const result = deps.check(options);
-  assert.equal(result.uiux.root, root);
-  assert.equal(result.uiux.availability, 'available');
-  assert.equal(result.uiux.source, 'codebuddy-plugin');
-  write(path.join(config, 'settings.json'), { enabledPlugins: { [id]: false } });
-  assert.equal(deps.check(options).uiux.availability, 'disabled');
-  write(path.join(config, 'settings.json'), { enabledPlugins: { [id]: true } });
-  write(path.join(config, 'plugins/installed_plugins.json'), { version: 2, plugins: { [id]: [{ ...record, scope: 'project', projectPath: options.project }] } });
-  assert.equal(deps.check(options).uiux.availability, 'missing');
-});
-test('dependency CLI rejects unintended writes and unrelated hosts', () => {
-  assert.throws(() => deps.parse(['check', '--force']), /Invalid option/);
-  assert.throws(() => deps.check({ host: 'not-a-host' }), /Unknown host/);
-  assert.throws(() => deps.parse(['update']), /check or install/);
-});
-function officialFixture(name, folder) {
-  const skill = path.join(folder, 'skill'), tool = path.join(folder, 'tool');
-  fs.mkdirSync(skill); fs.mkdirSync(tool);
-  fs.writeFileSync(path.join(skill, 'SKILL.md'), `---\nname: ${name === 'uiux' ? 'ui-ux-pro-max' : 'antdv'}\n---\nOfficial fixture; not host invocation evidence.\n`);
-  if (name === 'uiux') {
-    for (const file of ['scripts/search.py', 'scripts/core.py', 'scripts/design_system.py', 'data/ux-guidelines.csv']) {
-      fs.mkdirSync(path.dirname(path.join(skill, file)), { recursive: true }); fs.writeFileSync(path.join(skill, file), 'fixture');
-    }
-  } else {
-    const pkg = path.join(tool, 'node_modules/@antdv-next/cli'); fs.mkdirSync(pkg, { recursive: true });
-    fs.writeFileSync(path.join(pkg, 'package.json'), JSON.stringify({ name: '@antdv-next/cli', version: '0.0.0-beta.1', bin: { antdv: 'cli.cjs' } }));
-    fs.writeFileSync(path.join(pkg, 'cli.cjs'), 'process.stdout.write(JSON.stringify({name:"Table",props:[]}));');
-  }
-  return { skill, tool };
-}
-test('explicit skip never downloads, writes or permanently disables dependencies', async t => {
-  const options = workspace(t), before = fs.readdirSync(options.project);
-  const result = await installer.install({ ...options, skills: 'none' }, { prepare() { throw new Error('Unexpected download'); } });
-  assert.equal(result.status, 'skipped');
-  assert.deepEqual(fs.readdirSync(options.project), before);
-  assert.deepEqual(installer.selection('uiux,antdv'), ['uiux', 'antdv']);
-  assert.throws(() => installer.selection('none,uiux'), /Choose/);
-});
-test('optional antDv installation preserves user files and a later invocation reuses the Skill', async t => {
-  const options = workspace(t);
-  fs.writeFileSync(path.join(options.project, 'PRD.md'), 'human requirements');
-  const services = { prepare: officialFixture, progress() {} };
-  const result = await installer.install({ ...options, skills: 'antdv' }, services);
-  assert.equal(result.status, 'installed');
-  assert.equal(result.detection.antdv.skill.availability, 'available');
-  assert.equal(fs.readFileSync(path.join(options.project, 'PRD.md'), 'utf8'), 'human requirements');
-  const skillFile = path.join(options.project, '.codebuddy/skills/antdv/SKILL.md');
-  fs.appendFileSync(skillFile, 'user edit'); const before = fs.readFileSync(skillFile);
-  const again = await installer.install({ ...options, skills: 'antdv' }, { prepare() { throw new Error('Existing tool must not be replaced'); } });
-  assert.equal(again.status, 'reused');
-  assert.deepEqual(fs.readFileSync(skillFile), before);
-});
-test('a failed second preparation publishes neither selected Skill and removes temporary files', async t => {
-  const options = workspace(t);
-  await assert.rejects(installer.install({ ...options, skills: 'uiux,antdv' }, {
-    progress() {}, prepare(name, folder) { if (name === 'antdv') throw new Error('simulated network failure'); return officialFixture(name, folder); },
-  }), /simulated network failure/);
-  assert.deepEqual(fs.readdirSync(options.project), []);
-});
-test('antDv error text or error JSON with exit zero is not successful knowledge', async t => {
-  const options = workspace(t);
-  await installer.install({ ...options, skills: 'antdv' }, { prepare: officialFixture, progress() {} });
-  const file = path.join(resultTool(options), 'node_modules/@antdv-next/cli/cli.cjs');
-  for (const output of ['Error: Table knowledge missing', JSON.stringify({ error: 'Table knowledge missing' })]) {
-    fs.writeFileSync(file, `process.stdout.write(${JSON.stringify(output)});`);
-    assert.equal(deps.check(options).antdv.tool.availability, 'unusable');
-  }
-});
-test('local CLI handoff uses the real Node entry with no PATH command and rejects failed business queries',async t=>{
- const options={...workspace(t),host:'workbuddy'};options.env.PATH='';
- await installer.install({...options,skills:'antdv'},{prepare:officialFixture,progress(){}});
- const detected=deps.check(options).antdv.tool;
- assert.equal(detected.nodePath,process.execPath);assert.equal(detected.invocationVerified,false);
- const result=deps.query({...options,kind:'info',component:'Table'});
- assert.equal(result.status,'queried');assert.equal(result.command[0],process.execPath);assert.equal(result.command[1],detected.entry);
- assert.equal(result.data.name,'Table');assert.equal(result.skillInvocationVerified,false);
- const file=path.join(resultTool(options),'node_modules/@antdv-next/cli/cli.cjs');
- fs.writeFileSync(file,'const v=process.argv[process.argv.indexOf("--ver")+1];process.stdout.write(v==="1.5.3"?"Error: missing target knowledge":JSON.stringify({name:"Table",props:[]}));');
- assert.equal(deps.query({...options,kind:'info',component:'Table',version:'1.5.3'}).status,'failed');
- assert.throws(()=>deps.query({...options,kind:'upgrade'}),/read-only/);
-});
-function resultTool(options) { return path.join(deps.check(options).locations.toolsDirectory, 'antdv-cli'); }
-for (const host of ['codebuddy', 'workbuddy', 'codex', 'claude-code']) for (const scope of ['project', 'global']) {
-  test(`${host} ${scope} optional installation keeps all tools inside the selected host root`, async t => {
-    const options = { ...workspace(t), host, scope };
-    const result = await installer.install({ ...options, skills: 'antdv' }, { prepare: officialFixture, progress() {} });
-    assert.equal(result.detection.antdv.tool.source, `${scope}-tool`);
-    assert.ok(fs.existsSync(path.join(resultTool(options), 'node_modules/@antdv-next/cli/package.json')));
-    assert.equal(fs.existsSync(path.join(options.project, '.prototype-tools')), false);
-    assert.equal(fs.existsSync(path.join(options.project, 'package.json')), false);
-    if (scope === 'global') assert.deepEqual(fs.readdirSync(options.project), []);
-  });
-}
-test('an available global tool is reused by a later project without project writes', async t => {
-  const options = workspace(t);
-  await installer.install({ ...options, host: 'codex', scope: 'global', skills: 'antdv' }, { prepare: officialFixture, progress() {} });
-  const result = await installer.install({ ...options, host: 'codex', skills: 'antdv' }, { prepare() { throw new Error('No download expected'); } });
-  assert.equal(result.status, 'reused');
-  assert.equal(result.detection.antdv.tool.source, 'global-tool');
-  assert.deepEqual(fs.readdirSync(options.project), []);
-});
-test('legacy independent tools stay readable until an explicit owned migration', async t => {
-  const options = workspace(t), legacy = path.join(options.project, '.prototype-tools/antdv-cli');
-  const stage = path.join(options.project, 'fixture'); fs.mkdirSync(stage);
-  const prepared = officialFixture('antdv', stage);
-  fs.mkdirSync(path.dirname(legacy)); fs.renameSync(prepared.tool, legacy); fs.rmSync(stage, { recursive: true });
-  fs.writeFileSync(path.join(legacy, 'UPSTREAM-ORIGIN.json'), JSON.stringify({ ...require(path.join(skills, 'i3-ui-prototype/assets/optional-skills/sources.json')).antdv, installer: 'i3 optional dependency preparation; official Skill body unchanged' }));
-  assert.equal(deps.check(options).antdv.tool.source, 'legacy-project-tool');
-  await installer.install({ ...options, skills: 'antdv' }, { prepare: officialFixture, progress() {} });
-  assert.equal(fs.existsSync(legacy), true);
-  fs.writeFileSync(path.join(options.project, '.prototype-tools/user-note.txt'), 'keep this location');
-  await installer.install({ ...options, scope: 'global', skills: 'antdv' }, { prepare: officialFixture, progress() {} });
-  assert.equal(deps.check(options).antdv.tool.source, 'global-tool', 'normal lookup prefers a current global tool over legacy');
-  const result = await installer.install({ ...options, skills: 'antdv', migrateTools: true }, { prepare() { throw new Error('No download expected'); } });
-  assert.equal(result.status, 'migrated');
-  assert.equal(result.detection.antdv.tool.source, 'project-tool');
-  assert.equal(fs.existsSync(legacy), false);
-  assert.equal(fs.readFileSync(path.join(options.project, '.prototype-tools/user-note.txt'), 'utf8'), 'keep this location');
-});
-test('legacy mixed tools without i3 ownership remain untouched by migration', async t => {
-  const options = workspace(t), stage = path.join(options.project, 'fixture'); fs.mkdirSync(stage);
-  const prepared = officialFixture('antdv', stage), legacy = path.join(options.project, '.prototype-tools/antdv-cli');
-  fs.mkdirSync(path.dirname(legacy)); fs.renameSync(prepared.tool, legacy); fs.rmSync(stage, { recursive: true });
-  await assert.rejects(installer.install({ ...options, skills: 'antdv', migrateTools: true }, { prepare() { throw new Error('No download expected'); } }), /ownership|来源|归属/);
-  assert.equal(deps.check(options).antdv.tool.source, 'legacy-project-tool');
-});
-test('a broken project tool is reported instead of silently borrowing a healthy global tool', async t => {
-  const options = workspace(t);
-  await installer.install({ ...options, scope: 'global', skills: 'antdv' }, { prepare: officialFixture, progress() {} });
-  const local = path.join(options.project, '.codebuddy/tools/i3-prototype/antdv-cli/node_modules/@antdv-next/cli');
-  fs.mkdirSync(local, { recursive: true }); fs.writeFileSync(path.join(local, 'package.json'), '{broken');
-  assert.equal(deps.check(options).antdv.tool.availability, 'unusable');
-  assert.equal(deps.check({ ...options, scope: 'global' }).antdv.tool.availability, 'available');
-  await assert.rejects(installer.install({ ...options, skills: 'antdv' }), /Existing tool unusable/);
-  assert.equal(fs.readFileSync(path.join(local, 'package.json'), 'utf8'), '{broken');
-});
-test('failed post-migration execution restores the old location and removes newly created destinations', async t => {
-  const options = workspace(t), stage = path.join(options.project, 'fixture'); fs.mkdirSync(stage);
-  const prepared = officialFixture('antdv', stage), legacy = path.join(options.project, '.prototype-tools/antdv-cli');
-  fs.mkdirSync(path.dirname(legacy)); fs.renameSync(prepared.tool, legacy); fs.rmSync(stage, { recursive: true });
-  const file = path.join(legacy, 'node_modules/@antdv-next/cli/cli.cjs');
-  fs.writeFileSync(file, 'if(__dirname.includes("tools/i3-prototype"))process.exit(1);process.stdout.write(JSON.stringify({name:"Table",props:[]}));');
-  fs.writeFileSync(path.join(legacy, 'UPSTREAM-ORIGIN.json'), JSON.stringify({ ...require(path.join(skills, 'i3-ui-prototype/assets/optional-skills/sources.json')).antdv, installer: 'i3 optional dependency preparation; official Skill body unchanged' }));
-  await assert.rejects(installer.install({ ...options, skills: 'antdv', migrateTools: true }, { prepare: officialFixture, progress() {} }), /tool query failed/);
-  assert.equal(deps.check(options).antdv.tool.source, 'legacy-project-tool');
-  assert.equal(fs.existsSync(path.join(options.project, '.codebuddy')), false);
-  assert.ok(fs.existsSync(file));
-});
-test('unusable existing UIUX resources are preserved without attempting a download', async t => {
-  const options = workspace(t), target = path.join(options.project, '.codebuddy/skills/ui-ux-pro-max');
-  fs.mkdirSync(target, { recursive: true }); fs.writeFileSync(path.join(target, 'SKILL.md'), 'human-owned incomplete skill');
-  await assert.rejects(installer.install({ ...options, skills: 'uiux' }, { prepare() { throw new Error('must not download'); } }), /Existing Skill preserved/);
-  assert.equal(fs.readFileSync(path.join(target, 'SKILL.md'), 'utf8'), 'human-owned incomplete skill');
-});
-test('optional installer rejects symlink escapes, including dangling targets, and bad download bytes', async t => {
-  const options = workspace(t), outside = path.join(options.project, 'outside');
-  fs.symlinkSync(outside, path.join(options.project, '.codebuddy'), 'dir');
-  await assert.rejects(installer.install({ ...options, skills: 'antdv' }, { prepare: officialFixture }), /symlink/);
-  assert.equal(fs.existsSync(outside), false);
-  assert.throws(() => installer.verify(Buffer.from('altered'), '0'.repeat(64)), /integrity mismatch/);
-});

package/scripts/ui-prototype-devtools-test.js

@@ -1,53 +0,0 @@
-'use strict';
-const test=require('node:test'),assert=require('node:assert/strict'),fs=require('node:fs'),path=require('node:path'),os=require('node:os');
-const installationFile=path.join(__dirname,'lib/installation.js');
-const skills=fs.existsSync(installationFile)?require(installationFile).loadInstallation().skillsDirectory:path.resolve(__dirname,'../skills');
-const review=require(path.join(skills,'i3-ui-prototype/scripts/native-devtools.cjs'));
-// Synthetic contract fixtures only; none is browser or host invocation evidence.
-function fixture(t){
- const directory=fs.mkdtempSync(path.join(os.tmpdir(),'devtools-review-'));t.after(()=>fs.rmSync(directory,{recursive:true,force:true}));
- const write=(file,value)=>{const full=path.join(directory,file);fs.mkdirSync(path.dirname(full),{recursive:true});fs.writeFileSync(full,Buffer.isBuffer(value)||typeof value==='string'?value:JSON.stringify(value));};
- const current={revision:'r001',digest:'a'.repeat(64)},build={buildId:'b-fixture',buildDigest:'b'.repeat(64)};
- write('inputs/acceptance.json',{browserReview:review.policy()});
- const png=Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+ip1sAAAAASUVORK5CYII=','base64');
- const observations={};for(const kind of review.KINDS){const evidence=`qa/fixture/${kind}.${kind==='screenshot'?'png':kind==='performance'?'json':'txt'}`;write(evidence,kind==='screenshot'?png:kind==='performance'?{traceEvents:[{name:'synthetic-fixture',ts:1}]}:`Synthetic ${kind} fixture; not executed`);observations[kind]={status:'passed',summary:'Synthetic guard fixture, not executed',evidence};}
- const report={schemaVersion:1,status:'passed',revision:current.revision,candidateDigest:current.digest,...build,executor:'synthetic-unit-fixture',startedAt:'2026-10-17T00:00:00.000Z',completedAt:'2026-10-17T00:00:01.000Z',previewBaseURL:'http://127.0.0.1:4173/',skill:{name:review.policy().skill,toolCallId:'fixture-skill',evidence:'synthetic-fixture only'},mcp:{name:'chrome-devtools-mcp',version:'1.11.0',evidence:'synthetic-fixture only',calls:['evaluate_script','take_screenshot','list_console_messages','list_network_requests','take_snapshot','performance_start_trace','performance_stop_trace'].map((name,index)=>({tool:`mcp__chrome-devtools__${name}`,toolCallId:`fixture-${index}`}))},observations,openItems:[]};
- const lib={manifest:()=>current,verifyBuild:(_root,id)=>{assert.equal(id,build.buildId);return build;},claim:()=>{},release:()=>{}};
- return {directory,write,current,build,report,lib};
-}
-test('new DevTools policy is explicit; old fixed inputs remain read-only and not required',t=>{
- const f=fixture(t);assert.equal(review.check(f.directory,f.lib).status,'not-run');
- f.write('inputs/acceptance.json',{});const before=fs.readdirSync(f.directory);assert.deepEqual(review.check(f.directory,f.lib),{status:'not-required',required:false});assert.deepEqual(fs.readdirSync(f.directory),before);
-});
-test('fixed framework inputs retain all six DevTools observations and reject policy removal',t=>{
- const f=fixture(t);f.write('inputs/framework.json',{acceptance:{browserReview:review.policy()}});
- for(const mutate of [value=>delete value.browserReview,value=>value.browserReview.required=false,value=>value.browserReview.observations.pop()]){
-  const input={browserReview:review.policy()};mutate(input);f.write('inputs/acceptance.json',input);
-  assert.equal(review.check(f.directory,f.lib).status,'failed');assert.throws(()=>review.record(f.directory,f.report,f.lib),/policy|observations|opt out/);
- }
-});
-test('a review binds six actual-format evidence files to current candidate and build without attesting invocation',t=>{
- const f=fixture(t),before=f.current.digest;const result=review.record(f.directory,f.report,f.lib);
- assert.equal(result.status,'passed');assert.equal(result.invocationVerified,false);assert.equal(f.current.digest,before);
- const checked=review.check(f.directory,f.lib);assert.equal(checked.status,'current');assert.equal(Object.keys(checked.evidenceDigests).length,6);
- assert.match(checked.limitations,/host transcript/);
-});
-test('missing observation, stale identity and substituted evidence cannot pass the review gate',t=>{
- const f=fixture(t);
- for(const mutate of [r=>delete r.observations.network,r=>r.observations.console.status='not-run',r=>r.candidateDigest='c'.repeat(64),r=>r.buildDigest='c'.repeat(64),r=>r.skill.name='other-skill',r=>r.mcp.calls=r.mcp.calls.filter(c=>!c.tool.endsWith('performance_stop_trace')),r=>r.observations.network.evidence=r.observations.dom.evidence]){
-  const report=structuredClone(f.report);mutate(report);assert.throws(()=>review.record(f.directory,report,f.lib));assert.equal(fs.existsSync(path.join(f.directory,'qa/devtools-review.json')),false);
- }
- review.record(f.directory,f.report,f.lib);f.write(f.report.observations.network.evidence,'changed QA artifact');assert.equal(review.check(f.directory,f.lib).status,'failed');
-});
-test('Playwright ZIP and mislabeled screenshots do not become DevTools trace or PNG evidence',t=>{
- const f=fixture(t);f.write(f.report.observations.performance.evidence,Buffer.from('PK\x03\x04fake-playwright-trace'));assert.throws(()=>review.record(f.directory,f.report,f.lib),/trace|JSON/);
- f.write(f.report.observations.performance.evidence,{traceEvents:[{name:'fixture'}]});f.write(f.report.observations.screenshot.evidence,'not a PNG');assert.throws(()=>review.record(f.directory,f.report,f.lib),/PNG/);
-});
-test('a truncated PNG header is not a complete screenshot artifact',t=>{
- const f=fixture(t),fake=Buffer.alloc(24);Buffer.from([137,80,78,71,13,10,26,10]).copy(fake);fake.write('IHDR',12);fake.writeUInt32BE(1,16);fake.writeUInt32BE(1,20);f.write(f.report.observations.screenshot.evidence,fake);
- assert.throws(()=>review.record(f.directory,f.report,f.lib),/PNG/);
-});
-test('evidence paths cannot escape QA through traversal or symlinks',t=>{
- const f=fixture(t),r=structuredClone(f.report);r.observations.dom.evidence='../outside.txt';assert.throws(()=>review.record(f.directory,r,f.lib),/QA|path/);
- const link=path.join(f.directory,'qa/link.txt');fs.symlinkSync(path.join(f.directory,f.report.observations.dom.evidence),link);r.observations.dom.evidence='qa/link.txt';assert.throws(()=>review.record(f.directory,r,f.lib),/symlink/);
-});

package/scripts/ui-prototype-execution-evidence-test.js

@@ -1,62 +0,0 @@
-'use strict';
-const prototypeScripts=(()=>{const fs=require('node:fs'),path=require('node:path'),file=path.join(__dirname,'lib/installation.js');return path.join(fs.existsSync(file)?require(file).loadInstallation().skillsDirectory:path.resolve(__dirname,'../skills'),'i3-ui-prototype/scripts');})();
-const test = require('node:test');
-const assert = require('node:assert/strict');
-const E = require(prototypeScripts+'/execution-evidence.cjs');
-const use = (id, name, input) => ({ type: 'assistant', message: { role: 'assistant', content: [{ type: 'tool_use', id, name, input }] } });
-const result = (id, content, is_error = false) => ({ type: 'user', message: { role: 'user', content: [{ type: 'tool_result', tool_use_id: id, content, is_error }] } });
-const raw = rows => rows.map(row => JSON.stringify(row)).join('\n') + '\n';
-test('paired native results distinguish loaded skills from attempts and failures', () => {
-  const stream = raw([use('f1', 'Skill', { skill: 'i3-frontend-ui-engineering' }), result('f1', 'Full skill instructions'),
-    use('f2', 'Skill', { skill: 'antdv' }), result('f2', 'Not available', true), use('f3', 'Skill', { skill: 'ui-ux-pro-max' })]);
-  const calls = E.parse(stream);
-  assert.equal(calls[0].skill, 'frontend'); assert.equal(calls[0].success, true);
-  assert.equal(calls[1].success, false); assert.equal(calls[2].success, false);
-  assert.equal(E.loaded(calls, 'frontend').length, 1); assert.equal(E.loaded(calls, 'antdv').length, 0);
-});
-test('Read, forged names, zero-exit errors and duplicate IDs do not become valid skill loads', () => {
-  const calls = E.parse(raw([use('r1', 'Read', { file_path: 'SKILL.md' }), result('r1', 'instructions'),
-    use('b1', 'Bash', { command: 'node antdv info' }), result('b1', JSON.stringify({ exitCode: 0, stdout: 'Error: missing knowledge' }))]));
-  assert.equal(E.loaded(calls, 'frontend').length, 0); assert.equal(calls[1].success, false);
-  assert.throws(() => E.parse(raw([use('a', 'Skill', { skill: 'antdv' }), use('a', 'Skill', { skill: 'antdv' })])), /Duplicate/);
-  assert.throws(() => E.parse(raw([result('unknown', 'success')])), /unmatched|Unmatched/);
-});
-test('evidence references must resolve to the actual response and retain original order', () => {
-  const calls = E.parse(raw([use('a', 'Skill', { skill: 'antdv' }), result('a', 'official skill'), use('b', 'Bash', { command: 'node cli info Drawer' }), result('b', 'Drawer API') ]));
-  assert.equal(E.reference(calls, { toolCallId: 'b', resultDigest: calls[1].resultDigest }).name, 'Bash');
-  assert.throws(() => E.reference(calls, { toolCallId: 'b', resultDigest: '0'.repeat(64) }), /digest/);
-  assert.throws(() => E.reference(calls, { toolCallId: 'not-real' }), /missing/);
-  assert.ok(calls[0].resultLine < calls[1].requestLine);
-});
-test('malformed streams and model-written audit JSON are not accepted as native transcripts', () => {
-  assert.throws(() => E.parse('{broken\n'), /JSON/);
-  assert.throws(() => E.parse(JSON.stringify({ skill: 'frontend', used: true, passed: true })), /native|Native/);
-});
-// Structure captured from a real CodeBuddy Code 2.169.0 installation smoke run.
-// Skill instruction bodies are replaced; identities, pairing and status remain.
-const modern = (id='native-1', status='completed') => [
-  {type:'message',role:'user',sessionId:'session-169',content:[{type:'input_text',text:'请验收安装并加载前端 Skill'}]},
-  {type:'function_call',name:'Skill',callId:id,arguments:'{"skill":"i3-frontend-ui-engineering"}',sessionId:'session-169',message:{usage:{}}},
-  {type:'function_call_result',name:'Skill',callId:id,status,output:{type:'text',text:'Full frontend Skill instructions'},sessionId:'session-169'},
-  {type:'message',role:'assistant',sessionId:'session-169',content:[{type:'output_text',text:'安装检查已完成'}]},
-];
-test('CodeBuddy 2.169 flat messages and function calls retain native ordering and session evidence', () => {
-  const text=raw(modern()),calls=E.parse(text),description=E.describe(text);
-  assert.equal(E.loaded(calls,'frontend').length,1);
-  assert.equal(calls[0].sessionId,'session-169');
-  assert.equal(calls[0].requestLine,2);assert.equal(calls[0].resultLine,3);
-  assert.equal(description.prompts[0].text,'请验收安装并加载前端 Skill');
-  assert.equal(description.latestAssistant,'安装检查已完成');
-});
-test('flat failed, pending, empty and Read results cannot satisfy a frontend Skill gate', () => {
-  for(const status of ['failed','pending','cancelled'])assert.equal(E.loaded(E.parse(raw(modern('a',status))),'frontend').length,0);
-  const empty=modern();empty[2].output.text='';assert.equal(E.loaded(E.parse(raw(empty)),'frontend').length,0);
-  const read=modern();read[1].name=read[2].name='Read';read[1].arguments='{"file_path":"SKILL.md"}';
-  assert.equal(E.loaded(E.parse(raw(read)),'frontend').length,0);
-});
-test('flat native calls reject mismatched identity, malformed arguments and cross-session results', () => {
-  const wrong=modern();wrong[2].name='Read';assert.throws(()=>E.parse(raw(wrong)),/name|identity/i);
-  const bad=modern();bad[1].arguments='{broken';assert.throws(()=>E.parse(raw(bad)),/argument|JSON/i);
-  const session=modern();session[2].sessionId='other';assert.throws(()=>E.parse(raw(session)),/session/i);
-  const duplicate=modern();duplicate.splice(2,0,duplicate[1]);assert.throws(()=>E.parse(raw(duplicate)),/Duplicate/);
-});

package/scripts/ui-prototype-execution-gates-test.js

@@ -1,91 +0,0 @@
-'use strict';
-const prototypeScripts=(()=>{const fs=require('node:fs'),path=require('node:path'),file=path.join(__dirname,'lib/installation.js');return path.join(fs.existsSync(file)?require(file).loadInstallation().skillsDirectory:path.resolve(__dirname,'../skills'),'i3-ui-prototype/scripts');})();
-const test=require('node:test'),assert=require('node:assert/strict');
-const P=require(prototypeScripts+'/execution-policy.cjs');
-const E=require(prototypeScripts+'/execution-evidence.cjs');
-const G=require(prototypeScripts+'/execution-gates.cjs');
-test('native UI writes resolve relative paths from the actual tool cwd',()=>{
- assert.equal(G.uiWrite({name:'Write',cwd:'/work',input:{file_path:'prototypes/orders/app/src/Probe.vue'}},'/work/prototypes/orders'),true);
- assert.equal(G.uiWrite({name:'Write',cwd:'/work/prototypes/orders/app',input:{file_path:'src/Probe.vue'}},'/work/prototypes/orders'),true);
- assert.equal(G.uiWrite({name:'Write',cwd:'/work',input:{file_path:'other/app/src/Probe.vue'}},'/work/prototypes/orders'),false);
- assert.equal(G.uiWrite({name:'Write',input:{filePath:'/work/prototypes/orders/app/src/Probe.vue'}},'/work/prototypes/orders'),true);
-});
-function fixture() {
- const file='/work/prototypes/orders/app/src/Orders.vue',bytes='<Table />';
- const call=(toolCallId,name,input,result,line,skill)=>({toolCallId,name,input,result,requestLine:line+2,resultLine:line+3,success:true,resultDigest:E.sha(result),sessionId:'s1',contextLine:0,skill});
- const calls=[call('front','Skill',{},'frontend instructions',3,'frontend'),call('ant','Skill',{},'antdv instructions',5,'antdv'),call('query','Bash',{command:'antdv info Table'},'Table API: rowSelection',7),call('version','Read',{file_path:'/work/app/node_modules/antdv-next/package.json'},'{"version":"1.5.3"}',9),call('write','Write',{file_path:file},'saved',11)];
- const policy=P.create({mode:'template'}),current={digest:'candidate',inputDigest:'input',revision:'r001'};
- const binding={schemaVersion:1,runId:'r1',sessionId:'s1',projectKey:'p1',directory:'/work/prototypes/orders',instanceId:'instance',policyDigest:policy.digest,inputDigest:'input',entryLine:1};
- calls.push(call('begin','Bash',{command:'node /skills/native-pilot.cjs execution-begin /work/prototypes/orders'},JSON.stringify({status:'bound',runId:'r1',sessionId:'s1',directory:binding.directory}),0));
- const proof={schemaVersion:1,runId:'r1',sessionId:'s1',projectKey:'p1',policyDigest:policy.digest,candidateDigest:'candidate',inputDigest:'input',revision:'r001',frontend:{toolCallId:'front',files:[{path:'app/src/Orders.vue',sha256:E.sha(bytes)}],requirementIds:['R1']},official:{skill:{toolCallId:'ant'},version:{toolCallId:'version',quote:'"version":"1.5.3"'},queries:[{component:'Table',toolCallId:'query',quote:'Table API: rowSelection'}]},templateChoice:{quote:'template mode'}};
- return {policy,current,binding,proof,source:{calls,contextLine:0,prompts:[{line:1,text:'generate prototype in template mode',digest:'prompt'}]},scope:{requirements:[{id:'R1'}]},files:{'app/src/Orders.vue':bytes},implementation:{bindings:[{status:'implemented',components:['Table'],files:[{path:'app/src/Orders.vue'}]}]},frameworkVersion:'1.5.3'};
-}
-test('a native frontend load is required before the first actual UI write in both modes',()=>{
- const f=fixture();assert.equal(G.evaluate(f,'implementation').status,'passed');
- f.source.calls[0].success=false;assert.equal(G.evaluate(f,'implementation').status,'failed');
- f.source.calls[0].success=true;f.source.calls[0].resultLine=14;assert.match(G.evaluate(f,'implementation').errors.join(),/before/);
-});
-test('IDE relative write evidence uses its bound workspace while legacy evidence keeps its contract',()=>{
- const f=fixture();f.source.format='codebuddy-ide-index-v1';f.binding.project='/work';f.source.calls.find(c=>c.name==='Write').input.file_path='prototypes/orders/app/src/Orders.vue';
- assert.equal(G.evaluate(f,'implementation').status,'passed');
-});
-test('current context, task and artifact identities reject replay and changed inputs',()=>{
- for(const mutate of [f=>f.proof.runId='other',f=>f.proof.inputDigest='old',f=>f.source.contextLine=10,f=>f.source.calls[0].sessionId='s2',f=>f.binding.entryLine=20]){const f=fixture();mutate(f);assert.equal(G.evaluate(f,'implementation').status,'failed');}
-});
-test('reading a skill, adapted metadata, or incomplete review mappings cannot pass',()=>{
- const f=fixture();f.source.calls[0].skill=null;assert.equal(G.evaluate(f,'implementation').status,'failed');
- const g=fixture();g.proof.frontend.files=[];assert.equal(G.evaluate(g,'implementation').status,'failed');
- const h=fixture();h.proof.frontend.requirementIds=[];assert.equal(G.evaluate(h,'implementation').status,'failed');
-});
-test('new WorkBuddy implementation uses the shared design gate and rechecks recovery references',()=>{
- const f=fixture();f.policy=P.create({id:P.AUTO_ID,host:'workbuddy',mode:'template'});
- Object.assign(f.binding,{host:'workbuddy',identitySource:'native-client',policyDigest:f.policy.digest});f.proof.policyDigest=f.policy.digest;
- assert.equal(G.evaluate(f,'implementation').status,'passed');
- f.binding.recovery={status:'recovered',invocations:[{skill:'frontend',toolCallId:'front',resultDigest:f.source.calls[0].resultDigest,requestLine:5,resultLine:6,feedbackLine:1}],retry:{toolCallId:'write'}};
- assert.equal(G.evaluate(f,'implementation').status,'passed');
- f.binding.recovery.retry.toolCallId='invented';assert.equal(G.evaluate(f,'implementation').status,'failed');
- delete f.binding.recovery;f.source.calls.find(call=>call.skill==='antdv').success=false;
- assert.equal(G.evaluate(f,'implementation').status,'failed','Official loading cannot wait until finalization in the new policy');
-});
-function stageRecoveryFixture(){
- const f=fixture(),result='native build succeeded';
- f.source.calls.push({toolCallId:'retry-build',name:'Bash',input:{command:'node /skills/native-pilot.cjs build /work/prototypes/orders'},result,requestLine:13,resultLine:14,success:true,resultDigest:E.sha(result),sessionId:'s1'});
- f.binding.recovery={status:'recovered',invocations:[],retry:{toolCallId:'retry-build',resultDigest:E.sha(result),kind:'stage',stage:'implementation',operation:'build',feedbackLine:12}};
- return f;
-}
-test('the shared gate accepts an actual matching successful stage retry after recovery',()=>{
- const f=stageRecoveryFixture();const result=G.evaluate(f,'implementation');assert.equal(result.status,'passed',result.errors?.join('; '));
-});
-test('stage recovery rejects a wrong operation, stage, root, unsafe command or failed native result',()=>{
- for(const change of [f=>f.binding.recovery.retry.operation='finalize',f=>f.binding.recovery.retry.stage='delivery',f=>f.source.calls.at(-1).input.command='node /skills/native-pilot.cjs build /other/prototypes/orders',f=>f.source.calls.at(-1).input.command+='; echo fake',f=>f.source.calls.at(-1).success=false,f=>f.binding.recovery.retry.kind='ui-write',f=>f.binding.recovery.retry.feedbackLine=14]){
-  const f=stageRecoveryFixture();change(f);assert.equal(G.evaluate(f,'implementation').status,'failed');
- }
-});
-test('official query references must be successful, relevant, and version checked',()=>{
- const f=fixture();assert.equal(G.evaluate(f,'design').status,'passed');
- f.proof.official.queries[0].quote='invented';assert.equal(G.evaluate(f,'design').status,'failed');
- const g=fixture();g.source.calls[2].input.command='antdv probe';assert.equal(G.evaluate(g,'design').status,'failed');
- const h=fixture();h.source.calls[3].result='{"version":"1.5.2"}';assert.equal(G.evaluate(h,'design').status,'failed');
-});
-test('professional requires actual UIUX execution; explicit template choice cannot be invented',()=>{
- const f=fixture();f.policy=P.create({mode:'professional'});f.binding.policyDigest=f.proof.policyDigest=f.policy.digest;assert.match(G.evaluate(f,'design').errors.join(),/UIUX/);
- const g=fixture();g.proof.templateChoice.quote='use template now';assert.equal(G.evaluate(g,'design').status,'failed');
- const h=fixture();h.proof.templateChoice.quote='template';h.source.prompts[0].text='参考 template 制作专业增强原型';assert.equal(G.evaluate(h,'design').status,'failed');
-});
-test('missing current build, fake browser IDs, and self-written passed booleans cannot finish',()=>{
- const f=fixture();f.proof.build={toolCallId:'query'};assert.equal(G.evaluate(f,'build').status,'failed');
- f.proof.browser={passed:true};assert.equal(G.evaluate(f,'browser').status,'failed');assert.equal(G.evaluate(f,'delivery').status,'failed');
-});
-test('the shared gate can correlate a complete synthetic chain and rejects unrelated native facts',()=>{
- const f=fixture(),call=(toolCallId,name,input,result,line,skill)=>({toolCallId,name,input,result,requestLine:line,resultLine:line+1,success:true,resultDigest:E.sha(result),sessionId:'s1',contextLine:0,skill});
- f.build={buildId:'b1',buildDigest:'bytes',candidateDigest:'candidate'};
- f.source.calls.push(call('build','Bash',{command:'node /skills/native-pilot.cjs build /work/prototypes/orders'},'{"buildId":"b1","buildDigest":"bytes"}',15),call('browser','Skill',{},'browser instructions',17,'browser'),call('preview','mcp__chrome_devtools__navigate_page',{url:'http://127.0.0.1:4173/'},'opened',19),call('fact','mcp__chrome_devtools__evaluate_script',{function:'() => document.title'},'{"candidate":"candidate","saved":true}',21));
- f.proof.build={toolCallId:'build'};f.business={previewBaseURL:'http://127.0.0.1:4173/',journeys:[{id:'save'}]};
- const methods={dom:'evaluate_script',screenshot:'take_screenshot',console:'list_console_messages',network:'list_network_requests',accessibility:'take_snapshot',performance:'performance_stop_trace'};
- const refs=Object.fromEntries(Object.entries(methods).map(([kind,method],i)=>{const id=kind==='dom'?'fact':kind;if(kind!=='dom')f.source.calls.push(call(id,`mcp__chrome_devtools__${method}`,{},'synthetic observation',24+i*2));return [kind,{toolCallId:id,quote:kind==='dom'?'candidate':'synthetic observation'}];}));
- f.devtools={skill:{toolCallId:'browser'},mcp:{calls:Object.entries(methods).map(([kind,method])=>({toolCallId:refs[kind].toolCallId,tool:`mcp__chrome_devtools__${method}`}))}};
- f.proof.browser={skill:{toolCallId:'browser'},preview:{toolCallId:'preview'},identity:{toolCallId:'fact',quote:'candidate'},observations:refs,facts:[{scenarioId:'save',checkIndex:0,toolCallId:'fact',quote:'"saved":true'}]};
- f.assertions={schemaVersion:1,scenarios:[{scenarioId:'save',checks:[{method:'evaluate_script',pointer:'/saved',operator:'equals',expected:true}]}]};
- assert.equal(G.evaluate(f,'delivery').status,'passed');
- f.source.calls.find(c=>c.toolCallId==='fact').result='{"candidate":"candidate","saved":false}';f.proof.browser.facts[0].quote='"saved":false';assert.equal(G.evaluate(f,'delivery').status,'failed');
-});

package/scripts/ui-prototype-execution-policy-test.js

@@ -1,53 +0,0 @@
-'use strict';
-const prototypeScripts=(()=>{const fs=require('node:fs'),path=require('node:path'),file=path.join(__dirname,'lib/installation.js');return path.join(fs.existsSync(file)?require(file).loadInstallation().skillsDirectory:path.resolve(__dirname,'../skills'),'i3-ui-prototype/scripts');})();
-const test = require('node:test');
-const assert = require('node:assert/strict');
-const P = require(prototypeScripts+'/execution-policy.cjs');
-test('CodeBuddy policy defaults never confuse a PRD scope file with project/global installation scope',()=>{
- const options={host:'codebuddy',scope:'/work/prototypes/.preparation/orders/scope.json'};
- const result=P.creationOptions(options,{name:'i3-composer-agent',scope:'global',agents:['codebuddy']});
- assert.equal(result.scope,options.scope);assert.equal(result.executionPolicy,P.AUTO_ID);
- assert.equal(P.creationOptions({host:'codex'},{name:'i3-composer-agent'}).executionPolicy,undefined);
- assert.equal(P.creationOptions({},null).executionPolicy,undefined);
- assert.equal(P.creationOptions({},{name:'i3-composer-agent',agents:['workbuddy']}).executionPolicy,P.AUTO_ID);
- assert.throws(()=>P.creationOptions({},{name:'i3-composer-agent',agents:['codebuddy','workbuddy']}),/actual --host/);
-});
-test('new Buddy policy supports WorkBuddy without changing the legacy policy',()=>{
- const old=P.create();assert.equal(old.id,'codebuddy-ab-v1');assert.equal(old.schemaVersion,1);
- const policy=P.create({host:'workbuddy',id:P.AUTO_ID});assert.equal(policy.host,'workbuddy');
- assert.equal(P.validate(policy).id,'buddy-ab-v2');assert.deepEqual(policy.recovery,{perMissing:2,total:6});
- assert.ok(P.requirements(policy,'implementation').includes('antdv'));
- assert.throws(()=>P.create({host:'workbuddy',id:P.ID}),/legacy|CodeBuddy/);
-});
-
-test('analysis and inspection never acquire implementation requirements', () => {
-  for (const operation of ['analyze', 'inspect', 'confirm-baseline']) {
-    const policy = P.create({ operation });
-    assert.deepEqual(P.requirements(policy, 'implementation-entry'), []);
-    assert.equal(policy.readOnly, true);
-  }
-});
-test('both generation modes require frontend loading before implementation', () => {
-  for (const operation of ['create', 'revise']) for (const mode of ['professional', 'template']) {
-    const policy = P.create({ operation, mode });
-    assert.ok(P.requirements(policy, 'implementation-entry').includes('frontend'));
-    assert.ok(P.requirements(policy, 'browser-entry').includes('browser'));
-    assert.equal(P.requirements(policy, 'design').includes('uiux'), mode === 'professional');
-  }
-});
-test('official framework fallback is explicit and cannot invent a native invocation', () => {
-  assert.ok(P.requirements(P.create({ officialCallable: true }), 'design').includes('antdv'));
-  assert.ok(P.requirements(P.create({ officialCallable: false }), 'design').includes('official-source'));
-  assert.equal(P.skillKey('fake-i3-frontend-ui-engineering'), null);
-  assert.equal(P.skillKey('i3-frontend-ui-engineering'), 'frontend');
-  assert.equal(P.skillKey('ui-ux-pro-max:ui-ux-pro-max'),'uiux');
-  assert.equal(P.skillKey('arbitrary:ui-ux-pro-max'),null);
-});
-test('policy changes are detected and unsupported hosts cannot silently acquire CodeBuddy support', () => {
-  const policy = P.create({ mode: 'template' });
-  assert.equal(P.validate(policy).digest, policy.digest);
-  assert.throws(() => P.validate({ ...policy, mode: 'professional' }), /policy|Policy/);
-  assert.throws(() => P.create({ host: 'codex' }), /CodeBuddy/);
-  assert.throws(() => P.create({ operation: 'write-anything' }), /operation/);
-  assert.throws(() => P.create({ mode: 'basic' }), /mode/);
-});

package/scripts/ui-prototype-execution-runtime-test.js

@@ -1,27 +0,0 @@
-'use strict';
-const prototypeScripts=(()=>{const fs=require('node:fs'),path=require('node:path'),file=path.join(__dirname,'lib/installation.js');return path.join(fs.existsSync(file)?require(file).loadInstallation().skillsDirectory:path.resolve(__dirname,'../skills'),'i3-ui-prototype/scripts');})();
-const test=require('node:test'),assert=require('node:assert/strict'),fs=require('node:fs'),path=require('node:path'),os=require('node:os');
-const lib=require(prototypeScripts+'/native-pilot-lib.cjs'),X=require(prototypeScripts+'/execution-runtime.cjs'),A=require(prototypeScripts+'/execution-assertions.cjs');
-function fixture(t){const project=fs.mkdtempSync(path.join(os.tmpdir(),'i3-execution-source-fixture-'));t.after(()=>fs.rmSync(project,{recursive:true,force:true}));const scope={schemaVersion:1,title:'Synthetic orders fixture',pages:[{id:'orders',title:'Orders',referencePage:'models-page',regions:[{id:'list',mode:'management-list'},{id:'editor',mode:'edit-form'}]}],requirements:[{id:'R1',text:'Synthetic source contract only',pages:['orders'],source:{type:'prd',reference:'fixture/R1',statement:'Synthetic fixture, not actual browser acceptance'}}],exemptions:[]};const scopeFile=path.join(project,'scope.json');fs.writeFileSync(scopeFile,JSON.stringify(scope));return {project,scope:scopeFile,expertMode:'template'};}
-test('new execution inputs freeze complete scenario expectations without changing legacy candidates',t=>{
- const options=fixture(t),legacy=lib.createPrototype({...options,id:'old'}),before=lib.manifest(legacy.directory);
- assert.equal(X.policy(legacy.directory),null);assert.equal(X.check(legacy.directory,'delivery',lib).status,'not-required');
- const assertions=A.template(options);assert.ok(assertions.scenarios.length>20);for(const scenario of assertions.scenarios)scenario.checks=[{method:'evaluate_script',pointer:'/synthetic',operator:'equals',expected:true}];
- const file=path.join(options.project,'assertions.json');fs.writeFileSync(file,JSON.stringify(assertions));
- const fresh=lib.createPrototype({...options,id:'strict',host:'codebuddy',executionPolicy:'codebuddy-ab-v1',executionAssertions:file});
- assert.equal(X.policy(fresh.directory).id,'codebuddy-ab-v1');assert.equal(lib.inspect(fresh.directory).status,'passed');
- assert.equal(X.check(fresh.directory,'delivery',lib).status,'failed');const stage=X.requireStage(fresh.directory,'implementation',lib);assert.equal(stage.status,'not-required');assert.equal(stage.auditHook,'retired');assert.equal(stage.invocationVerification,'unverified');
- assert.deepEqual(lib.manifest(legacy.directory),before);assert.deepEqual(fs.readdirSync(options.project).sort(),['assertions.json','prototypes','scope.json']);
-});
-test('missing or incomplete fixed facts cannot silently create a strict artifact or affect legacy state',t=>{
- const options=fixture(t);assert.throws(()=>lib.createPrototype({...options,id:'missing',host:'codebuddy',executionPolicy:'codebuddy-ab-v1'}),/execution-assertions/);
- assert.equal(fs.existsSync(path.join(options.project,'prototypes/missing')),false);
- const assertions=A.template(options);assert.throws(()=>A.validate(assertions,assertions.scenarios.map(s=>s.scenarioId)),/actual result/);
-});
-test('native values are extracted and compared with fixed inputs instead of a self-written passed flag',()=>{
- const check={method:'evaluate_script',pointer:'/form/errors',operator:'equals',expected:1};
- A.compare(A.extract(A.resultData('### Result\n```json\n{"form":{"errors":1}}\n```'),check.pointer),check);
- assert.throws(()=>A.compare(A.extract(A.resultData('{"passed":true,"form":{"errors":0}}'),check.pointer),check),/differs/);
- assert.throws(()=>A.extract({passed:true},check.pointer),/absent/);
- assert.throws(()=>A.resultData('passed'),/JSON/);
-});