@givolt/i3-composer-agent 2.3.2 → 2.3.4

package/scripts/prototype-generation-test.js

@@ -0,0 +1,99 @@
+'use strict';
+const test = require('node:test'), assert = require('node:assert/strict'), fs = require('node:fs'), path = require('node:path');
+const install = path.join(__dirname, 'lib/installation.js');
+const skills = fs.existsSync(install) ? require(install).loadInstallation().skillsDirectory : path.resolve(__dirname, '../skills');
+const root = path.join(skills, 'i3-ui-prototype'), templates = require(path.join(root, 'scripts/template-contract.cjs'));
+const generation = require(path.join(root, 'scripts/generation-contract.cjs'));
+function scope(pattern = 'management-list') {
+  return { schemaVersion: 3, moduleIds: ['assets'], pages: [{ id: 'assets', title: '资产', referencePage: 'models-page', regions: [{ id: 'main', mode: 'content', pattern }] }], requirements: [{ id: 'A-01', text: '按实际资产需求适配参考页面', pages: ['assets'], source: { type: 'prd', reference: 'fixture/A-01', statement: 'Synthetic contract fixture; not user or runtime acceptance.' } }], generation: { presentation: { layout: 'mixed', style: 'minimal', density: 'compact' }, decisions: [] } };
+}
+test('selected page patterns derive complete abilities and frozen customer presentation choices', () => {
+  const fixed = generation.compile(templates.loadBundledTemplate(), scope());
+  assert.deepEqual(fixed.presentation, { layout: 'mixed', style: 'minimal', density: 'compact' });
+  for (const capability of ['filter', 'selection', 'pagination', 'bulk', 'columns', 'feedback']) assert.ok(fixed.bindings.some(binding => binding.capabilityId === capability));
+  assert.ok(fixed.scenarios.some(scenario => scenario.id.includes('/columns/')));
+  assert.equal(fixed.bindings.find(binding => binding.capabilityId === 'pagination').parameters.defaultPageSize, 10);
+  assert.ok(fixed.referenceCoverage[0].events.length && fixed.referenceCoverage[0].nodes.length);
+});
+test('tree, tree table, wizard, canvas, permissions and dialogs have distinct required behavior', () => {
+  const snapshot = templates.loadBundledTemplate();
+  for (const [pattern, required] of Object.entries({ 'tree-list': ['hierarchy', 'pagination'], 'tree-table': ['hierarchy', 'columns'], wizard: ['wizard', 'dirty'], workflow: ['canvas', 'dirty'], permissions: ['authorization', 'hierarchy'], 'edit-form': ['edit', 'dialog', 'dirty'], detail: ['detail'] })) {
+    const fixed = generation.compile(snapshot, scope(pattern));
+    for (const capability of required) assert.ok(fixed.bindings.some(binding => binding.capabilityId === capability), `${pattern}/${capability}`);
+  }
+});
+test('unknown choices and deleting a required pattern capability fail instead of weakening the contract', () => {
+  const snapshot = templates.loadBundledTemplate(), input = scope(), fixed = generation.compile(snapshot, input);
+  for (const [key,value] of Object.entries({ layout: 'invented-layout', style: 'invented-style', density: 'invisible' })) {
+    const changed = structuredClone(input); changed.generation.presentation[key] = value;
+    assert.throws(() => generation.compile(snapshot, changed), /Unsupported|choice/);
+  }
+  fixed.bindings = fixed.bindings.filter(binding => binding.capabilityId !== 'columns');
+  assert.throws(() => generation.verify(snapshot, input, fixed), /contract|generation/i);
+  input.generation.decisions = [{ pageId: 'assets', capabilityId: 'columns', decision: 'not-applicable', requirementId: 'A-01', reason: 'Do not test columns' }];
+  assert.throws(() => generation.compile(snapshot, input), /required/i);
+});
+test('reference applicability is explicit and omissions remain pending until sourced decisions exist', () => {
+  const snapshot = templates.loadBundledTemplate(), input = scope(), fixed = generation.compile(snapshot, input);
+  assert.ok(fixed.pendingDecisions.length);
+  input.generation.decisions = fixed.pendingDecisions.map(item => ({ ...item, decision: 'not-applicable', requirementId: 'A-01', reason: 'This fixture intentionally narrows its stated business scope.' }));
+  assert.equal(generation.compile(snapshot, input).pendingDecisions.length, 0);
+  input.generation.decisions[0].reason = '';
+  assert.throws(() => generation.compile(snapshot, input), /reason|source/i);
+});
+test('frozen generation rules remain independent from future global catalog changes', () => {
+  const snapshot = templates.loadBundledTemplate(), input = scope(), fixed = generation.compile(snapshot, input);
+  assert.equal(generation.verify(snapshot, input, fixed).status, 'passed');
+  const changed = structuredClone(input); changed.pages[0].regions[0].pattern = 'tree-list';
+  assert.throws(() => generation.verify(snapshot, changed, fixed), /contract|generation/i);
+});
+test('business fields and actions remain sourced and receive individual acceptance identities', () => {
+  const snapshot = templates.loadBundledTemplate(), input = scope(), region = input.pages[0].regions[0];
+  region.fields = [{ id: 'name', label: '资产名称', kind: 'text', required: true, requirementId: 'A-01' }];
+  region.actions = [{ id: 'disable', label: '停用所选资产', kind: 'state-change', target: 'selected', outcome: '只有所选资产变为停用', requirementId: 'A-01' }];
+  const fixed = generation.compile(snapshot, input);
+  assert.equal(fixed.pages[0].regions[0].fields[0].label, '资产名称');
+  assert.ok(fixed.scenarios.some(item => item.id.endsWith('/action/disable')));
+  region.actions[0].requirementId = 'unknown';
+  assert.throws(() => generation.compile(snapshot, input), /source|requirement/);
+});
+test('unknown parameters and attempts to disable selected behavior fail validation', () => {
+  const snapshot = templates.loadBundledTemplate(), input = scope();
+  input.pages[0].regions[0].parameters = { columns: { enabled: false } };
+  assert.throws(() => generation.compile(snapshot, input), /parameter|Unsupported/i);
+});
+test('navigation groups preserve every declared page once and reject missing or duplicate routes', () => {
+  const snapshot = templates.loadBundledTemplate(), input = scope();
+  input.generation.navigation = [{ id: 'assets-group', title: '资产管理', children: [{ pageId: 'assets' }] }];
+  assert.equal(generation.compile(snapshot, input).navigation[0].children[0].key, 'assets');
+  input.generation.navigation[0].children.push({ pageId: 'assets' });
+  assert.throws(() => generation.compile(snapshot, input), /Duplicate|navigation/i);
+});
+test('every referenced functional node requires an explicit mapped or excluded disposition',()=>{
+ const templates=require(path.join(root,'scripts/template-contract.cjs')),lib=require(path.join(root,'scripts/generation-contract.cjs')),snapshot=templates.loadBundledTemplate();
+ const scope={schemaVersion:3,pages:[{id:'assets',title:'资产',referencePage:'models-page',regions:[{id:'list',pattern:'management-list'}]}],requirements:[{id:'A-01',pages:['assets'],source:{type:'prd',reference:'fixture',statement:'Fixture only.'}}],generation:{}};
+ const fixed=lib.compile(snapshot,scope);assert.ok(fixed.pendingReferenceElements.length);const first=fixed.pendingReferenceElements[0];
+ scope.generation.referenceDecisions=[{pageId:first.pageId,nodeIds:[first.nodeId],decision:'not-applicable',requirementId:'A-01',reason:'Synthetic fixture excludes this example node.'}];
+ assert.equal(lib.compile(snapshot,scope).pendingReferenceElements.length,fixed.pendingReferenceElements.length-1);
+ scope.generation.referenceDecisions.push(scope.generation.referenceDecisions[0]);assert.throws(()=>lib.compile(snapshot,scope),/duplicate reference element/);
+});
+test('fixed pagination and modal form scenarios match their actual parameters',()=>{
+ const templates=require(path.join(root,'scripts/template-contract.cjs')),lib=require(path.join(root,'scripts/generation-contract.cjs')),snapshot=templates.loadBundledTemplate();
+ const scope={schemaVersion:3,pages:[{id:'assets',title:'资产',referencePage:'models-page',regions:[{id:'list',pattern:'management-list',parameters:{pagination:{mode:'fixed',fixedPageSize:15,minimumTestPages:3}}},{id:'edit',pattern:'edit-form',parameters:{edit:{presentation:'modal'}}}]}],requirements:[{id:'A-01',pages:['assets'],source:{type:'prd',reference:'fixture',statement:'Fixture only.'}}]};
+ const fixed=lib.compile(snapshot,scope);assert.match(fixed.scenarios.find(s=>s.capabilityId==='pagination'&&s.id.endsWith('page-size')).expected,/固定容量/);assert.equal(fixed.bindings.find(s=>s.capabilityId==='dialog').parameters.presentation,'modal');
+ scope.pages[0].regions[1].parameters.dialog={presentation:'drawer'};assert.throws(()=>lib.compile(snapshot,scope),/presentation|呈现/);
+});
+test('optional shell and second-region capabilities can be adopted without borrowing another region binding',()=>{
+ const snapshot=templates.loadBundledTemplate(),input=scope();input.pages[0].regions.push({id:'second',pattern:'content'});
+ input.generation.decisions=[{pageId:'app-shell',regionId:'shell',capabilityId:'menu',decision:'adopted',requirementId:'A-01',reason:'Fixture shell menu.'},{pageId:'assets',regionId:'second',capabilityId:'columns',decision:'adopted',requirementId:'A-01',reason:'Fixture second table.'}];
+ const fixed=generation.compile(snapshot,input);assert.ok(fixed.bindings.some(b=>b.id==='app-shell/shell/menu'));assert.ok(fixed.bindings.some(b=>b.id==='assets/second/columns'));
+});
+test('adopted reference controls get individual scenarios even when they share a core capability',()=>{
+ const snapshot=templates.loadBundledTemplate(),input=scope(),draft=generation.compile(snapshot,input),node=draft.pendingReferenceElements.find(item=>item.events.length&&(!item.capabilities.length||item.capabilities.includes('interaction')));
+ input.generation.referenceDecisions=[{pageId:node.pageId,nodeIds:[node.nodeId],decision:'mapped',bindingIds:['app-shell/shell/interaction'],requirementId:'A-01',reason:'Fixture adapts this control to its sourced outcome.'}];
+ const fixed=generation.compile(snapshot,input);assert.ok(fixed.scenarios.some(item=>item.referenceNodeId===node.nodeId&&item.bindingId==='app-shell/shell/interaction'));
+});
+test('read-only planning exposes compact summaries and individual reference fragments',()=>{
+ const fixed=generation.compile(templates.loadBundledTemplate(),scope()),summary=generation.view(fixed);assert.equal(summary.readOnly,true);assert.ok(summary.referenceReview.pendingCount>0);assert.ok(!summary.definition);assert.ok(Buffer.byteLength(JSON.stringify(summary))<25000);
+ const group=summary.referenceReview.fragments[0],detail=generation.view(fixed,{page:group.pageId,fragment:group.fragment});assert.ok(detail.referenceReview.elements.length);assert.ok(detail.referenceReview.elements.every(item=>item.fragment===group.fragment));assert.throws(()=>generation.view(fixed,{page:'missing'}),/page/);
+});

