@givolt/i3-composer-agent 2.3.1 → 2.3.3

package/skills/i3-ui-prototype/scripts/content-template.cjs

@@ -0,0 +1,98 @@
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const assert = require('node:assert/strict');
+const read = file => JSON.parse(fs.readFileSync(file, 'utf8'));
+
+function extract(directory, manifest, files) {
+  assert.equal(manifest.entry, 'index.html', 'Content templates use the offline index.html convention');
+  const html = fs.readFileSync(path.join(directory, manifest.entry), 'utf8');
+  assert.ok(!/<script\b[^>]*type=["']module/i.test(html), 'Offline entry cannot use modules');
+  const routesMatch = html.match(/id="prototype-offline-routes">([\s\S]*?)<\/script>/);
+  assert.ok(routesMatch, 'Editable route inventory is required');
+  const routes = JSON.parse(routesMatch[1]);
+  const fragments = new Map([...html.matchAll(/^<template data-source="([^"]+)">\n([\s\S]*?)^<\/template>/gm)].map(match => [match[1], match[2]]));
+  assert.ok(fragments.size, 'Editable HTML fragments are required');
+  const resources = [];
+  for (const match of html.matchAll(/<(script|link)\b[^>]*\b(src|href)="([^"]+)"/gi)) {
+    if (match[3].startsWith('data:')) continue;
+    assert.ok(!/^(?:[a-z]+:|\/)/i.test(match[3]) && !match[3].split('/').includes('..'), 'Offline resources must remain inside the template');
+    const resource = match[3].split(/[?#]/)[0];
+    assert.ok(files.some(file => file.path === resource), `Offline resource missing: ${resource}`);
+    resources.push({ file: manifest.entry, path: resource });
+    if (match[1].toLowerCase() === 'script') {
+      const script = fs.readFileSync(path.join(directory, resource), 'utf8');
+      assert.ok(!/\bfetch\s*\(|\bXMLHttpRequest\b|\bimport\s*(?:\(|["'{*])|\bfrom\s*["']/.test(script), 'Offline runtime cannot load modules or remote HTML');
+    }
+  }
+  const pages = [...new Set(routes.map(route => route.component).filter(Boolean))].map(component => {
+    const fragment = 'reference/' + component.replace(/^\.\//, '').replace(/\.js$/, '.html');
+    assert.ok(fragments.has(fragment), `Missing page HTML: ${fragment}`);
+    const title = fragments.get(fragment).match(/<h1[^>]*>([^<{]+)<\/h1>/)?.[1]?.trim();
+    return { id: path.posix.basename(component, '.js').replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase(),
+      title: title || path.posix.basename(component, '.js'), file: 'index.html', fragment,
+      routes: routes.filter(route => route.component === component).map(route => route.path) };
+  });
+  assert.equal(new Set(pages.map(page => page.id)).size, pages.length, 'Duplicate content page identity');
+  return { kind: 'content-reference', pages, regions: [], bindings: [], fields: [], actions: [], resources,
+    htmlFragments: [...fragments.keys()], routes, requiredBindings: [], requiredScenarios: [] };
+}
+
+function scopeInputs(snapshot, scope, contract) {
+  assert.ok(Array.isArray(scope?.pages) && scope.pages.length, 'Provide sourced PRD scope.pages; the reference is not the business requirement');
+  assert.ok(scope.requirements?.length, 'Provide sourced business requirements');
+  const known = new Set(snapshot.index.pages.map(page => page.id));
+  const seen = new Set(['app-shell']), regions = [{ pageId: 'app-shell', id: 'appearance', mode: 'application-shell' }], bindings = [];
+  const defaults = {
+    theme: { defaultTheme: 'light', presets: ['light', 'dark', 'fresh', 'tech'] },
+    filter: { resetPage: true, clearSelection: true }, selection: { strategy: 'current-page-clear-on-change' },
+    pagination: { mode: 'adjustable', defaultPageSize: 10, pageSizeOptions: [10, 20, 50], minimumTestPages: 3 },
+    bulk: { target: 'selected-only' }, edit: { presentation: 'drawer', preserveOnFailure: true },
+  };
+  for (const page of scope.pages) {
+    assert.match(page.id || '', /^[a-z][a-z0-9-]{0,63}$/);
+    assert.ok(!seen.has(page.id), `Duplicate business page: ${page.id}`); seen.add(page.id);
+    assert.ok(page.title?.trim() && known.has(page.referencePage), `Missing explicit template reference page: ${page.id}`);
+    assert.ok(page.regions?.length, `Declare the actual region modes: ${page.id}`);
+    for (const region of page.regions) {
+      assert.match(region.id || '', /^[a-z][a-z0-9-]{0,63}$/);
+      assert.ok(['management-list', 'edit-form', 'content'].includes(region.mode) || (scope.schemaVersion === 3 && require('./generation-contract.cjs').resource(snapshot, 'generation.json').patterns.includes(region.pattern || region.mode)), `Unknown business region mode: ${region.mode}`);
+      regions.push({ pageId: page.id, id: region.id, mode: scope.schemaVersion === 3 ? 'content' : region.mode });
+    }
+  }
+  for (const region of regions) for (const capability of snapshot.definition.capabilities) {
+    if (capability.requirement !== 'required' || !capability.appliesTo.includes(region.mode)) continue;
+    const configured = scope.pages.find(page => page.id === region.pageId)?.regions.find(item => item.id === region.id)?.parameters?.[capability.id];
+    const parameters = configured || (capability.id === 'feedback'
+      ? { states: region.mode === 'edit-form' ? ['loading', 'error', 'success'] : ['loading', 'empty', 'error', 'success'] }
+      : defaults[capability.id]);
+    bindings.push({ id: `${region.pageId}/${region.id}/${capability.id}`, pageId: region.pageId, regionId: region.id, capabilityId: capability.id, parameters });
+  }
+  const requirementIds = new Set();
+  for (const requirement of scope.requirements) {
+    assert.ok(typeof requirement.id==='string'&&requirement.id.trim()&&!requirementIds.has(requirement.id), `Missing or duplicate requirement identity: ${requirement.id}`);
+    requirementIds.add(requirement.id);
+    assert.ok(requirement.pages?.length && requirement.pages.every(page => seen.has(page) && page !== 'app-shell'), `Map each business requirement to its pages: ${requirement.id}`);
+  }
+  for (const page of scope.pages) assert.ok(scope.requirements.some(requirement => requirement.pages?.includes(page.id)), `Business page lacks a requirement: ${page.id}`);
+  const fixed = { schemaVersion: 1, definition: snapshot.definition, regions, bindings, decisions: scope.decisions || [] };
+  assert.ok(!fixed.decisions.some(decision=>decision.bindingId==='app-shell/appearance/theme'&&decision.status==='not-applicable'), 'The default four-theme contract must retain its acceptance');
+  const result = contract.checkCapabilities({ ...fixed, scope });
+  assert.equal(result.status, 'passed', result.errors.join('; '));
+  return { fixed, result };
+}
+function checkInputs(inputsRoot, contract) {
+  const snapshot = read(path.join(inputsRoot, 'template-snapshot.json')), scope = read(path.join(inputsRoot, 'scope.json'));
+  const expected = scopeInputs(snapshot, scope, contract), fixed = read(path.join(inputsRoot, 'capabilities.json'));
+  assert.deepEqual(fixed, expected.fixed, 'Business capability bindings differ from the fixed sourced page/region contract');
+  return expected.result;
+}
+function pageContent(snapshot, pageId) {
+  assert.equal(snapshot.kind, 'content-reference');
+  const page = snapshot.index.pages.find(entry=>entry.id===pageId);
+  assert.ok(page, `Unknown reference page: ${pageId}`);
+  const html = Buffer.from(snapshot.files.find(file=>file.path==='index.html').content, 'base64').toString('utf8');
+  const fragments = new Map([...html.matchAll(/^<template data-source="([^"]+)">\n([\s\S]*?)^<\/template>/gm)].map(match=>[match[1],match[2]]));
+  return { ...page, html: fragments.get(page.fragment), templateDigest: snapshot.digest, readOnly: true };
+}
+module.exports = { extract, scopeInputs, checkInputs, pageContent };

package/skills/i3-ui-prototype/scripts/enterprise-template.cjs

@@ -74,12 +74,19 @@ function initialize(directory, { id, title, purpose, templateRoot = assetRoot })
       adaptations.push({ file, reason: reasons.join('；'), source: origin.files[file], generated: hash(next) });
     }
   }
-  const index = path.join(app, 'index.html'), original = fs.readFileSync(index, 'utf8');
-  assert.ok(original.includes('src="app.js"'), 'Review changed EASEL boot entry before adapting');
-  const adapted = brandRuntimeResource('index.html', original).replace('</head>', '  <link rel="stylesheet" href="tokens.css">\n  <link rel="stylesheet" href="usability.css">\n</head>')
-    .replace('src="app.js"', 'src="enterprise-bootstrap.mjs"');
+  const index = path.join(app, 'index.html');
+  const portable = fs.readFileSync(path.join(templateRoot, 'index.html'), 'utf8');
+  assert.ok(portable.includes('src="offline.js"') && !portable.includes('type="module"'), 'Offline enterprise entry required');
+  const adapted = portable.replaceAll('href="reference/', 'href="').replaceAll('data-source="reference/', 'data-source="')
+    .replace('</head>', '  <link rel="stylesheet" href="tokens.css">\n</head>')
+    .replace(/(<script type="application\/json" id="prototype-offline-config">)[\s\S]*?(<\/script>)/,
+      (_, start, end) => start + JSON.stringify({ title }).replaceAll('<', '\\u003c') + end);
   fs.writeFileSync(index, adapted);
-  adaptations.push({ file: 'index.html', reason: '默认品牌统一为 i3-Composer；接入原有设计 token、实例配置和独立滚动适配，完整保留页面内容', source: origin.files['index.html'], generated: hash(adapted) });
+  const offline = fs.readFileSync(path.join(templateRoot, 'offline.js'), 'utf8')
+    .replaceAll('new URL("reference/', 'new URL("').replaceAll('i3-prototype-antdv-', storagePrefix);
+  fs.writeFileSync(path.join(app, 'offline.js'), offline);
+  adaptations.push({ file: 'index.html', reason: 'i3-Composer 完整可编辑 HTML 片段、路由和实例配置内嵌；经典脚本支持 file://；保留全部内容与本地样式', source: origin.files['index.html'], generated: hash(adapted) });
+  adaptations.push({ file: 'offline.js', reason: '来源模块的离线运行适配，实例存储前缀隔离；原始模块仍保留', generated: hash(offline) });
   fs.copyFileSync(path.join(templateRoot, 'usability.css'), path.join(app, 'usability.css'));
   fs.writeFileSync(path.join(app, 'enterprise-bootstrap.mjs'), "const response = await fetch(new URL('./config.json', import.meta.url));\nif (!response.ok) throw new Error('无法读取企业后台实例配置');\nconst config = await response.json();\ndocument.title = config.title;\nawait import('./app.js');\n");
   fs.copyFileSync(path.join(templateRoot, 'serve.cjs'), path.join(app, 'serve.cjs'));
@@ -92,6 +99,6 @@ function initialize(directory, { id, title, purpose, templateRoot = assetRoot })
   fs.mkdirSync(path.join(directory, 'mocks'), { recursive: true });
   fs.writeFileSync(path.join(directory, 'mocks/README.md'), '# 演示数据\n\n完整 i3-Composer 示例的数据与规则保留在 app/src/ 各模块中，并使用实例独立的本地存储。它们用于模板审查；新业务需要按需求替换，不能当作真实服务或已完成业务适配。\n');
   fs.writeFileSync(path.join(directory, 'requirements-map.json'), JSON.stringify(mapping, null, 2) + '\n');
-  return { kind: 'easel-html', entry: 'app/index.html', sourceVersion: origin.sourceVersion, instanceId, storagePrefix };
+  return { kind: 'easel-html', entry: 'app/index.html', sourceVersion: origin.sourceVersion, instanceId, storagePrefix, offlineVersion: 1 };
 }
 module.exports = { verifyReference, initialize, brandRuntimeResource };

package/skills/i3-ui-prototype/scripts/execution-assertions.cjs

@@ -0,0 +1,43 @@
+'use strict';
+const assert=require('node:assert/strict'),E=require('./execution-evidence.cjs');
+const METHODS=['evaluate_script','take_snapshot','list_console_messages','list_network_requests','performance_stop_trace'];
+function validate(value,scenarioIds) {
+ assert.equal(value?.schemaVersion,1,'Fixed native assertions schema required');assert.ok(Array.isArray(value.scenarios),'Fixed native assertion scenarios required');
+ assert.deepEqual(value.scenarios.map(s=>s.scenarioId).sort(),[...scenarioIds].sort(),'Fixed native assertion scenario coverage differs');
+ for(const scenario of value.scenarios) {
+  assert.ok(scenario.checks?.length,'Each fixed scenario needs actual result assertions before implementation');
+  for(const check of scenario.checks) {
+   assert.ok(METHODS.includes(check.method),'Unsupported native assertion method');
+   assert.ok(typeof check.pointer==='string'&&/^\/(?:[^~]|~[01])*$/.test(check.pointer)&&!/(?:__proto__|constructor|prototype)/.test(check.pointer),'Safe JSON pointer required');
+   assert.ok(['equals','includes','gte','lte'].includes(check.operator),'Unsupported native assertion operator');
+   assert.ok(Object.hasOwn(check,'expected')&&check.expected!==null,'Explicit fixed expected fact required');
+   if(['gte','lte'].includes(check.operator))assert.equal(typeof check.expected,'number','Numeric fixed expectation required');
+  }
+ }
+ return value;
+}
+function resultData(result) {
+ const text=E.contentText(result).trim();let value;
+ try{value=JSON.parse(text);}catch{const blocks=[...text.matchAll(/```(?:json)?\s*\n([\s\S]*?)\n```/g)];assert.equal(blocks.length,1,'One actual JSON result or JSON code block required');value=JSON.parse(blocks[0][1]);}
+ assert.ok(value&&typeof value==='object','Native JSON fact result required');return value;
+}
+function extract(value,pointer) {
+ for(const part of pointer.slice(1).split('/').map(p=>p.replaceAll('~1','/').replaceAll('~0','~'))) {assert.ok(value&&Object.hasOwn(value,part),'Native expected fact is absent');value=value[part];}return value;
+}
+function compare(actual,check) {
+ if(check.operator==='equals')assert.deepEqual(actual,check.expected,'Native fact differs from fixed expectation');
+ else if(check.operator==='includes')assert.ok((typeof actual==='string'||Array.isArray(actual))&&actual.includes(check.expected),'Native fact does not include fixed expectation');
+ else {assert.equal(typeof actual,'number','Native numeric fact required');assert.ok(check.operator==='gte'?actual>=check.expected:actual<=check.expected,'Native numeric fact differs from fixed expectation');}
+}
+function template(options) {
+ const fs=require('node:fs'),path=require('node:path'),T=require('./template-contract.cjs');
+ assert.ok(options.scope,'Sourced scope file required');const scope=JSON.parse(fs.readFileSync(path.resolve(options.scope),'utf8'));
+ const snapshot=options.templateRoot?T.loadTemplate(path.resolve(options.templateRoot)):T.loadBundledTemplate(options.template);
+ const selection=snapshot.kind==='content-reference'?require('./content-template.cjs').scopeInputs(snapshot,scope,T):null;
+ const generation=scope.schemaVersion===3?require('./generation-contract.cjs').compile(snapshot,scope):null;
+ const scenarios=[...(selection?.result.requiredScenarios||snapshot.index.requiredScenarios),...(generation?.scenarios||[])];
+ const drawer=selection&&(selection.fixed.regions.some(r=>r.mode==='edit-form')||generation?.bindings.some(b=>b.capabilityId==='dialog'&&b.parameters.presentation==='drawer'));
+ const framework=selection?['framework-responsive','framework-instance-isolation','template-content-projection',...(drawer?['framework-drawer-motion','framework-mask-blur','framework-focus-scroll']:[])]:['framework-drawer-motion','framework-mask-blur','framework-focus-scroll','framework-states','framework-responsive','framework-instance-isolation','template-content-projection'];
+ return {schemaVersion:1,scopeDigest:E.sha(JSON.stringify(scope)),templateDigest:snapshot.digest,scenarios:[...scenarios.map(s=>({scenarioId:typeof s==='string'?s:s.id,expectedSummary:s.expected||null,checks:[]})),...framework.map(scenarioId=>({scenarioId,checks:[]}))]};
+}
+module.exports={validate,resultData,extract,compare,template};

package/skills/i3-ui-prototype/scripts/execution-evidence.cjs

@@ -0,0 +1,146 @@
+'use strict';
+const assert = require('node:assert/strict');
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+const P = require('./execution-policy.cjs');
+const sha = value => crypto.createHash('sha256').update(value).digest('hex');
+function contentText(content) {
+  if (typeof content === 'string') return content;
+  if (content?.type === 'text' && typeof content.text === 'string') return content.text;
+  if (Array.isArray(content)) return content.map(item => item?.type === 'text' ? item.text || '' : item?.type === 'image' ? '[native image result]' : '').join('\n');
+  return content === undefined ? '' : JSON.stringify(content);
+}
+// CodeBuddy Code 2.169 serializes flat message/function_call rows. Keep the
+// original line cursor and session identity while adapting only observed shapes.
+// Legacy assistant/user + tool_use/tool_result JSONL remains supported.
+function nativeEvent(event) {
+  if (event.type === 'message' && ['assistant', 'user'].includes(event.role)) {
+    const content = Array.isArray(event.content) ? event.content.map(block =>
+      ['input_text', 'output_text'].includes(block?.type) ? { ...block, type: 'text' } : block) : event.content;
+    return { ...event, type: event.role, message: { content } };
+  }
+  if (event.type === 'function_call') {
+    let input;
+    try { input = typeof event.arguments === 'string' ? JSON.parse(event.arguments) : event.arguments; }
+    catch { throw new Error('Invalid native function arguments JSON'); }
+    assert.ok(input && typeof input === 'object' && !Array.isArray(input), 'Invalid native function arguments');
+    return { ...event, type: 'assistant', message: { content: [{ type: 'tool_use', id: event.callId, name: event.name, input }] } };
+  }
+  if (event.type === 'function_call_result') {
+    return { ...event, type: 'user', message: { content: [{ type: 'tool_result', tool_use_id: event.callId,
+      tool_name: event.name, content: event.output, is_error: event.status !== 'completed' }] } };
+  }
+  return event;
+}
+function successful(block) {
+  if (block.is_error || block.isError || block.success === false || block.error) return false;
+  const text = contentText(block.content ?? block.result ?? block.tool_response);
+  if (!text.trim() || /^\s*(?:Error:|Error\b|错误[:：]|Unknown skill\b|Skill[^\n]*not (?:found|available))/i.test(text)) return false;
+  try {
+    const value = JSON.parse(text);
+    if (value && typeof value === 'object') {
+      if (value.isError || value.success === false || value.error || value.status === 'failed') return false;
+      if (typeof value.exitCode === 'number' && value.exitCode !== 0) return false;
+      if (typeof value.stdout === 'string' && /^\s*(?:Error:|Error\b|错误[:：])/i.test(value.stdout)) return false;
+    }
+  } catch { /* Native tool text need not be JSON. */ }
+  return true;
+}
+function parse(text) {
+  assert.ok(typeof text === 'string' && Buffer.byteLength(text) <= 64 * 1024 * 1024, 'Native transcript is too large');
+  const calls = [], requests = new Map(); let nativeMessages = 0, contextLine = 0, promptLine = 0;
+  for (const [lineIndex, line] of text.split('\n').entries()) {
+    if (!line.trim()) continue;
+    let event; try { event = JSON.parse(line); } catch { throw new Error(`Invalid native JSONL at line ${lineIndex + 1}`); }
+    event = nativeEvent(event);
+    if (event.type === 'system' && ['compact_boundary','compact'].includes(event.subtype)) contextLine = lineIndex + 1;
+    const message = event.message;
+    if (!message || !['assistant', 'user'].includes(event.type)) continue;
+    const content = typeof message.content === 'string' ? [{type:'text',text:message.content}] : message.content;
+    if (!Array.isArray(content)) continue;
+    nativeMessages++;
+    if (event.type === 'user' && !event.isMeta && !event.isSidechain && content.some(block=>block.type==='text') && !content.some(block=>block.type==='tool_result')) promptLine = lineIndex + 1;
+    for (const block of content) {
+      if (event.type === 'assistant' && block.type === 'tool_use') {
+        assert.ok(typeof block.id === 'string' && block.id && typeof block.name === 'string', 'Native request identity missing');
+        assert.ok(!requests.has(block.id), 'Duplicate native tool call ID');
+        const input = block.input || {}, skillName = ['Skill', 'skill'].includes(block.name) ? input.skill || input.name || input.command : null;
+        const normalized = typeof skillName === 'string' ? skillName.replace(/^i3-composer-agent:/, '') : null;
+        const call = { toolCallId: block.id, name: block.name, input, skillName: normalized, skill: P.skillKey(normalized),
+          sessionId:event.sessionId||event.session_id||null, cwd:event.cwd||null, nativeRequestId:event.nativeRequestId||null, contextLine, promptLine,
+          requestLine: lineIndex + 1, requestDigest: sha(JSON.stringify(block)), success: false };
+        requests.set(block.id, call); calls.push(call);
+      } else if (event.type === 'user' && block.type === 'tool_result') {
+        const call = requests.get(block.tool_use_id);
+        assert.ok(call && !call.resultLine, 'Unmatched or duplicate native tool result');
+        if (block.tool_name !== undefined) assert.equal(block.tool_name, call.name, 'Native tool result name differs');
+        if (call.sessionId && (event.sessionId||event.session_id)) assert.equal(call.sessionId,event.sessionId||event.session_id,'Cross-session native result');
+        Object.assign(call, { resultLine: lineIndex + 1, resultDigest: sha(JSON.stringify(block)),
+          result: block.content, success: successful(block) });
+      }
+    }
+  }
+  assert.ok(nativeMessages, 'No native assistant/user transcript messages');
+  return calls;
+}
+function loaded(calls, skill) { return calls.filter(call => call.skill === skill && call.success && call.resultLine); }
+function reference(calls, value) {
+  const call = calls.find(item => item.toolCallId === value?.toolCallId);
+  assert.ok(call?.success && call.resultLine, 'Successful native tool result missing');
+  if (value.resultDigest !== undefined) assert.equal(value.resultDigest, call.resultDigest, 'Native result digest differs');
+  return call;
+}
+function describe(text) {
+  const prompts=[];let contextLine=0,latestAssistant='';
+  for(const [index,line] of text.split('\n').entries()) {
+    if(!line.trim())continue;const row=nativeEvent(JSON.parse(line));
+    if(row.type==='system'&&['compact_boundary','compact'].includes(row.subtype))contextLine=index+1;
+    const content=row.message?.content;
+    if(row.type==='assistant'&&(typeof content==='string'||Array.isArray(content)&&content.some(b=>b.type==='text')&&!content.some(b=>b.type==='tool_use')))latestAssistant=contentText(content);
+    if(row.type==='user'&&!row.isMeta&&!row.isSidechain&&(typeof content==='string'||Array.isArray(content)&&content.some(b=>b.type==='text')&&!content.some(b=>b.type==='tool_result')))
+      prompts.push({line:index+1,digest:sha(line),text:contentText(content),sessionId:row.sessionId||row.session_id||null,
+        ...(row.nativeRequestId?{nativeRequestId:row.nativeRequestId}:{})});
+  }
+  return {prompts,contextLine,latestAssistant};
+}
+function sourceData(file) {
+  if(path.basename(file)==='index.json') {
+    const ide=require('./codebuddy-ide-source.cjs').read(file);
+    return {...ide,buffer:Buffer.from(ide.text)};
+  }
+  const buffer=fs.readFileSync(file);return {buffer,text:buffer.toString('utf8'),format:'native-jsonl'};
+}
+function cursorBytes(file){return sourceData(file).buffer;}
+function ideWorkspace(file,sessionId) {
+  assert.ok(typeof file==='string'&&path.isAbsolute(file)&&path.basename(file)==='index.json','Native IDE index path required');
+  assert.equal(path.basename(path.dirname(file)),sessionId,'Native IDE session directory differs');
+  const data=sourceData(file);assert.ok(data.workspace,'Native IDE workspace context is missing');
+  return data.workspace;
+}
+function readSource(file, roots, {mode='manual',project}={}) {
+  assert.ok(typeof file==='string'&&path.isAbsolute(file)&&!/[\x00\r\n]/.test(file), 'Absolute native transcript file required');
+  assert.ok(['auto','manual'].includes(mode)&&Array.isArray(roots), 'Invalid native transcript policy');
+  if(mode==='manual')assert.ok(roots.length, 'Configured host transcript roots required');
+  else assert.equal(roots.length,0,'Automatic transcript mode cannot bypass configured manual roots');
+  const real = fs.realpathSync(file);
+  if(mode==='manual')assert.ok(roots.some(root => { if(!fs.existsSync(root))return false;const relative = path.relative(fs.realpathSync(root), real); return relative && relative!=='..'&&!relative.startsWith('..'+path.sep) && !path.isAbsolute(relative); }), 'Transcript is outside the configured native host log roots');
+  if(mode==='auto') {
+    assert.ok(typeof project==='string'&&path.isAbsolute(project), 'Native project required for automatic transcript validation');
+    const relative=path.relative(fs.realpathSync(project),real);
+    assert.ok(relative==='..'||relative.startsWith('..'+path.sep)||path.isAbsolute(relative), 'Native transcript cannot be inside the business project');
+  }
+  assert.ok(!fs.lstatSync(file).isSymbolicLink() && fs.statSync(real).isFile() && fs.statSync(real).size <= 64 * 1024 * 1024, 'Invalid native transcript file');
+  const data=sourceData(real),text=data.text,calls=parse(text);
+  if(data.workspace&&project)assert.equal(fs.realpathSync(data.workspace),fs.realpathSync(project),'Native IDE workspace differs from the bound project');
+  // IDE rewrites streaming argument objects before persisting their results.
+  // Freeze only the completed prefix; a pending request cannot attest success.
+  const pending=data.format==='codebuddy-ide-index-v1'?calls.filter(call=>!call.resultLine):[];
+  const firstPending=pending.length?Math.min(...pending.map(call=>call.requestLine)):null;
+  const bytes=firstPending?Buffer.from(text.split('\n').slice(0,firstPending-1).join('\n')+'\n'):data.buffer;
+  return { path: real, digest: sha(bytes), bytes: bytes.length, format:data.format, calls, ...describe(text),
+    ...(firstPending?{stableThroughLine:firstPending-1}:{}),
+    ...(data.latestAssistant!==undefined?{latestAssistant:data.latestAssistant}:{}),
+    sourceVerification: mode==='auto'?'native-hook-transcript':'configured-host-transcript', tamperProof: false };
+}
+module.exports = { sha, contentText, successful, parse, loaded, reference, describe, readSource, cursorBytes, ideWorkspace };

package/skills/i3-ui-prototype/scripts/execution-gates.cjs

@@ -0,0 +1,147 @@
+'use strict';
+// A: deterministic predicates shared by command gates, receipts, and Hook feedback.
+// A successful predicate correlates native source and current bytes; it is not a signature.
+const assert=require('node:assert/strict'),path=require('node:path');
+const P=require('./execution-policy.cjs'),E=require('./execution-evidence.cjs');
+const A=require('./execution-assertions.cjs');
+const same=(a,b,label)=>assert.deepEqual(a,b,label);
+const exact=(a,b,label)=>same([...new Set(a)].sort(),[...new Set(b)].sort(),label);
+function uiWrite(call,directory) {
+ if(!['Write','Edit','MultiEdit','write_to_file','replace_in_file'].includes(call.name))return false;
+ const file=call.input.file_path||call.input.filePath||call.input.path||call.input.TargetFile;
+ if(typeof file!=='string')return false;
+ const rel=path.relative(directory,path.resolve(call.cwd||directory,file));
+ return /^(?:app[\\/](?:src|public)[\\/]|mocks[\\/]|design-system[\\/])/.test(rel);
+}
+function nativeRef(data,ref) {
+ const call=E.reference(data.source.calls,ref);
+ if(data.source.stableThroughLine!==undefined)assert.ok(call.resultLine<=data.source.stableThroughLine,'Native result is outside the completed evidence prefix');
+ same(call.sessionId,data.binding.sessionId,'Native call belongs to another or unknown session');
+ assert.ok(call.requestLine>=data.binding.entryLine,'Native call predates this task');return call;
+}
+function skill(data,ref,key,before=Infinity) {
+ // Loading may be reused within this session/context, including before task binding.
+ const call=E.reference(data.source.calls,ref);
+ if(data.source.stableThroughLine!==undefined)assert.ok(call.resultLine<=data.source.stableThroughLine,'Skill result is outside the completed evidence prefix');
+ same(call.sessionId,data.binding.sessionId,'Skill session differs or is unknown');same(call.skill,key,`Actual ${key} Skill load required`);
+ assert.ok(call.requestLine>(data.source.contextLine||0),'Skill must be reloaded in the current context');
+ assert.ok(call.resultLine<before,'Skill must load before implementation or execution');return call;
+}
+function quote(data,ref) {
+ const call=nativeRef(data,ref);assert.ok(typeof ref.quote==='string'&&ref.quote.trim(),'Actual native result quote required');
+ assert.ok(E.contentText(call.result).includes(ref.quote),'Quoted finding absent from native result');return call;
+}
+function identity(d) {
+ P.validate(d.policy);assert.equal(d.binding?.schemaVersion,1,'Hook task binding required');assert.equal(d.proof?.schemaVersion,1,'Execution evidence required');
+ for(const key of ['runId','sessionId','projectKey','policyDigest'])same(d.proof[key],d.binding[key],`Execution ${key} differs`);
+ same(d.binding.policyDigest,d.policy.digest,'Execution policy differs');same(d.binding.inputDigest,d.current.inputDigest,'Inputs changed; begin a new execution run');
+ for(const key of ['inputDigest','candidateDigest','revision'])same(d.proof[key],key==='candidateDigest'?d.current.digest:d.current[key],`Current ${key} differs`);
+ assert.ok(d.source.prompts.some(p=>p.line===d.binding.entryLine),'Native user task source missing');
+}
+function frontend(d,complete) {
+ const writes=d.source.calls.filter(c=>c.success&&c.requestLine>=d.binding.entryLine&&uiWrite({...c,cwd:c.cwd||(d.source.format==='codebuddy-ide-index-v1'?d.binding.project:undefined)},d.binding.directory));
+ skill(d,d.proof.frontend,'frontend',writes.length?Math.min(...writes.map(c=>c.requestLine)):Infinity);
+ if(!complete)return;
+ assert.ok(writes.length,'Actual implementation write missing; metadata is not implementation');
+ const required=Object.keys(d.files||{}).filter(file=>/^(?:app\/src\/|mocks\/)/.test(file));
+ for(const binding of d.implementation?.bindings||[])for(const file of binding.files||[])required.push(file.path);
+ assert.ok(required.length,'Actual UI source review required');
+ exact((d.proof.frontend.files||[]).map(f=>f.path),required,'Frontend review file coverage differs');
+ for(const file of d.proof.frontend.files)same(file.sha256,E.sha(d.files[file.path]),'Frontend reviewed source bytes changed');
+ exact(d.proof.frontend.requirementIds||[],(d.scope?.requirements||[]).map(r=>r.id),'Frontend requirement review coverage differs');
+}
+function design(d) {
+ const queries=d.proof.official?.queries;assert.ok(Array.isArray(queries)&&queries.length,'Business framework queries required');
+ if(d.policy.officialCallable)skill(d,d.proof.official.skill,'antdv',Math.min(...queries.map(q=>nativeRef(d,q).requestLine)));
+ else {
+  assert.equal(d.proof.official.channel,'official-source','Disclose the equivalent official source channel');
+  const failed=d.source.calls.find(c=>c.toolCallId===d.proof.official.unavailable?.toolCallId);
+  assert.ok(failed?.skill==='antdv'&&!failed.success&&failed.resultLine&&failed.sessionId===d.binding.sessionId&&failed.requestLine>=d.binding.entryLine&&failed.requestLine>(d.source.contextLine||0)&&/not found|unavailable|not available|unknown skill|not in.*list|未找到|不可用/i.test(E.contentText(failed.result)),'Actual unavailable official Skill result required for fallback');
+ }
+ const version=quote(d,d.proof.official.version);
+ assert.ok(/(?:Read|read_file|Bash|WebFetch|mcp__)/.test(version.name),'Version must come from an actual source tool');
+ assert.ok(JSON.stringify(version.input).includes('antdv-next'),'Target package version source required');
+ assert.ok(d.frameworkVersion&&d.proof.official.version.quote.includes(d.frameworkVersion),'Target framework version was not verified');
+ const components=[...new Set((d.implementation?.bindings||[]).flatMap(b=>b.components||[]).filter(c=>!c.startsWith('application:')))];
+ for(const component of components)assert.ok(queries.some(q=>q.component===component),`Actual API query missing: ${component}`);
+ for(const query of queries) {
+  assert.ok(query.component&&(!components.length||components.includes(query.component)),'Unrelated framework query');
+  const call=quote(d,query),input=JSON.stringify(call.input);
+  assert.ok(!call.skill&&input.includes(query.component),'Probe or Skill load is not a business API query');
+  if(!d.policy.officialCallable)assert.ok(/https:\/\/(?:www\.)?(?:antdv-next\.com|github\.com\/antdv-next)|node_modules[\\/]antdv-next/.test(input),'Fallback must use official docs, types, or source');
+ }
+ if(d.policy.mode==='template') {
+  const chosen=d.proof.templateChoice?.quote;
+  const explicit=typeof chosen==='string'&&/template\s*(?:mode|模式)|模板模式|基础(?:生成|模式)|(?:选择|使用|采用)\s*template/i.test(chosen);
+  const promptChoice=typeof chosen==='string'&&d.source.prompts.some(p=>p.line<=d.binding.entryLine&&p.text.includes(chosen)&&(explicit||p.text.trim()==='template'&&chosen==='template'));
+  let answerChoice=false;
+  if(d.proof.templateChoice?.toolCallId){const answer=nativeRef(d,d.proof.templateChoice);assert.ok(/^(?:AskUserQuestion|ask_followup_question)$/.test(answer.name),'Actual native user question result required');const selected=A.extract(A.resultData(answer.result),d.proof.templateChoice.answerPointer);answerChoice=['template','模板模式','基础生成','基础模式'].includes(selected);}
+  assert.ok(promptChoice||answerChoice,'Explicit native user template choice required');return;
+ }
+ assert.ok(d.proof.uiux?.queries?.length,'Actual UIUX queries required in professional mode');
+ skill(d,d.proof.uiux.skill,'uiux',Math.min(...d.proof.uiux.queries.map(q=>nativeRef(d,q).requestLine)));
+ for(const query of d.proof.uiux.queries) {
+  const call=quote(d,query);assert.ok(!call.skill&&query.query&&JSON.stringify(call.input).includes(query.query),'UIUX probe is not a task query');
+  assert.ok(query.decisions?.length,'UIUX result decisions required');
+  for(const decision of query.decisions) {
+   assert.ok(['adopted','adjusted','rejected','no-match'].includes(decision.decision)&&decision.rationale&&decision.identity,'UIUX decision identity and rationale required');
+   assert.ok(E.contentText(call.result).includes(decision.identity),'UIUX identity absent from actual result');
+   if(['adopted','adjusted'].includes(decision.decision))assert.ok(Object.hasOwn(d.files||{},decision.implementation)&&decision.scenarioId,'Adopted UIUX result needs source and verification scenario');
+  }
+ }
+ assert.ok(d.designReview?.records?.length,'Current design review required');
+ for(const record of d.designReview.records)assert.ok(d.proof.uiux.queries.some(q=>q.query===record.query&&q.decisions.some(r=>r.identity===record.resultIdentity&&r.decision===record.decision&&r.rationale===record.rationale)),'Design review differs from actual UIUX query decisions');
+}
+function build(d) {
+ assert.ok(d.build?.buildId&&d.build?.buildDigest,'Current checked build required');
+ const call=nativeRef(d,d.proof.build),input=JSON.stringify(call.input),output=E.contentText(call.result);
+ assert.ok(['Bash','execute_command','run_terminal_command'].includes(call.name)&&input.includes('native-pilot.cjs')&&/\bbuild\b/.test(input)&&input.includes(d.binding.directory),'Actual current build command required');
+ assert.ok(output.includes(d.build.buildId)&&output.includes(d.build.buildDigest),'Native build result differs from current build');
+ same(d.build.candidateDigest,d.current.digest,'Build candidate is stale');return call;
+}
+function browser(d) {
+ const built=build(d);assert.ok(d.business&&d.devtools,'Actual business and DevTools reports required');
+ const loaded=skill(d,d.devtools.skill,'browser');
+ const calls=d.devtools.mcp?.calls;assert.ok(calls?.length,'Actual DevTools calls required');
+ for(const ref of calls) {
+  const call=nativeRef(d,ref);same(call.name,ref.tool,'DevTools native tool name differs');
+  assert.ok(/^mcp__.*chrome.*devtools.*__/.test(call.name),'CodeBuddy requires Chrome DevTools MCP');
+  assert.ok(call.requestLine>loaded.resultLine&&call.requestLine>built.resultLine,'Browser calls must follow Skill loading and the current build');
+ }
+ const preview=nativeRef(d,d.proof.browser?.preview);
+ assert.ok(/^mcp__.*chrome.*devtools.*__(?:navigate_page|new_page)$/.test(preview.name)&&JSON.stringify(preview.input).includes(d.business.previewBaseURL),'Actual current preview navigation required');
+ assert.ok(preview.requestLine>built.resultLine&&preview.requestLine>loaded.resultLine,'Preview must follow the current build and browser Skill');
+ const identityCall=quote(d,d.proof.browser?.identity);
+ assert.ok(calls.some(c=>c.toolCallId===identityCall.toolCallId)&&d.proof.browser.identity.quote.includes(d.current.digest),'Actual browser candidate identity missing');
+ for(const kind of ['dom','screenshot','console','network','accessibility','performance']) {
+  const fact=d.proof.browser.observations?.[kind],call=quote(d,fact);
+  assert.ok(calls.some(c=>c.toolCallId===call.toolCallId),`${kind} observation is not from reviewed MCP calls`);
+  assert.ok(({dom:['evaluate_script'],screenshot:['take_screenshot'],console:['list_console_messages'],network:['list_network_requests'],accessibility:['take_snapshot'],performance:['performance_stop_trace']})[kind].some(method=>call.name.endsWith(`__${method}`)),`${kind} fact uses the wrong native method`);
+ }
+ for(const journey of d.business.journeys||[]) {
+  const facts=(d.proof.browser.facts||[]).filter(f=>f.scenarioId===journey.id);assert.ok(facts.length,`Native scenario facts missing: ${journey.id}`);
+  const observation=d.business.generationObservations?.find(o=>o.scenarioId===journey.id);
+  for(const fact of facts) {
+   const call=quote(d,fact);assert.ok(/^mcp__.*chrome.*devtools.*__/.test(call.name)&&call.requestLine>preview.resultLine,'Scenario facts must follow actual preview navigation');
+   if(observation)assert.ok(observation.toolCallIds.includes(call.toolCallId)&&observation.steps.some(s=>s.observed.includes(fact.quote)),'Scenario fact differs from actual observation');
+  }
+ }
+ const fixed=A.validate(d.assertions,d.business.journeys.map(j=>j.id));
+ for(const scenario of fixed.scenarios)for(const [checkIndex,check] of scenario.checks.entries()) {
+  const fact=d.proof.browser.facts.find(f=>f.scenarioId===scenario.scenarioId&&f.checkIndex===checkIndex);assert.ok(fact,'Fixed scenario assertion has no actual native fact');
+  const call=nativeRef(d,fact);assert.ok(call.name.endsWith(`__${check.method}`),'Native fact method differs from fixed check');
+  A.compare(A.extract(A.resultData(call.result),check.pointer),check);
+ }
+}
+function evaluate(data,stage) {
+ try {
+  identity(data);const needs=P.requirements(data.policy,stage);
+  if(needs.includes('frontend')||needs.includes('implementation'))frontend(data,needs.includes('implementation'));
+  if(needs.some(n=>['antdv','official-source','uiux'].includes(n)))design(data);
+  if(needs.includes('build'))build(data);
+  if(needs.includes('browser'))skill(data,data.proof.browser?.skill||data.devtools?.skill,'browser');
+  if(needs.includes('browser-results'))browser(data);
+  return {status:'passed',stage,policyDigest:data.policy.digest,runId:data.binding.runId,sessionId:data.binding.sessionId,projectKey:data.binding.projectKey,host:'codebuddy',productForm:data.binding.product||'unreported',productVersion:data.binding.productVersion||'unreported',installationScope:data.binding.scope||'unreported',operation:data.binding.operation||data.policy.operation,mode:data.policy.mode,inputDigest:data.current.inputDigest,candidateDigest:data.current.digest,revision:data.current.revision,source:data.source.path?{path:data.source.path,bytes:data.source.bytes,digest:data.source.digest}:undefined,invocationVerification:'native-source-correlated',tamperProof:false};
+ } catch(error){return {status:'failed',stage,errors:[error.message],invocationVerification:'unverified'};}
+}
+module.exports={evaluate,uiWrite};

package/skills/i3-ui-prototype/scripts/execution-policy.cjs

@@ -0,0 +1,41 @@
+'use strict';
+const assert = require('node:assert/strict');
+const crypto = require('node:crypto');
+const ID = 'codebuddy-ab-v1';
+const SKILLS = Object.freeze({
+  frontend: [['frontend','ui','engineering'].join('-'), 'i3-frontend-ui-engineering'],
+  browser: [['browser','testing','with','devtools'].join('-'), 'i3-browser-testing-with-devtools'],
+  prototype: [['ui','prototype'].join('-'), 'i3-ui-prototype'],
+  antdv: ['antdv'], uiux: ['ui-ux-pro-max'],
+});
+const STAGES = ['design', 'implementation-entry', 'implementation', 'build', 'browser-entry', 'browser', 'delivery'];
+function digest(value) { return crypto.createHash('sha256').update(JSON.stringify(value)).digest('hex'); }
+function create(options = {}) {
+  const { host = 'codebuddy', operation = 'create', mode = 'professional', officialCallable = true } = options;
+  assert.equal(host, 'codebuddy', 'This execution policy supports CodeBuddy only');
+  assert.ok(['analyze', 'create', 'revise', 'inspect', 'confirm-baseline'].includes(operation), 'Invalid execution operation');
+  assert.ok(['professional', 'template'].includes(mode), 'Invalid execution mode');
+  assert.equal(typeof officialCallable, 'boolean');
+  const value = { schemaVersion: 1, id: ID, host, operation, mode, officialCallable,
+    readOnly: !['create', 'revise'].includes(operation), skills: SKILLS, stages: STAGES };
+  return { ...value, digest: digest(value) };
+}
+function validate(policy) {
+  assert.ok(policy && policy.id === ID, 'Unsupported execution policy');
+  const expected = create(policy);
+  assert.deepEqual(policy, expected, 'Execution policy was changed or is invalid');
+  return policy;
+}
+function requirements(policy, stage) {
+  validate(policy); assert.ok(STAGES.includes(stage), 'Unknown execution stage');
+  if (policy.readOnly) return [];
+  const design = [policy.officialCallable ? 'antdv' : 'official-source', ...(policy.mode === 'professional' ? ['uiux'] : [])];
+  return ({ design, 'implementation-entry': ['frontend'], implementation: ['frontend', 'implementation'],
+    build: ['implementation', 'build'], 'browser-entry': ['browser', 'build'],
+    browser: ['browser', 'build', 'browser-results'], delivery: [...design, 'frontend', 'implementation', 'build', 'browser', 'browser-results'] })[stage];
+}
+function skillKey(name) { return Object.keys(SKILLS).find(key => SKILLS[key].includes(name)) || null; }
+function creationOptions(options,installed) {
+  return installed?.name==='i3-composer-agent'&&options.host==='codebuddy'?{...options,executionPolicy:options.executionPolicy||ID}:options;
+}
+module.exports = { ID, SKILLS, STAGES, digest, create, validate, requirements, skillKey, creationOptions };

package/skills/i3-ui-prototype/scripts/execution-runtime.cjs

@@ -0,0 +1,60 @@
+'use strict';
+const F=require('./native-files.cjs'),{fs,path,assert,json,inside}=F;
+const P=require('./execution-policy.cjs'),E=require('./execution-evidence.cjs'),G=require('./execution-gates.cjs'),C=require('./codebuddy-context.cjs');
+const optional=(root,file)=>fs.existsSync(inside(root,file))?json(inside(root,file)):null;
+function policy(directory) {
+ const value=optional(directory,'inputs/execution-policy.json'),metaFile=inside(directory,'prototype.json');
+ if(!value&&!fs.existsSync(metaFile))return null; // Standalone legacy evidence validators have no artifact metadata.
+ const meta=json(metaFile);
+ if(!value){assert.ok(!meta.runtime.executionPolicy&&!fs.existsSync(inside(directory,'qa/execution-context.json')),'Fixed execution policy was removed');return null;}
+ P.validate(value);assert.equal(meta.runtime.executionPolicy,value.id,'Execution runtime identity differs');assert.equal(meta.expertMode,value.mode,'Execution mode changed');
+ const acceptance=json(inside(directory,'inputs/acceptance.json'));require('./execution-assertions.cjs').validate(json(inside(directory,'inputs/execution-assertions.json')),[...acceptance.requiredScenarios,...acceptance.frameworkScenarios]);return value;
+}
+function binding(directory) {
+ const pointer=optional(directory,'qa/execution-context.json');assert.ok(pointer?.schemaVersion===1,'No native Hook task binding; run execution-begin inside enabled CodeBuddy');
+ const project=fs.realpathSync(pointer.project),selected=C.select({project,product:pointer.product});assert.ok(selected,'Hooks are not enabled or are shadowed');
+ assert.equal(selected.base,pointer.base,'Effective Hook scope changed');
+ const stateDirectory=C.sessionDirectory(selected,project,pointer.sessionId),indexFile=path.join(stateDirectory,'session.json');
+ const index=JSON.parse(C.read(indexFile)||'null'),entry=index?.bindings?.[directory];assert.ok(entry,'Native Hook run is missing');
+ assert.equal(entry.runId,pointer.runId,'Native run pointer differs');assert.equal(entry.directory,directory);assert.equal(entry.project,project);
+ assert.equal(entry.instanceId,json(inside(directory,'prototype.json')).instanceId,'Prototype instance differs');
+ assert.equal(entry.registrationDigest,selected.registrationDigest,'Hook registration changed');assert.equal(entry.settingsDigest,selected.settingsDigest,'Hook settings changed');
+ C.prefix(entry.source.path,entry.source.bytes,entry.source.digest);
+ const source=C.source({session_id:entry.sessionId,transcript_path:entry.source.path},selected,project);
+ const prompt=source.prompts.find(p=>p.line===entry.entryLine);assert.equal(prompt?.digest,entry.promptDigest,'Original user task changed');
+ assert.ok(!C.readOnly(source.prompts.at(-1).text),'Latest user request is read-only or stopped');
+ return {entry,source,selected};
+}
+function data(directory,lib,options={}) {
+ directory=fs.realpathSync(directory);const fixed=policy(directory);if(!fixed)return null;
+ const {entry,source,selected}=binding(directory),current=lib.manifest(directory);
+ const proof=options.proof||optional(directory,'qa/execution-evidence.json');
+ const files={};for(const file of Object.keys(current.files))if(/^(?:app\/src\/|app\/public\/|mocks\/|design-system\/)/.test(file))files[file]=fs.readFileSync(inside(directory,file));
+ const pointer=optional(directory,'last-build.json');let build=null;
+ if(pointer)try{build=lib.verifyBuild(directory,pointer.buildId);}catch{/* A changed candidate must be allowed to rebuild; build/browser gates reject null. */}
+ const latest=optional(directory,'qa/latest.json');
+ const business=options.businessReport||(latest?json(inside(directory,latest.report)):proof?.browser?.report?json(inside(directory,proof.browser.report)):null);
+ const framework=json(inside(directory,'inputs/framework.json'));
+ return {policy:fixed,current,binding:entry,source,proof,assertions:json(inside(directory,'inputs/execution-assertions.json')),designReview:optional(directory,'qa/design-advice.json'),scope:json(inside(directory,'inputs/scope.json')),implementation:optional(directory,'design-system/implementation.json'),files,frameworkVersion:framework.profile?.versions?.['antdv-next']||json(inside(directory,'app/package.json')).dependencies['antdv-next'].replace(/^[~^]/,''),build,business,devtools:options.devtoolsReport||optional(directory,'qa/devtools-review.json'),selected};
+}
+function check(directory,stage,lib,options={}) {
+ try {const value=data(directory,lib,options);if(!value)return {status:'not-required',policy:'legacy',invocationVerification:'unverified',tamperProof:false};return G.evaluate(value,stage);}
+ catch(error){return {status:'failed',stage,errors:[error.message],invocationVerification:'unverified'};}
+}
+function requireStage(directory,stage,lib,options={}) {
+ const result=check(directory,stage,lib,options);assert.ok(['passed','not-required'].includes(result.status),`Execution gate ${stage}: ${result.errors?.join('; ')}`);return result;
+}
+function template(directory,lib) {
+ const fixed=policy(directory);assert.ok(fixed,'This existing prototype retains its original execution contract');
+ const {entry,source}=binding(fs.realpathSync(directory)),current=lib.manifest(directory);
+ const ref=key=>{const call=E.loaded(source.calls,key).filter(c=>c.requestLine>source.contextLine).at(-1);return call?{toolCallId:call.toolCallId,resultDigest:call.resultDigest}:null;};
+ return {schemaVersion:1,runId:entry.runId,sessionId:entry.sessionId,projectKey:entry.projectKey,policyDigest:fixed.digest,inputDigest:current.inputDigest,candidateDigest:current.digest,revision:current.revision,
+  frontend:{...ref('frontend'),files:[],requirementIds:[]},official:{skill:ref('antdv'),channel:fixed.officialCallable?'native-skill':'official-source',version:null,queries:[]},
+  ...(fixed.mode==='professional'?{uiux:{skill:ref('uiux'),queries:[]}}:{templateChoice:{quote:null}}),build:null,browser:{skill:ref('browser'),report:'qa/business-browser-input.json',preview:null,identity:null,observations:{},facts:[]}};
+}
+function begin(directory,lib) {
+ directory=fs.realpathSync(directory);const {entry}=binding(directory);
+ return {status:'bound',operation:'execution-begin',directory,runId:entry.runId,sessionId:entry.sessionId,policyDigest:entry.policyDigest,evidenceTemplate:template(directory,lib),
+  next:'Load applicable Skills through CodeBuddy, implement the current scope, and bind actual native result IDs in qa/execution-evidence.json. Binding is not completion.'};
+}
+module.exports={policy,binding,data,check,requireStage,template,begin};

package/skills/i3-ui-prototype/scripts/generation-assets.cjs

@@ -0,0 +1,18 @@
+'use strict';
+// Maintainer-only derived assets. Runtime analysis never invokes write mode.
+const {fs,path,assert,json,write,inside}=require('./native-files.cjs');
+function refresh(skillRoot,options={}){
+ const templates=path.join(skillRoot,'assets/templates'),catalog=json(path.join(templates,'catalog.json')),inventory=require('./template-inventory.cjs');const choices=[];const summaries=[];
+ for(const entry of catalog.templates.filter(item=>item.availability==='available'&&item.contentRoot)){
+  assert.ok(/^[a-z][a-z0-9-]{0,63}$/.test(entry.contentRoot),'Unsafe template content root');const root=inside(templates,entry.contentRoot),meta=json(path.join(root,'generation.json'));
+  assert.equal(meta.templateId,entry.id,'Generation template identity differs');
+  const current=inventory.scan(root),file=path.join(root,'template-inventory.json');
+  if(options.check)inventory.verify(root,json(file));else write(root,'template-inventory.json',current);
+  choices.push({id:entry.id,name:entry.name,defaults:meta.defaults,choices:meta.choices,patterns:meta.patterns});
+  summaries.push({id:entry.id,files:Object.keys(current.files).length,pages:current.pages.length,components:Object.keys(current.components).length,events:current.eventCount});
+ }
+ const script=`// Generated from registered template metadata; refresh with sync-generation-assets.\nglobalThis.I3_GENERATION_OPTIONS = ${JSON.stringify(choices,null,2)};\n`,file=path.join(templates,'generation-options.js');
+ if(options.check)assert.equal(fs.readFileSync(file,'utf8'),script,'Offline customer choices differ from registered template metadata');else write(templates,'generation-options.js',script);
+ return {status:'passed',readOnly:!!options.check,templates:summaries};
+}
+module.exports={refresh};