package/scripts/prototype-inventory-test.js

@@ -0,0 +1,43 @@
+'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 install = path.join(__dirname, 'lib/installation.js');
+const skills = fs.existsSync(install) ? require(install).loadInstallation().skillsDirectory : path.resolve(__dirname, '../skills');
+const root = path.join(skills, 'i3-ui-prototype'), inventory = require(path.join(root, 'scripts/template-inventory.cjs'));
+const builtin = path.join(root, 'assets/templates/enterprise-admin');
+test('the complete reference inventory accounts for every route, fragment, component and event', () => {
+  const value = inventory.scan(builtin);
+  assert.equal(value.routes.length, 44); assert.equal(value.pages.length, 35); assert.equal(value.fragments.length, 93);
+  assert.equal(Object.keys(value.components).length, 116); assert.equal(value.eventCount, 595);
+  assert.equal(value.unknownComponents.length, 0);
+  assert.ok(value.fragments.every(fragment => fragment.nodes.length && fragment.digest));
+  assert.ok(value.fragments.every(fragment => fragment.nodes.every(node => node.id && node.tag && node.attributes)));
+  assert.equal(value.components.Tree.classification.capabilities.includes('hierarchy'), true);
+  assert.ok(value.files['reference/src/shared/columns.js']);
+  assert.ok(value.components.ColumnSettings.classification.source.endsWith('ColumnSettings.html'));
+});
+function fixture(t) {
+  const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'i3-inventory-'));
+  t.after(() => fs.rmSync(directory, { recursive: true, force: true }));
+  fs.writeFileSync(path.join(directory, 'index.html'), '<script type="application/json" id="prototype-offline-routes">[{"path":"/items","component":"./Items.js"}]</script>\n<template data-source="reference/Items.html">\n<main><template data-component="Button" data-on-click="save">保存</template></main>\n</template>\n');
+  fs.writeFileSync(path.join(directory, 'component-inventory.json'), JSON.stringify({ schemaVersion: 1, components: { Button: { kind: 'framework', capabilities: ['interaction'] } } }));
+  return directory;
+}
+test('a removed event, route or non-HTML source file cannot keep the old complete inventory', t => {
+  const directory = fixture(t), file = path.join(directory, 'index.html'), html = fs.readFileSync(file, 'utf8');
+  fs.writeFileSync(path.join(directory, 'domain.js'), 'original behavior');
+  const baseline = inventory.scan(directory);
+  for (const change of [html.replace(' data-on-click="save"', ''), html.replace('/items', '/different')]) {
+    fs.writeFileSync(file, change); assert.throws(() => inventory.verify(directory, baseline), /inventory|changed|清单/i);
+  }
+  fs.writeFileSync(file, html); fs.unlinkSync(path.join(directory, 'domain.js'));
+  assert.throws(() => inventory.verify(directory, baseline), /inventory|changed|清单/i);
+});
+test('unclassified components and unsafe template files fail closed', t => {
+  const directory = fixture(t), file = path.join(directory, 'index.html');
+  fs.appendFileSync(file, '\n<template data-source="reference/Other.html">\n<template data-component="NewWidget"></template>\n</template>\n');
+  assert.throws(() => inventory.scan(directory), /Unclassified.*NewWidget/);
+  fs.unlinkSync(file); fs.writeFileSync(file, '<script id="prototype-offline-routes">[]</script>');
+  fs.symlinkSync(os.tmpdir(), path.join(directory, 'outside'));
+  assert.throws(() => inventory.scan(directory), /symlink/i);
+});
+test('quoted comparison expressions remain complete nodes in replacement templates',t=>{const directory=fixture(t),file=path.join(directory,'index.html');fs.writeFileSync(file,fs.readFileSync(file,'utf8').replace('<main>','<main data-bind-visible="a > b && c < d">'));const fixed=inventory.scan(directory);assert.equal(fixed.fragments[0].nodes[0].attributes['data-bind-visible'],'a > b && c < d');});

package/scripts/prototype-locations-test.js

@@ -22,15 +22,36 @@ test('all registered project and global targets keep tools under their host base
     const toolBase = path.dirname(local.skillsDirectory) === options.project ? path.join(options.project, `.${agent.id}`) : path.dirname(local.skillsDirectory);
     assert.equal(local.toolsDirectory, path.join(toolBase, 'tools/i3-prototype'));
     assert.notEqual(local.toolsDirectory, path.join(options.project, 'tools/i3-prototype'));
+    assert.equal(local.cacheDirectory, path.join(toolBase, 'cache/i3-prototype'));
     if (agent.globalSkillsDir) {
       const global = locations.resolveLocations({ ...options, host: agent.id, scope: 'global' });
       assert.equal(global.toolsDirectory, path.join(path.dirname(global.skillsDirectory), 'tools/i3-prototype'));
       assert.ok(global.base.startsWith(options.home + path.sep));
+      assert.equal(global.cacheDirectory, path.join(global.base, 'cache/i3-prototype', global.projectKey));
     } else assert.throws(() => locations.resolveLocations({ ...options, host: agent.id, scope: 'global' }), /project installation only/);
   }
   assert.deepEqual(fs.readdirSync(options.project), []);
   assert.deepEqual(fs.readdirSync(options.home), []);
 });
+test('global caches distinguish same-name projects while path resolution remains read-only', t => {
+  const options = workspace(t), other = path.join(options.home, 'business'); fs.mkdirSync(other);
+  const first = locations.resolveLocations({ ...options, host: 'codebuddy', scope: 'global' });
+  const second = locations.resolveLocations({ ...options, project: other, host: 'codebuddy', scope: 'global' });
+  assert.notEqual(first.projectKey, second.projectKey);
+  assert.notEqual(first.cacheDirectory, second.cacheDirectory);
+  assert.deepEqual(fs.readdirSync(options.project), []);
+  assert.equal(fs.existsSync(path.join(options.home, '.codebuddy')), false);
+});
+test('CLI path output distinguishes installation scope from the preparation scope file without writes', async t => {
+  const options = workspace(t), cli = require(path.join(skills, 'i3-ui-prototype/scripts/native-pilot.cjs'));
+  for (const scope of ['project', 'global']) {
+    const result = await cli.main(['paths', '--project', options.project, '--home', options.home, '--host', 'codebuddy', '--scope', scope, '--id', 'assets']);
+    assert.equal(result.scope, scope);
+    assert.equal(result.scopeFile, path.join(options.project, 'prototypes/.preparation/assets/scope.json'));
+  }
+  assert.deepEqual(fs.readdirSync(options.project), []);
+  assert.deepEqual(fs.readdirSync(options.home), []);
+});
 test('CodeBuddy and WorkBuddy share project tools but use separate global roots; Codex follows agents', t => {
   const options = workspace(t), get = (host, scope = 'project') => locations.resolveLocations({ ...options, host, scope });
   assert.equal(get('codebuddy').toolsDirectory, get('workbuddy').toolsDirectory);

package/scripts/prototype-project-test.js

@@ -0,0 +1,183 @@
+'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 scripts = path.join(skills, 'i3-ui-prototype/scripts');
+const native = require(path.join(scripts, 'native-pilot-lib.cjs'));
+const registry = require(path.join(scripts, 'project-registry.cjs'));
+const read = file => JSON.parse(fs.readFileSync(file, 'utf8'));
+function fixture(t) {
+  const project = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'i3-project-')));
+  t.after(() => fs.rmSync(project, { recursive: true, force: true }));
+  const scope = { schemaVersion: 2, moduleIds: ['asset-management', 'work-orders', 'asset-management'], title: '资产原型',
+    pages: [{ id: 'assets', title: '资产台账', referencePage: 'models-page', regions: [{ id: 'list', mode: 'management-list' }] }],
+    requirements: [{ id: 'ASSET-01', text: '查询、多选、分页和批量状态变更', pages: ['assets'], source: { type: 'prd', reference: 'PRD-assets-v1.2#ASSET-01', statement: 'Isolated fixture with explicitly named project modules.' } }], exemptions: [] };
+  const file = path.join(project, 'scope.json');
+  const create = (id = 'assets') => { fs.writeFileSync(file, JSON.stringify(scope)); return native.createPrototype({ project, id, scope: file, expertMode: 'template' }); };
+  return { project, scope, create };
+}
+test('new prototypes use one shared nested index and derive module associations from fixed scope', t => {
+  const { project, scope, create } = fixture(t), created = create();
+  const index = read(path.join(project, 'prototypes/index.json'));
+  assert.deepEqual(index.prototypes[0].appliesTo, ['asset-management', 'work-orders']);
+  assert.equal(index.prototypes[0].directory, 'prototypes/assets');
+  assert.deepEqual(read(path.join(created.directory, 'inputs/scope.json')), scope);
+  for (const name of ['.i3-ui-prototypes.json', '.i3-ui-prototypes.lock', '.prototype-preparation', '.playwright-cli', 'ui-templates']) assert.equal(fs.existsSync(path.join(project, name)), false, name);
+  assert.equal(fs.existsSync(path.join(project, 'prototypes/.index.lock')), false);
+});
+test('scope module validation rejects invented paths and malformed declarations before any output', t => {
+  const { project, scope, create } = fixture(t);
+  for (const value of [undefined, null, 'assets', [null], ['../assets'], ['src/assets'], ['*'], [''], ['asset management']]) {
+    scope.moduleIds = value;
+    assert.throws(() => create(), /moduleIds|module identifier/i);
+    assert.equal(fs.existsSync(path.join(project, 'prototypes')), false);
+  }
+  scope.moduleIds = [];
+  create();
+  assert.deepEqual(registry.query({ project, module: 'asset-management' }).matches, []);
+  assert.deepEqual(registry.query({ project }).unbound.map(entry => entry.id), ['assets']);
+});
+test('index lookup is read-only, detects overlapping prototypes and never treats unbound as global', t => {
+  const { project, scope, create } = fixture(t);
+  assert.equal(registry.query({ project }).prototypes.length, 0);
+  assert.deepEqual(fs.readdirSync(project), []);
+  create('first'); create('second');
+  const result = registry.query({ project, module: 'asset-management' });
+  assert.equal(result.selection, 'ambiguous');
+  assert.deepEqual(result.matches.map(entry => entry.id), ['first', 'second']);
+  scope.moduleIds = []; create('exploration');
+  assert.equal(registry.query({ project, module: 'work-orders' }).matches.length, 2);
+  assert.equal(registry.query({ project, module: 'other' }).matches.length, 0);
+});
+test('a legacy-only project keeps one active index until explicitly migrated and preserves its instances', t => {
+  const { project, create } = fixture(t), first = create('old');
+  const before = native.manifest(first.directory);
+  fs.renameSync(path.join(project, 'prototypes/index.json'), path.join(project, '.i3-ui-prototypes.json'));
+  create('new');
+  assert.equal(fs.existsSync(path.join(project, 'prototypes/index.json')), false);
+  assert.equal(registry.query({ project }).legacy, true);
+  assert.equal(read(path.join(project, '.i3-ui-prototypes.json')).prototypes.length, 2);
+  assert.deepEqual(native.manifest(first.directory), before);
+});
+test('conflicting indices and an old active writer block creation without overwriting user content', t => {
+  const { project, create } = fixture(t); create('first');
+  const before = fs.readFileSync(path.join(project, 'prototypes/index.json'));
+  fs.writeFileSync(path.join(project, '.i3-ui-prototypes.json'), JSON.stringify({ schemaVersion: 1, prototypes: [] }));
+  assert.throws(() => create('second'), /conflict|indices/i);
+  assert.equal(fs.existsSync(path.join(project, 'prototypes/second')), false);
+  assert.deepEqual(fs.readFileSync(path.join(project, 'prototypes/index.json')), before);
+  fs.unlinkSync(path.join(project, '.i3-ui-prototypes.json'));
+  fs.writeFileSync(path.join(project, '.i3-ui-prototypes.lock'), 'existing writer');
+  assert.throws(() => create('second'), /lock|writer/i);
+  assert.equal(fs.readFileSync(path.join(project, '.i3-ui-prototypes.lock'), 'utf8'), 'existing writer');
+});
+test('failed atomic index publication removes only the newly created prototype', t => {
+  const { project, create } = fixture(t); create('first');
+  const original = fs.readFileSync(path.join(project, 'prototypes/index.json'));
+  const rename = fs.renameSync;
+  fs.renameSync = (from, to) => { if (to === path.join(project, 'prototypes/index.json')) throw new Error('fixture index write failed'); return rename(from, to); };
+  try { assert.throws(() => create('second'), /fixture index write failed/); } finally { fs.renameSync = rename; }
+  assert.deepEqual(fs.readFileSync(path.join(project, 'prototypes/index.json')), original);
+  assert.equal(fs.existsSync(path.join(project, 'prototypes/second')), false);
+  assert.deepEqual(fs.readdirSync(path.join(project, 'prototypes')).sort(), ['first', 'index.json']);
+});
+test('old scope contracts remain valid and legacy HTML creation also uses the shared index', t => {
+  const { project, scope, create } = fixture(t);
+  scope.schemaVersion = 1; delete scope.moduleIds;
+  const first = create();
+  assert.equal(native.inspect(first.directory).status, 'passed');
+  assert.deepEqual(registry.query({ project }).unbound.map(entry => entry.id), ['assets']);
+  const legacy = require(path.join(scripts, 'prototype-lib.cjs'));
+  const html = legacy.initPrototype({ project, id: 'html', template: 'classic-admin', expertMode: 'template' });
+  assert.equal(legacy.checkPrototype(html.directory).status, 'passed');
+  assert.equal(registry.query({ project }).prototypes.length, 2);
+  assert.equal(fs.existsSync(path.join(project, '.i3-ui-prototypes.json')), false);
+});
+test('legacy human module labels remain searchable without rewriting their old scope', t => {
+  const { project, scope, create } = fixture(t); scope.schemaVersion = 1; delete scope.moduleIds;
+  const directory = create().directory, before = native.manifest(directory), file = path.join(project, 'prototypes/index.json'), index = read(file);
+  index.prototypes[0].appliesTo = ['资产管理']; fs.writeFileSync(file, JSON.stringify(index));
+  assert.equal(registry.query({ project, module: '资产管理' }).matches[0].id, 'assets');
+  assert.deepEqual(native.manifest(directory), before);
+});
+test('explicitly accepting a revised scope updates the index and invalid associations cannot be selected', t => {
+  const { project, create } = fixture(t), directory = create().directory;
+  const scopeFile = path.join(directory, 'inputs/scope.json'), scope = read(scopeFile);
+  scope.moduleIds = ['maintenance']; fs.writeFileSync(scopeFile, JSON.stringify(scope));
+  assert.equal(registry.query({ project, module: 'asset-management' }).status, 'failed');
+  assert.deepEqual(registry.query({ project, module: 'asset-management' }).matches, []);
+  const candidate = native.manifest(directory);
+  native.revise(directory, { revision: 'r002', expectedRevision: candidate.revision, expectedDigest: candidate.digest, acceptInputs: true });
+  assert.deepEqual(read(path.join(project, 'prototypes/index.json')).prototypes[0].appliesTo, ['maintenance']);
+  assert.equal(registry.query({ project, module: 'maintenance' }).selection, 'matched');
+  assert.equal(native.inspect(directory).status, 'passed');
+});
+test('synchronizing the index uses fixed accepted inputs and leaves the candidate unchanged', t => {
+  const { project, create } = fixture(t), directory = create().directory, before = native.manifest(directory);
+  const indexFile = path.join(project, 'prototypes/index.json'), index = read(indexFile);
+  index.prototypes[0].appliesTo = ['invented']; fs.writeFileSync(indexFile, JSON.stringify(index));
+  assert.equal(registry.query({ project, module: 'invented' }).status, 'failed');
+  const rename = fs.renameSync; let instanceLocked = false;
+  fs.renameSync = (from, to) => { if (to === indexFile) instanceLocked = fs.existsSync(path.join(directory, '.prototype-write.lock')); return rename(from, to); };
+  try { assert.equal(native.synchronizeIndex({ project, id: 'assets' }).status, 'synchronized'); } finally { fs.renameSync = rename; }
+  assert.equal(instanceLocked, true, 'Synchronization must lock the candidate while reading its fixed inputs');
+  assert.deepEqual(native.manifest(directory), before);
+  assert.equal(registry.query({ project, module: 'invented' }).matches.length, 0);
+  assert.equal(registry.query({ project, module: 'asset-management' }).matches.length, 1);
+  const scope = read(path.join(directory, 'inputs/scope.json')); scope.moduleIds = ['pending'];
+  fs.writeFileSync(path.join(directory, 'inputs/scope.json'), JSON.stringify(scope));
+  assert.throws(() => native.synchronizeIndex({ project, id: 'assets' }), /input|contract|合同/i);
+});
+test('an index failure while revising restores prototype metadata and preserves the previous registry', t => {
+  const { project, create } = fixture(t), directory = create().directory;
+  const metadataFile = path.join(directory, 'prototype.json'), before = fs.readFileSync(metadataFile);
+  const indexFile = path.join(project, 'prototypes/index.json'), indexBefore = fs.readFileSync(indexFile);
+  const scopeFile = path.join(directory, 'inputs/scope.json'), scope = read(scopeFile); scope.moduleIds = ['maintenance']; fs.writeFileSync(scopeFile, JSON.stringify(scope));
+  const candidate = native.manifest(directory), rename = fs.renameSync;
+  fs.renameSync = (from, to) => { if (to === indexFile) throw new Error('fixture revise index failure'); return rename(from, to); };
+  try { assert.throws(() => native.revise(directory, { revision: 'r002', expectedRevision: candidate.revision, expectedDigest: candidate.digest, acceptInputs: true }), /fixture revise index failure/); }
+  finally { fs.renameSync = rename; }
+  assert.deepEqual(fs.readFileSync(metadataFile), before);
+  assert.deepEqual(fs.readFileSync(indexFile), indexBefore);
+});
+test('legacy index migration previews without writes, archives source bytes and preserves prototype identity', t => {
+  const { project, create } = fixture(t), directory = create().directory, candidate = native.manifest(directory);
+  const current = path.join(project, 'prototypes/index.json'), old = path.join(project, '.i3-ui-prototypes.json');
+  fs.renameSync(current, old); const bytes = fs.readFileSync(old), before = fs.readdirSync(path.join(project, 'prototypes'));
+  const preview = registry.migrate({ project, check: true });
+  assert.equal(preview.status, 'migration-preview');
+  assert.equal(fs.existsSync(current), false);
+  assert.deepEqual(fs.readdirSync(path.join(project, 'prototypes')), before);
+  const result = registry.migrate({ project });
+  assert.equal(result.status, 'migrated');
+  assert.deepEqual(fs.readFileSync(result.backup), bytes);
+  assert.deepEqual(fs.readFileSync(current), bytes);
+  assert.equal(fs.existsSync(old), false);
+  assert.deepEqual(native.manifest(directory), candidate);
+  assert.equal(registry.migrate({ project }).status, 'current');
+});
+test('failed migration rolls back its new index and retains original source and user files', t => {
+  const { project, create } = fixture(t); create();
+  const current = path.join(project, 'prototypes/index.json'), old = path.join(project, '.i3-ui-prototypes.json');
+  fs.renameSync(current, old); const bytes = fs.readFileSync(old);
+  fs.writeFileSync(path.join(project, 'user.md'), 'keep user content');
+  const unlink = fs.unlinkSync;
+  fs.unlinkSync = file => { if (file === old) throw new Error('fixture old source cannot be removed'); return unlink(file); };
+  try { assert.throws(() => registry.migrate({ project }), /fixture old source/); } finally { fs.unlinkSync = unlink; }
+  assert.deepEqual(fs.readFileSync(old), bytes);
+  assert.equal(fs.existsSync(current), false);
+  assert.equal(fs.readFileSync(path.join(project, 'user.md'), 'utf8'), 'keep user content');
+  assert.equal(fs.existsSync(path.join(project, 'prototypes/.index.lock')), false);
+  assert.equal(fs.existsSync(path.join(project, '.i3-ui-prototypes.lock')), false);
+});
+test('migration refuses divergent duplicate indices rather than picking a winner', t => {
+  const { project, create } = fixture(t); create();
+  const current = path.join(project, 'prototypes/index.json'), bytes = fs.readFileSync(current);
+  fs.writeFileSync(path.join(project, '.i3-ui-prototypes.json'), '{"schemaVersion":1,"prototypes":[]}');
+  assert.throws(() => registry.migrate({ project }), /conflict|indices/i);
+  assert.deepEqual(fs.readFileSync(current), bytes);
+});

package/scripts/ui-prototype-buddy-lifecycle-test.js

@@ -0,0 +1,89 @@
+'use strict';
+// Real filesystem/Hook handlers with explicitly synthetic native events, not host acceptance.
+const test=require('node:test'),assert=require('node:assert/strict'),fs=require('node:fs'),os=require('node:os'),path=require('node:path');
+const installed=path.join(__dirname,'lib/installation.js');
+const scripts=path.join(fs.existsSync(installed)?require(installed).loadInstallation().skillsDirectory:path.resolve(__dirname,'../skills'),'i3-ui-prototype/scripts');
+const H=require(path.join(scripts,'codebuddy-hook.cjs')),R=require(path.join(scripts,'codebuddy-registration.cjs')),C=require(path.join(scripts,'codebuddy-context.cjs'));
+const P=require(path.join(scripts,'execution-policy.cjs')),A=require(path.join(scripts,'execution-assertions.cjs')),lib=require(path.join(scripts,'native-pilot-lib.cjs')),X=require(path.join(scripts,'execution-runtime.cjs'));
+function fixture(t,host,scope,client){
+ const root=fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(),'i3-buddy-lifecycle-fixture-')));t.after(()=>fs.rmSync(root,{recursive:true,force:true}));
+ const project=path.join(root,'business'),home=path.join(root,'isolated-home');fs.mkdirSync(project);fs.mkdirSync(home);
+ const scopeFile=path.join(root,'scope.json');fs.writeFileSync(scopeFile,JSON.stringify({schemaVersion:1,title:'Synthetic fixture',pages:[{id:'orders',title:'Orders',referencePage:'models-page',regions:[{id:'list',mode:'management-list'}]}],requirements:[{id:'R1',text:'Synthetic contract only',pages:['orders'],source:{type:'prd',reference:'fixture',statement:'Not native host or business acceptance'}}],exemptions:[]}));
+ const opts={project,scope:scopeFile,expertMode:'template'};
+ const facts=A.template(opts);for(const item of facts.scenarios)item.checks=[{method:'evaluate_script',pointer:'/fixture',operator:'equals',expected:true}];
+ const assertions=path.join(root,'facts.json');fs.writeFileSync(assertions,JSON.stringify(facts));
+ const created=lib.createPrototype({...opts,id:'orders',host,executionPolicy:P.AUTO_ID,executionAssertions:assertions});
+ const base=scope==='project'?path.join(project,'.codebuddy'):path.join(home,`.${host}`),entry=path.join(scripts,'hosts/codebuddy.cjs');
+ const registered=R.plan({action:'enable',scope,host,base,project,nodePath:process.execPath,scriptPath:entry,scriptDigest:C.bundle(entry)});R.apply(registered);
+ const file=client?path.join(root,'native.jsonl'):path.join(home,`.${host}`,'projects','business','fixture-native-session.jsonl'),sessionId='fixture-native-session',rows=[];let number=0;
+ fs.mkdirSync(path.dirname(file),{recursive:true});
+ function append(row){
+  if(!client){
+   const block=Array.isArray(row.message?.content)?row.message.content[0]:null;
+   if(block?.type==='tool_use')row={type:'function_call',callId:block.id,name:block.name,arguments:JSON.stringify(block.input)};
+   else if(block?.type==='tool_result')row={type:'function_call_result',callId:block.tool_use_id,output:block.content,status:block.is_error?'failed':'completed'};
+   else row={type:'message',role:row.type,content:[{type:row.type==='user'?'input_text':'output_text',text:row.message?.content||''}]};
+  }
+  rows.push({...row,sessionId,cwd:project});fs.writeFileSync(file,rows.map(value=>JSON.stringify(value)).join('\n')+'\n');
+ }
+ function hook(event,name,input,id){return H.handle({client,hook_event_name:event,session_id:sessionId,transcript_path:file,cwd:project,tool_name:name,tool_input:input,tool_use_id:id},{event,base,scope,product:'auto',home,env:{}});}
+ function request(name,input){const id='fixture-call-'+(++number);append({type:'assistant',message:{content:[{type:'tool_use',id,name,input}]}});return id;}
+ function result(id,content,failed=false){append({type:'user',message:{content:[{type:'tool_result',tool_use_id:id,content,is_error:failed}]}});}
+ function tool(name,input,content='success',action=()=>{}){
+  const id=request(name,input),decision=hook('PreToolUse',name,input,id);
+  if(decision.deny){result(id,decision.reason,true);return {id,decision};}
+  action();result(id,content);return {id,decision,post:hook('PostToolUse',name,input,id)};
+ }
+ append({type:'user',message:{content:'实现原型，使用模板模式。Synthetic fixture only.'}});
+ tool('Skill',{skill:'i3-ui-prototype'},'Prototype Skill loaded');
+ const begin=()=>tool('Bash',{command:`node '${path.join(scripts,'native-pilot.cjs')}' execution-begin '${created.directory}'`},'bound');begin();
+ return {root,project,base,directory:created.directory,append,hook,tool,begin,result,request,read(){const pointer=JSON.parse(fs.readFileSync(path.join(created.directory,'qa/execution-context.json')));const selected=C.select({project,product:client==='CodeBuddyCLI'||!client&&host==='codebuddy'?'cli':'ide',host,home,env:{}});return JSON.parse(fs.readFileSync(path.join(C.sessionDirectory(selected,project,pointer.sessionId),'session.json')));}};
+}
+for(const [host,client] of [['codebuddy','CodeBuddyCLI'],['codebuddy','CodeBuddyIDE'],['workbuddy','WorkBuddy'],['codebuddy',null],['workbuddy',null]])for(const scope of ['project','global'])test(`${host} ${client||'native-flat-log'} ${scope}: deny, correlate successful Skills, retry and retain budget`,t=>{
+ const f=fixture(t,host,scope,client),file=path.join(f.directory,'app/src/RecoveryFixture.vue');
+ const denied=f.tool('Write',{file_path:file,content:'fixture'});assert.equal(denied.decision.deny,true);assert.equal(fs.existsSync(file),false);
+ assert.match(denied.decision.reason,/i3-frontend-ui-engineering/);
+ const before=Object.values(f.read().recoveries)[0].total;f.begin();assert.equal(Object.values(f.read().recoveries)[0].total,before);
+ const frontend=f.tool('Skill',{skill:'i3-frontend-ui-engineering'},'Frontend Skill successfully loaded');
+ const official=f.tool('Skill',{skill:'antdv'},'Official Skill successfully loaded');
+ const retry=f.tool('Write',{file_path:file,content:'fixture'},'written',()=>fs.writeFileSync(file,'fixture'));
+ assert.equal(retry.decision.continue,true);assert.equal(fs.readFileSync(file,'utf8'),'fixture');
+ const recovery=f.read().bindings[f.directory].recovery;assert.equal(recovery.status,'recovered');assert.equal(recovery.retry.toolCallId,retry.id);
+ assert.deepEqual(recovery.invocations.map(item=>item.toolCallId).sort(),[frontend.id,official.id].sort());
+ assert.equal(X.check(f.directory,'delivery',lib).status,'failed','Recovery is not business acceptance or a delivery receipt');
+});
+test('Stop asks for missing Skills twice, then reports blocked without an endless loop',t=>{
+ const f=fixture(t,'codebuddy','project','CodeBuddyCLI');
+ for(let n=0;n<3;n++){
+  f.append({type:'assistant',message:{content:'已完成，可以交付 '+n}});
+  const answer=f.hook('Stop');
+  if(n<2)assert.equal(answer.feedback,true);else {assert.equal(answer.continue,true);assert.equal(answer.recovery.status,'blocked');}
+ }
+ f.append({type:'user',message:{content:'先分析，不改代码'}});
+ const answer=f.tool('Write',{file_path:path.join(f.directory,'app/src/NoWrite.vue'),content:'no'});assert.equal(answer.decision.deny,true);assert.match(answer.decision.reason,/read-only/);
+});
+test('a duplicated native callback does not spend recovery budget when the transcript grows',t=>{
+ const f=fixture(t,'workbuddy','project',null),input={file_path:path.join(f.directory,'app/src/Duplicate.vue'),content:'fixture'};
+ const id=f.request('Write',input);assert.equal(f.hook('PreToolUse','Write',input,id).deny,true);
+ f.append({type:'assistant',message:{content:'native transcript metadata was persisted'}});
+ assert.equal(f.hook('PreToolUse','Write',input,id).deny,true);
+ assert.equal(Object.values(f.read().recoveries)[0].total,1);
+});
+test('stage recovery waits for its shared gate and the matching successful command result',t=>{
+ const f=fixture(t,'codebuddy','project','CodeBuddyCLI');
+ f.tool('Skill',{skill:'i3-frontend-ui-engineering'});f.tool('Skill',{skill:'antdv'});
+ // This test covers the Hook/recovery boundary; execution-runtime tests exercise
+ // the real shared predicate with genuine source/evidence fixtures separately.
+ const original=X.check;t.after(()=>{X.check=original;});
+ X.check=()=>({status:'failed',errors:['Synthetic implementation evidence missing']});
+ const command=`node '${path.join(scripts,'native-pilot.cjs')}' build '${f.directory}'`;
+ assert.equal(f.tool('Bash',{command}).decision.deny,true);
+ X.check=()=>({status:'passed'});
+ const file=path.join(f.directory,'app/src/Unrelated.vue');
+ f.tool('Write',{file_path:file,content:'unrelated'},'written',()=>fs.writeFileSync(file,'unrelated'));
+ assert.equal(f.read().bindings[f.directory].recovery.status,'required','An unrelated successful UI edit cannot resolve a stage failure');
+ const retry=f.tool('Bash',{command},'successful native build command');
+ const recovery=f.read().bindings[f.directory].recovery;
+ assert.equal(recovery.status,'recovered');assert.equal(recovery.retry.toolCallId,retry.id);
+ assert.equal(recovery.retry.kind,'stage');assert.equal(recovery.retry.stage,'implementation');assert.equal(recovery.retry.operation,'build');
+});

package/scripts/ui-prototype-codebuddy-hook-test.js

@@ -0,0 +1,106 @@
+'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 H=require(prototypeScripts+'/codebuddy-hook.cjs'),E=require(prototypeScripts+'/execution-evidence.cjs');
+test('native command parsing handles quoted paths without evaluating shell substitutions or chains',()=>{
+ const c=H.nativeCommand('Bash',{command:"'/node path/node' '/skills path/native-pilot.cjs' execution-begin '/work/prototypes/a b'"},'/work');
+ assert.equal(c.root,'/work/prototypes/a b');assert.equal(c.operation,'execution-begin');
+ for(const command of ['node x; node native-pilot.cjs finalize /x','$(steal) native-pilot.cjs build /x','node x | node native-pilot.cjs finalize /x'])assert.equal(H.nativeCommand('Bash',{command},'/work'),null);
+});
+test('before UI write requires a successful frontend Skill in the same live context and task',()=>{
+ const source={prompts:[{line:1,text:'create prototype'}],calls:[],contextLine:0},binding={entryLine:1,contextLine:0,sessionId:'s1'};
+ const input={event:'PreToolUse',source,binding,tool:'Write',input:{file_path:'/work/prototypes/p/app/src/A.vue'},directory:'/work/prototypes/p'};
+ assert.equal(H.decision(input).deny,true);
+ source.calls=[{skill:'frontend',sessionId:'s1',requestLine:2,resultLine:3,success:true}];assert.equal(H.decision(input).continue,true);
+ source.contextLine=4;assert.equal(H.decision(input).deny,true);
+});
+test('analysis overrides old tasks and Stop feedback is bounded without granting tool permissions',()=>{
+ const source={prompts:[{line:1,text:'先分析，不改代码'}],calls:[],contextLine:0};
+ assert.equal(H.decision({event:'Stop',source,binding:{},deliveryCurrent:false}).feedback,undefined);
+ source.prompts[0].text='implement prototype';
+ source.latestAssistant='已完成，可以交付';
+ assert.equal(H.decision({event:'Stop',source,binding:{},deliveryCurrent:false}).feedback,true);
+ assert.equal(H.decision({event:'Stop',source,binding:{},deliveryCurrent:false,stopHookActive:true}).continue,true);
+ assert.equal(H.decision({event:'Stop',source,binding:{},deliveryCurrent:true}).continue,true);
+ assert.equal(JSON.stringify(H.decision({event:'PreToolUse',source,tool:'Read',directory:'/p'})).includes('permissionDecision'),false);
+});
+test('native compact boundaries invalidate loads and mixed-session results are rejected',()=>{
+ const rows=[{type:'user',sessionId:'s1',message:{content:'create prototype'}},{type:'assistant',sessionId:'s1',message:{content:[{type:'tool_use',id:'f',name:'Skill',input:{skill:'i3-frontend-ui-engineering'}}]}},{type:'user',sessionId:'s2',message:{content:[{type:'tool_result',tool_use_id:'f',content:'loaded'}]}}];
+ assert.throws(()=>E.parse(rows.map(r=>JSON.stringify(r)).join('\n')),/session/);
+ rows[2].sessionId='s1';rows.push({type:'system',subtype:'compact_boundary'});
+ assert.equal(E.describe(rows.map(r=>JSON.stringify(r)).join('\n')).contextLine,4);
+});
+test('effective binding differs by IDE override and CLI merge without writing any settings',()=>{
+ const C=require(prototypeScripts+'/codebuddy-context.cjs'),path=require('node:path');
+ const texts=new Map(),records=new Map(),project='/work/p',home='/home/user',projectBase=path.join(project,'.codebuddy'),globalBase=path.join(home,'.codebuddy');
+ const args={project,home,env:{},readText:file=>texts.get(file)||null,loadRegistration:base=>records.get(base)||null};
+ records.set(globalBase,{base:globalBase,product:'ide'});texts.set(path.join(projectBase,'settings.json'),'{}');
+ assert.equal(C.select({...args,product:'ide'}),null,'IDE cannot fall back through shadowing project settings');
+ records.set(globalBase,{base:globalBase,product:'cli'});assert.equal(C.select({...args,product:'cli'}).base,globalBase);
+ records.set(projectBase,{base:projectBase,product:'cli'});assert.equal(C.select({...args,product:'cli'}).base,projectBase);
+ texts.set(path.join(projectBase,'settings.local.json'),'{"hooks":{}}');assert.throws(()=>C.select({...args,product:'cli'}),/overrides/);
+ assert.notEqual(C.projectKey('/work/p'),C.projectKey('/other/p'));
+});
+test('read-only intent does not confuse business pause buttons with cancelling implementation',()=>{
+ const C=require(prototypeScripts+'/codebuddy-context.cjs');
+ assert.equal(C.readOnly('先分析，不改代码'),true);assert.equal(C.readOnly('先检查再实现原型'),false);
+ assert.equal(C.readOnly('增加暂停按钮，不改业务逻辑'),false);assert.equal(C.readOnly('暂停当前修改'),true);
+});
+test('a Hook payload must resolve to the actual current native request rather than a model-written begin',()=>{
+ const source={prompts:[{line:1,text:'create prototype'}],calls:[{name:'Bash',toolCallId:'native-begin',input:{command:'node native-pilot.cjs execution-begin /p'},requestLine:3}]};
+ const payload={hook_event_name:'PreToolUse',tool_name:'Bash',tool_input:{command:'node native-pilot.cjs execution-begin /p'}};
+ assert.equal(H.eventCall(payload,source).toolCallId,'native-begin');
+ assert.throws(()=>H.eventCall({...payload,tool_input:{command:'fabricated begin'}},source),/uniquely/);
+ source.calls[0].resultLine=4;assert.throws(()=>H.eventCall(payload,source),/uniquely/);
+});
+test('project-scope callbacks use their registered root when tools run in a subdirectory',()=>{
+ const payload={cwd:'/business/p/src'},real=p=>p;
+ assert.equal(H.safeProject(payload,{scope:'project',base:'/business/p/.codebuddy'},{},real),'/business/p');
+ assert.equal(H.safeProject(payload,{scope:'global',base:'/custom/codebuddy'},{CODEBUDDY_PROJECT_DIR:'/business/p'},real),'/business/p');
+ assert.equal(H.safeProject({hook_event_name:'SessionStart'},{scope:'global',base:'/custom/codebuddy'},{},real,'/business/p'),'/business/p');
+ assert.throws(()=>H.safeProject({cwd:'/other'},{scope:'project',base:'/business/p/.codebuddy'},{},real),/outside/);
+});
+test('the frontend gate blocks project-relative native Write calls before any run binding',()=>{
+ const result=H.decision({event:'PreToolUse',source:{prompts:[{line:1,text:'实现原型'}],calls:[],contextLine:0},tool:'Write',input:{file_path:'prototypes/p/app/src/Probe.vue'},directory:'/work/prototypes/p',cwd:'/work'});
+ assert.equal(result.deny,true);assert.match(result.reason,/frontend/);
+ const ide=H.decision({event:'PreToolUse',source:{prompts:[{line:1,text:'实现原型'}],calls:[],contextLine:0},tool:'Write',input:{filePath:'/work/prototypes/p/app/src/Probe.vue'},directory:'/work/prototypes/p',cwd:'/work'});
+ assert.equal(ide.deny,true);
+});
+test('IDE streaming requests correlate only within the exact native generation and unique call',()=>{
+ const source={format:'codebuddy-ide-index-v1',prompts:[{line:1}],calls:[{name:'Write',toolCallId:'actual-ide-call',nativeRequestId:'generation-1',input:{content:'<template>'},requestLine:2}]};
+ const payload={hook_event_name:'PreToolUse',client:'CodeBuddyIDE',generation_id:'generation-1',tool_name:'Write',tool_input:{filePath:'/work/p/app/src/A.vue',content:'<template><p>A</p></template>'}};
+ assert.equal(H.eventCall(payload,source).toolCallId,'actual-ide-call');
+ assert.throws(()=>H.eventCall({...payload,generation_id:'other'},source),/uniquely/);
+ assert.throws(()=>H.eventCall({...payload,client:'other'},source),/uniquely/);
+ assert.throws(()=>H.eventCall({...payload,tool_input:{content:'unrelated'}},source),/uniquely/);
+ source.calls.push({...source.calls[0],toolCallId:'second-call'});assert.throws(()=>H.eventCall(payload,source),/uniquely/);
+});
+test('IDE transient reads retry while wrong generations and mismatched pending requests stay rejected',()=>{
+ const payload={hook_event_name:'PreToolUse',client:'CodeBuddyIDE',generation_id:'g1',tool_name:'Write',tool_input:{content:'ui'}};
+ const pending={format:'codebuddy-ide-index-v1',prompts:[{line:1,nativeRequestId:'g1'}],calls:[{name:'Write',toolCallId:'w1',nativeRequestId:'g1',input:{content:'ui'},requestLine:2}]};
+ let reads=0,waits=0;
+ const readSource=()=>{if(++reads<3)throw new Error('native index write in progress');return pending;};
+ const result=H.eventSource(payload,{product:'ide'},'/work',{readSource,pause:ms=>{assert.equal(ms,100);waits++;}});
+ assert.equal(result.calls[0].toolCallId,'w1');assert.equal(result.nativeReadAttempts,3);assert.equal(waits,2);
+ reads=0;assert.throws(()=>H.eventSource({...payload,generation_id:'g2'},{product:'ide'},'/work',{readSource:()=>{reads++;return pending;},pause:()=>{}}),/generation/);assert.equal(reads,8);
+ assert.throws(()=>H.eventSource({...payload,tool_input:{content:'different'}},{product:'ide'},'/work',{readSource:()=>pending,pause:()=>{}}),/uniquely/);
+ reads=0;assert.throws(()=>H.eventSource({...payload,client:'cli'},{product:'cli'},'/work',{readSource:()=>{reads++;return {...pending,calls:[]};},pause:()=>assert.fail('CLI must not retry')}),/uniquely/);assert.equal(reads,1);
+});
+test('IDE defers current callback evidence until the host persists it and never invents Skill success',()=>{
+ const source={format:'codebuddy-ide-index-v1',prompts:[{line:1,nativeRequestId:'g1',text:'implement prototype'}],calls:[],contextLine:0};
+ const payload={hook_event_name:'PreToolUse',client:'CodeBuddyIDE',generation_id:'g1',tool_name:'Write',tool_input:{filePath:'/work/prototypes/p/app/src/A.vue'}};
+ const result=H.eventSource(payload,{product:'ide'},'/work',{readSource:()=>source});
+ assert.equal(result.nativeRequestStatus,'deferred-until-native-persistence');assert.deepEqual(result.calls,[]);
+ assert.equal(H.decision({event:'PreToolUse',source:result,binding:{entryLine:1,contextLine:0,sessionId:'s1'},tool:'Write',input:payload.tool_input,directory:'/work/prototypes/p'}).deny,true);
+ assert.throws(()=>E.reference(result.calls,{toolCallId:'made-up'}),/Successful native/);
+ assert.throws(()=>H.eventSource(payload,{product:'ide'},'/work',{readSource:()=>({...source,prompts:[{line:1,nativeRequestId:'old'}]}),pause:()=>{}}),/generation/);
+});
+test('only the observed project IDE root-cwd sentinel is mapped to the registered project',()=>{
+ const options={scope:'project',base:'/business/p/.codebuddy',product:'ide'},payload={cwd:'/',client:'CodeBuddyIDE'};
+ assert.equal(H.safeProject(payload,options,{},p=>p),'/business/p');
+ assert.throws(()=>H.safeProject({...payload,cwd:'/other'},options,{},p=>p),/outside/);
+ assert.throws(()=>H.safeProject(payload,{...options,product:'cli'},{},p=>p),/outside/);
+ assert.equal(H.safeProject({...payload,transcript_path:'/native/index.json',session_id:'s1'},{scope:'global',product:'ide'},{},p=>p,'/ignored',(file,session)=>{assert.equal(file,'/native/index.json');assert.equal(session,'s1');return '/business/p';}),'/business/p');
+ const cwd=H.toolCwd(payload,{product:'ide'},'/business/p');assert.equal(cwd,'/business/p');
+ assert.equal(H.nativeCommand('Bash',{command:'node /skills/native-pilot.cjs execution-begin prototypes/p'},cwd).root,'/business/p/prototypes/p');
+});

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

@@ -131,6 +131,19 @@ test('antDv error text or error JSON with exit zero is not successful knowledge'
     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 => {