@givolt/i3-composer-agent 3.0.0 → 3.1.0

package/skills/i3-ui-demo/scripts/resources.cjs

@@ -0,0 +1,283 @@
+#!/usr/bin/env node
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const assert = require('node:assert/strict');
+const root = path.resolve(__dirname, '..');
+const catalog = require('../assets/templates.json');
+const versions = require('../assets/versions.json');
+
+function selectTemplates({ submitted = false, values = [] } = {}) {
+  if (!submitted) return { status: 'needs-selection', templates: catalog.templates };
+  if (!Array.isArray(values) || values.some(value => typeof value !== 'string')) throw new Error('Template values must be an array of submitted choices');
+  const choices = values.length ? values : [catalog.defaultTemplate];
+  const selected = [];
+  for (const value of choices) {
+    const template = catalog.templates.find(item => item.id === value || item.number === value);
+    if (!template) throw new Error(`Unknown template: ${value}`);
+    if (template.availability !== 'available') throw new Error(`Template unavailable: ${template.name}（暂未开放）`);
+    if (!selected.includes(template.id)) selected.push(template.id);
+  }
+  return { status: 'selected', selected };
+}
+
+const hash = value => crypto.createHash('sha256').update(value).digest('hex');
+const json = file => JSON.parse(fs.readFileSync(file, 'utf8'));
+function local(directory, relative) {
+  assert.ok(typeof relative === 'string' && relative && !path.isAbsolute(relative) && !relative.split(/[\\/]/).includes('..'), 'Unsafe template resource path');
+  let current = directory;
+  for (const part of relative.split('/')) {
+    current = path.join(current, part);
+    assert.ok(!fs.lstatSync(current).isSymbolicLink(), `Template symlink refused: ${relative}`);
+  }
+  return current;
+}
+function loadTemplate() {
+  const templateRoot = local(root, 'assets/templates/enterprise-admin');
+  const generation = path.join(templateRoot, 'generation.json');
+  const designRules = path.join(templateRoot, 'design-system.md');
+  const capabilityDefinition = path.join(templateRoot, 'capability-definition.json');
+  if (![generation, designRules, capabilityDefinition].every(file => fs.existsSync(file) && fs.statSync(file).isFile())) {
+    throw new Error('This i3-ui-demo skill is missing its own enterprise-admin template resources. Restore this skill; no other skill template or demo substitute was selected.');
+  }
+  const inventory = json(local(templateRoot, 'template-inventory.json'));
+  for (const [relative, expected] of Object.entries(inventory.files)) {
+    assert.equal(hash(fs.readFileSync(local(templateRoot, relative))), expected, `Template resource integrity changed: ${relative}`);
+  }
+  const meta = json(generation), definition = json(capabilityDefinition), manifest = json(local(templateRoot, 'template.json'));
+  assert.equal(definition.schemaVersion, 2, 'Unsupported independent capability contract');
+  assert.equal(meta.definitionDigest, hash(JSON.stringify(definition)), 'Template capability definition digest changed');
+  assert.equal(meta.templateId, manifest.id, 'Template metadata identity differs');
+  for (const id of definition.core) assert.ok(definition.capabilities[id], `Missing core capability: ${id}`);
+  for (const [id, capability] of Object.entries(definition.capabilities)) {
+    assert.equal(capability.id, id, 'Capability identity differs');
+    assert.ok(capability.implementation?.components?.length, `Missing native mapping: ${id}`);
+    assert.ok(capability.scenarios.length && new Set(capability.scenarios.map(item => item.id)).size === capability.scenarios.length, `Invalid capability scenarios: ${id}`);
+    const native = capability.nativeChecks || [];
+    assert.equal(new Set(native.map(check => check.id)).size, native.length, `Duplicate native checks: ${id}`);
+  }
+  for (const pattern of meta.patterns) {
+    assert.ok(definition.patterns[pattern], `Missing pattern: ${pattern}`);
+    for (const id of definition.patterns[pattern].required) assert.ok(definition.capabilities[id], `Unmapped pattern capability: ${id}`);
+  }
+  const preset = json(local(templateRoot, 'preset.json'));
+  return { templateRoot, generation, designRules, capabilityDefinition, inventory, definition, meta, manifest, preset,
+    templateDigest: hash(JSON.stringify({ manifest, inventory })) };
+}
+
+function visualProfile(context) {
+  const semantic = context.preset.semantic;
+  return { source: 'preset.json', semantic, nativeTokens: {
+    colorPrimary: semantic['easel-primary'], colorBgLayout: semantic['easel-page'], colorBgContainer: semantic['easel-surface'],
+    colorText: semantic['easel-text'], colorTextSecondary: semantic['easel-secondary'], colorBorder: semantic['easel-border-strong'],
+    colorBorderSecondary: semantic['easel-border'], fontFamily: semantic['easel-font'], fontSize: Number.parseInt(semantic['easel-body'], 10),
+    borderRadius: Number.parseInt(context.preset.component['ant-border-radius'], 10), controlHeight: Number.parseInt(context.preset.component['ant-control-height'], 10),
+  }, panelRadius: Number.parseInt(semantic['easel-radius'], 10), spacing: Number.parseInt(semantic['easel-space-6'], 10) };
+}
+function resolveResources() {
+  const context = loadTemplate();
+  return { template: { ...catalog.templates[0], version: context.manifest.version },
+    templateRoot: context.templateRoot, generation: context.generation, designRules: context.designRules,
+    capabilityDefinition: context.capabilityDefinition, templateDigest: context.templateDigest,
+    templateInventory: path.join(context.templateRoot, 'template-inventory.json'),
+    componentInventory: path.join(context.templateRoot, 'component-inventory.json'), preset: path.join(context.templateRoot, 'preset.json'),
+    summary: { pages: context.inventory.pages.length, routes: context.inventory.routes.length,
+      capabilities: Object.keys(context.definition.capabilities).length, patterns: context.meta.patterns },
+    referencePages: context.inventory.pages.map(page => ({ id: pageId(page.component), fragment: page.fragment, routes: page.routes })),
+    visual: visualProfile(context), starter: path.join(root, 'assets/starter'), versions, skillRoot: root };
+}
+const pageId = component => path.posix.basename(component, '.js').replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase();
+function reference(context, id) {
+  const selected = id === 'app-shell' ? { fragment: context.meta.shell, routes: [] } : context.inventory.pages.find(page => pageId(page.component) === id);
+  assert.ok(selected, `Unknown reference page: ${id}`);
+  const fragments = new Map(context.inventory.fragments.map(item => [item.file, item])), visited = new Set(), elements = [];
+  function visit(file) {
+    if (visited.has(file)) return;
+    visited.add(file);
+    const fragment = fragments.get(file); assert.ok(fragment, `Reference fragment missing: ${file}`);
+    for (const node of fragment.nodes) {
+      const name = node.attributes['data-component'], component = context.inventory.components[name];
+      if (name) assert.ok(component?.classification, `Unclassified reference component: ${name}`);
+      const capabilities = (component?.classification.capabilities || []).filter(value => value !== 'review-tools');
+      const events = Object.entries(node.attributes).filter(([key]) => key.startsWith('data-on-')).map(([event, expression]) => ({ event, expression }));
+      if (events.length || (component?.classification.kind !== 'icon' && capabilities.length)) elements.push({ id: node.id, fragment: file, component: name || null, capabilities, events });
+      if (component?.classification.source) visit(component.classification.source);
+    }
+  }
+  visit(selected.fragment);
+  const behaviorFiles = new Set();
+  function behavior(file) {
+    if (behaviorFiles.has(file)) return;
+    assert.ok(Object.hasOwn(context.inventory.files, file), `Reference behavior missing: ${file}`);
+    behaviorFiles.add(file);
+    const text = fs.readFileSync(local(context.templateRoot, file), 'utf8');
+    for (const match of text.matchAll(/\b(?:from\s*|import\s*)["']([^"']+)["']/g)) {
+      if (match[1].startsWith('.')) behavior(path.posix.normalize(path.posix.join(path.posix.dirname(file), match[1])));
+    }
+  }
+  for (const file of visited) {
+    const js = file.replace(/\.html$/, '.js');
+    if (Object.hasOwn(context.inventory.files, js)) behavior(js);
+  }
+  return { id, templateDigest: context.templateDigest, routes: selected.routes,
+    fragments: [...visited].map(file => ({ file, digest: context.inventory.files[file], elements: elements.filter(item => item.fragment === file).length })),
+    behaviorFiles: [...behaviorFiles].sort(), styleFiles: Object.keys(context.inventory.files).filter(file => file.endsWith('.css')),
+    elements, capabilities: [...new Set(elements.flatMap(item => item.capabilities))].sort() };
+}
+function readPage(id) { return reference(loadTemplate(), id); }
+function readCapability(id) {
+  const context = loadTemplate(), capability = context.definition.capabilities[id];
+  assert.ok(capability, `Unknown capability: ${id}`);
+  return { ...capability, frameworkId: context.definition.frameworkId, componentVersion: versions.component.version };
+}
+
+function parameters(capability, supplied = {}, pattern = '') {
+  const value = { ...capability.defaults, ...supplied };
+  if (capability.id === 'pagination' && supplied.mode === 'fixed') {
+    for (const key of ['defaultPageSize', 'pageSizeOptions']) {
+      assert.ok(!Object.hasOwn(supplied, key), `Fixed pagination cannot contain ${key}`); delete value[key];
+    }
+  }
+  if (capability.id === 'feedback' && !Object.hasOwn(supplied, 'states')) value.states = ['edit-form','form-page','wizard','permissions'].includes(pattern) ? ['loading','error','success'] : ['loading','empty','error','success'];
+  for (const [key, rule] of Object.entries(capability.parameters)) {
+    const item = value[key];
+    if (rule.required || (rule.requiredInMode && rule.requiredInMode === value.mode)) assert.ok(item !== undefined, `Missing ${capability.id}.${key}`);
+    if (item === undefined) continue;
+    if (rule.enum) assert.ok(rule.enum.includes(item), `Invalid ${capability.id}.${key}`);
+    if (rule.boolean || rule.type === 'boolean') assert.equal(typeof item, 'boolean', `Invalid boolean: ${key}`);
+    if (rule.string || rule.type === 'string') assert.ok(typeof item === 'string' && item.trim(), `Invalid string: ${key}`);
+    if (rule.integer || rule.type === 'integer') assert.ok(Number.isInteger(item) && item >= (rule.minimum ?? rule.integer ?? 0), `Invalid integer: ${key}`);
+    if (rule.type === 'array' || rule.strings || rule.positiveIntegers) assert.ok(Array.isArray(item), `Invalid array: ${key}`);
+    if (rule.strings) assert.ok(item.every(entry => typeof entry === 'string' && entry.trim()), `Invalid strings: ${key}`);
+    if (rule.positiveIntegers) assert.ok(item.length >= 2 && new Set(item).size === item.length && item.every(entry => Number.isInteger(entry) && entry > 0), `Invalid page-size options: ${key}`);
+    if (rule.minItems) assert.ok(item.length >= rule.minItems, `Too few items: ${key}`);
+    if (rule.uniqueItems) assert.equal(new Set(item).size, item.length, `Duplicate items: ${key}`);
+    if (rule.includes) assert.ok(rule.includes.every(entry => item.includes(entry)), `Missing required values: ${key}`);
+    if (rule.includesByMode) {
+      const mode = ['edit-form','form-page','wizard','permissions'].includes(pattern) ? 'edit-form' : ['management-list','tree-list','tree-table'].includes(pattern) ? 'management-list' : 'content';
+      assert.ok((rule.includesByMode[mode] || []).every(entry => item.includes(entry)), `Missing ${mode} states`);
+    }
+  }
+  for (const key of Object.keys(value)) assert.ok(Object.hasOwn(capability.parameters, key), `Unknown ${capability.id} parameter: ${key}`);
+  if (capability.id === 'pagination') {
+    assert.ok(value.mode === 'fixed' ? Number.isInteger(value.fixedPageSize) && value.fixedPageSize > 0 : !Object.hasOwn(value, 'fixedPageSize') && value.pageSizeOptions?.includes(value.defaultPageSize), value.mode === 'fixed' ? 'fixedPageSize is required' : 'Invalid adjustable pagination');
+  }
+  return value;
+}
+const validId = value => typeof value === 'string' && /^[a-z][a-z0-9-]{0,63}$/.test(value);
+function plan(scope) {
+  const context = loadTemplate(), definition = context.definition;
+  assert.ok(Array.isArray(scope.pages) && scope.pages.length, 'Business pages are required');
+  const requirements = new Map((scope.requirements || []).map(item => [item.id, item]));
+  assert.ok(requirements.size && requirements.size === scope.requirements.length, 'Unique sourced business requirements are required');
+  for (const item of requirements.values()) assert.ok(item.id?.trim() && item.text?.trim() && ['type','reference','statement'].every(key => typeof item.source?.[key] === 'string' && item.source[key].trim()), 'Requirement source is missing');
+  const presentation = { ...context.meta.defaults, ...(scope.generation?.presentation || scope.presentation) };
+  for (const [key, value] of Object.entries(presentation)) assert.ok(Object.hasOwn(context.meta.choices[key] || {}, value), `Unsupported presentation: ${key}`);
+  const bindings = [], coverage = [{ pageId: 'app-shell', ...reference(context, 'app-shell') }], pageIds = new Set();
+  function bind(page, region, id, values = {}, pattern = '') {
+    const capability = definition.capabilities[id]; assert.ok(capability, `Unknown capability: ${id}`);
+    const binding = { id: `${page}/${region}/${id}`, pageId: page, regionId: region, capabilityId: id, parameters: parameters(capability, values, pattern) };
+    if (!bindings.some(item => item.id === binding.id)) bindings.push(binding);
+  }
+  for (const id of definition.core) bind('app-shell', 'shell', id);
+  const businessDetails = [];
+  for (const page of scope.pages) {
+    assert.ok(validId(page.id) && page.id !== 'app-shell' && !pageIds.has(page.id) && page.title?.trim(), 'Invalid or duplicate business page'); pageIds.add(page.id);
+    assert.ok([...requirements.values()].some(item => item.pages?.includes(page.id)), `Page lacks a business requirement: ${page.id}`);
+    coverage.push({ pageId: page.id, ...reference(context, page.referencePage) });
+    assert.ok(Array.isArray(page.regions) && page.regions.length, 'Page regions are required');
+    const regions = new Set();
+    for (const region of page.regions) {
+      assert.ok(validId(region.id) && !regions.has(region.id), 'Invalid or duplicate region'); regions.add(region.id);
+      const pattern = region.pattern || region.mode; assert.ok(context.meta.patterns.includes(pattern), `Unsupported pattern: ${pattern}`);
+      const selected = new Set(definition.patterns[pattern].required);
+      const edit = region.parameters?.edit?.presentation || (pattern === 'edit-form' ? 'drawer' : 'page');
+      if (['form-page','wizard','permissions'].includes(pattern)) assert.equal(edit, 'page', 'Full-page pattern requires page presentation');
+      if (pattern === 'edit-form') assert.ok(['drawer','modal'].includes(edit), 'Edit-form requires drawer or modal presentation');
+      if (selected.has('edit') && edit !== 'page') selected.add('dialog');
+      for (const id of Object.keys(region.parameters || {})) assert.ok(selected.has(id), `Unused capability parameters: ${id}`);
+      for (const id of selected) {
+        const defaults = id === 'edit' || id === 'dialog' ? { presentation: edit } : id === 'hierarchy' ? { kind: pattern === 'tree-table' ? 'tree-table' : pattern === 'permissions' ? 'permission-tree' : 'filter-tree', selectionPolicy: pattern === 'permissions' ? 'cascade' : pattern === 'tree-table' ? 'independent' : 'single' } : {};
+        bind(page.id, region.id, id, { ...defaults, ...region.parameters?.[id] }, pattern);
+      }
+      for (const [kind, items] of Object.entries({ field: region.fields || [], action: region.actions || [] })) {
+        if (!items.length && !region.emptyReason?.trim()) businessDetails.push({ pageId: page.id, regionId: region.id, kind, reason: 'Declare actual business details or explain why none apply' });
+        const seen = new Set();
+        for (const item of items) {
+          assert.ok(validId(item.id) && !seen.has(item.id) && item.label?.trim() && requirements.get(item.requirementId)?.pages?.includes(page.id), 'Business field/action requires a unique identity and matching requirement'); seen.add(item.id);
+          if (kind === 'field') assert.ok(item.type?.trim(), 'Business field type is required');
+          if (kind === 'action') assert.ok(item.outcome?.trim() && ['page','row','selected','node'].includes(item.target), 'Action target and outcome are required');
+          bindings.push({ id: `${page.id}/${region.id}/${kind}/${item.id}`, pageId: page.id, regionId: region.id, capabilityId: 'interaction', kind, parameters: item });
+        }
+      }
+    }
+  }
+  for (const item of requirements.values()) assert.ok(item.pages?.length && item.pages.every(id => pageIds.has(id)), 'Requirement references an unknown business page');
+  const decisions = scope.generation?.decisions || [], referenceDecisions = scope.generation?.referenceDecisions || [];
+  const decided = new Set();
+  for (const item of decisions) {
+    const key = `${item.pageId}/${item.capabilityId}`;
+    assert.ok(!decided.has(key) && definition.capabilities[item.capabilityId] && ['adopted','not-applicable'].includes(item.decision) && item.reason?.trim(), 'Invalid or duplicate capability decision'); decided.add(key);
+    const requirement = requirements.get(item.requirementId);
+    assert.ok(requirement && (item.pageId === 'app-shell' || requirement.pages.includes(item.pageId)), 'Capability decision needs a matching source');
+    const required = bindings.some(binding => (binding.pageId === item.pageId || binding.pageId === 'app-shell') && binding.capabilityId === item.capabilityId);
+    assert.ok(!(required && item.decision === 'not-applicable'), 'Required capability cannot be excluded');
+    if (item.decision === 'adopted' && !required) {
+      const region = scope.pages.find(page => page.id === item.pageId)?.regions.find(region => region.id === item.regionId);
+      assert.ok(region, 'Adopted capability needs a declared region'); bind(item.pageId, item.regionId, item.capabilityId, item.parameters, region.pattern || region.mode);
+    }
+  }
+  const accounted = new Set(), referenceScenarios = [];
+  for (const item of referenceDecisions) {
+    const selected = coverage.find(entry => entry.pageId === item.pageId), requirement = requirements.get(item.requirementId);
+    assert.ok(selected && requirement && (item.pageId === 'app-shell' || requirement.pages.includes(item.pageId)) && item.reason?.trim() && ['mapped','not-applicable'].includes(item.decision) && item.nodeIds?.length, 'Reference decision needs actual nodes and a matching source');
+    for (const id of item.nodeIds) {
+      const element = selected.elements.find(entry => entry.id === id), key = `${item.pageId}/${id}`;
+      assert.ok(element && !accounted.has(key), 'Unknown or duplicate reference element'); accounted.add(key);
+      if (item.decision === 'mapped') {
+        assert.ok(item.bindingIds?.length && item.bindingIds.every(id => bindings.some(binding => binding.id === id && (binding.pageId === item.pageId || binding.pageId === 'app-shell'))), 'Reference element requires matching implementation bindings');
+        const mapped = bindings.filter(binding => item.bindingIds.includes(binding.id));
+        assert.ok(!element.capabilities.length || element.capabilities.some(id => mapped.some(binding => binding.capabilityId === id)), 'Reference capability mapping does not match the element');
+        if (element.events.length) assert.ok(mapped.some(binding => binding.kind === 'action') || item.behavior?.trim(), 'Reference event needs a business action or explicit observable behavior');
+        referenceScenarios.push({ id: `reference/${item.pageId}/${id}`, pageId: item.pageId, referenceNodeId: id,
+          bindingIds: item.bindingIds, events: element.events, expected: item.behavior || item.reason });
+      } else assert.ok(!item.bindingIds?.length, 'Excluded reference element cannot claim an implementation');
+    }
+  }
+  const scenarios = bindings.flatMap(binding => {
+    if (binding.kind) return [{ id: `template/${binding.id}`, bindingId: binding.id, expected: binding.kind === 'action' ? binding.parameters.outcome : `字段 ${binding.parameters.label} 的类型、校验、只读和联动符合声明` }];
+    const capability = definition.capabilities[binding.capabilityId];
+    return [...capability.scenarios, ...(capability.nativeChecks || []).filter(check => !check.when || Object.entries(check.when).every(([key,value]) => binding.parameters[key] === value)).map(check => ({ ...check, id: `native/${check.id}` }))]
+      .map(check => ({ ...check, id: `template/${binding.id}/${check.id}`, bindingId: binding.id, parameters: binding.parameters }));
+  });
+  return { schemaVersion: 1, status: 'pending-implementation', executionVerified: false,
+    template: { id: context.manifest.id, version: context.manifest.version, digest: context.templateDigest },
+    component: versions.component, presentation, visual: visualProfile(context), pages: scope.pages, bindings, scenarios: [...scenarios, ...referenceScenarios],
+    frameworkChecks: definition.frameworkChecks, requiredChecks: definition.requiredChecks, browserReview: definition.browserReview,
+    pendingBusinessDetails: businessDetails,
+    pendingDecisions: coverage.flatMap(item => item.capabilities.filter(id => !bindings.some(binding => (binding.pageId === item.pageId || binding.pageId === 'app-shell') && binding.capabilityId === id) && !decided.has(`${item.pageId}/${id}`)).map(capabilityId => ({ pageId: item.pageId, capabilityId }))),
+    referenceCoverage: coverage, referenceDecisions,
+    pendingReferenceElements: coverage.flatMap(item => item.elements.filter(element => !accounted.has(`${item.pageId}/${element.id}`)).map(element => ({ pageId: item.pageId, ...element }))),
+  };
+}
+
+module.exports = { root, catalog, versions, selectTemplates, resolveResources, readPage, readCapability, plan };
+if (require.main === module) {
+  try {
+    const args = process.argv.slice(2); let output;
+    if (!args.length) output = resolveResources();
+    else if (args[0] === '--capability' && args.length === 2) output = readCapability(args[1]);
+    else if (args[0] === '--plan' && args.length === 2) output = plan(json(path.resolve(args[1])));
+    else if (args[0] === '--page' && [2,4].includes(args.length)) {
+      const page = readPage(args[1]);
+      if (args.length === 4) {
+        assert.equal(args[2], '--fragment', 'Expected --fragment');
+        assert.ok(page.fragments.some(fragment => fragment.file === args[3]), 'Fragment is outside the selected page');
+        output = { page: page.id, file: args[3], html: fs.readFileSync(local(resolveResources().templateRoot, args[3]), 'utf8'), elements: page.elements.filter(item => item.fragment === args[3]) };
+      } else { const { elements, ...summary } = page; output = { ...summary, elementCount: elements.length, next: 'Use --fragment <listed-path> to read actual HTML and its functional nodes' }; }
+    } else throw new Error('Use no arguments, --page <id> [--fragment <path>], --capability <id>, or --plan <scope.json>');
+    process.stdout.write(JSON.stringify(output, null, 2) + '\n');
+  }
+  catch (error) { process.stderr.write(JSON.stringify({ status: 'failed', errors: [error.message] }) + '\n'); process.exitCode = 1; }
+}

package/skills/i3-ui-prototype/SKILL.md

@@ -57,7 +57,7 @@ analyze 的交付是需求／能力覆盖、模板与框架选型、交互验收
 
 已有 v2 实例先运行一次 `node <skill-root>/scripts/native-pilot.cjs state <prototype-root>`，从聚合结果恢复身份、固定需求、设计／构建／实际QA、负责人和下一步的精确命令。不要为寻找参数反复遍历全仓库、node_modules或阅读控制器内部实现。这里只读检查，不安装、启动浏览器或更新状态。
 
-制作前实际调用所需的前端／框架／设计 Skill，真实浏览器验收使用浏览器 Skill；不能以读取 SKILL.md 代替调用。安装器注册的 Hooks 自动运行。收到缺少 Skill 的反馈时，补调该 Skill、等待成功后重试原操作。同一有效上下文内的成功加载可复用，普通追问后继续原任务，不重新绑定或重复加载全部 Skill；基础设施异常只简要报告未验收项，由独立维护入口处理，不在原型任务中排查。
+制作前实际调用所需的前端／框架／设计 Skill，真实浏览器验收使用浏览器 Skill；不能以读取 SKILL.md 代替调用。缺少必要 Skill 时先补调并等待成功，再继续原操作。同一有效上下文内的成功加载可复用，普通追问后继续原任务，不重新绑定或重复加载全部 Skill；基础设施异常只简要报告未验收项，由独立维护入口处理，不在原型任务中排查。
 
 新 create 使用实际 `--host <codebuddy|workbuddy>`。按 PRD 和固定能力制定交互验收场景，使用 `native-pilot.cjs execution-assertions-template --scope <scope-file>` 取得场景骨架，填充预期 JSON 事实并传 `--execution-assertions <assertions-file>`。这是原型交互验收，不要求手动绑定会话或填写 Hook 调用记录。旧 HTML 和既有 execution-* 入口保持兼容。
 

package/skills/i3-ui-prototype/references/execution-evidence.md

@@ -8,25 +8,17 @@
 默认使用简体中文解释、追问及生成报告；用户明确要求其他语言时可切换。原方法正文、引用、阈值和审批条件完整保留。代码标识、路径、命令、工具参数、JSON 键/枚举与原文引用保持原样。
 <!-- i3:zh-guide:end -->
 
-当前正常流程由安装器注册的 Hooks 自动采集真实 Skill 和工具调用。原型会话直接制作、修订和验收 UI；没有手动 execution-begin、检查 Hook 或填写内部调用记录的前置。缺少必要 Skill 时只补调该 Skill 并重试原操作。安装、原生协议和失败诊断统一见随包 [Hooks 维护说明](../../../hooks/PROTOTYPE.md)，不属于原型工作步骤。
+原型自动审计 Hook 已移除，安装器不再注册 prototype 组，旧事件入口不再采集、拦截、补调或阻止 Stop。原型会话继续按 Skill 正文实际加载适用技能、制作 UI、构建和验收；不要求 execution-begin、Hook 会话绑定或内部调用记录作为正常流程的前置。配置清理见 [Hooks 维护说明](../../../hooks/PROTOTYPE.md)。
 
-以下为已有显式 execution-* 使用者保留的兼容格式与旧手动流程，不作为新任务指导；已有原型不会自动改写。
+## 当前执行与验收
 
-## 旧 Buddy A＋B 执行与补调合同
+正常 build、record-run、record-devtools-review、finalize 和 state 不进入 Hook 调用审计。审计字段显示 `auditHook=retired`、`invocationVerification=unverified`，不作为已通过的调用证明。固定输入、业务断言、依赖、实际构建、业务报告、浏览器证据与交付摘要仍按各自合同检查；缺少这些证据仍不能通过。
 
-本合同适配 CodeBuddy IDE／CLI 和 WorkBuddy 桌面 command Hooks；各宿主项目／全局的真实调用、补调及业务效果仍须逐项手测，profile 保持 pending-user。不是新增专责 Agent，不改 using 的发现／路由、上游前端／浏览器方法或上游 Hooks。A 是确定性门禁，B 采集与绑定原生来源；没有 C 提示词对照表方案。
+原型 Skill 仍要求前端技能在首次 UI 写入前成功加载，适用时实际调用 antDv、UIUX 和浏览器技能。读取 SKILL.md、模型自述或已有审计状态不能代替真实调用。移除自动回调不承诺自动发现或阻止所有漏调。
 
-## 安装范围与原生生效
+## 安装与历史保留
 
-安装器对 CodeBuddy／WorkBuddy 默认注册 prototype 组，不再询问是否启用、组或 IDE／CLI；非交互同默认。其他原版组仍交付脚本，但不新增注册。已有启用组保留，明确禁用由 state/i3-composer-agent/hooks.json 的 prototypeDisabledHosts 记忆；只有显式 enable 撤销禁用。显式 --hooks keep 保留状态，--hooks enable|list|check|disable 和 --hook-groups 继续作为管理参数；旧 --prototype-hooks 仅管理原型组。新注册 product=auto、schemaVersion=2；旧 ide/cli 注册和参数兼容，可安全升级到 auto，手改和未知归属不接管。
-
-每次仅使用原生 Hook 的 transcript_path 具体文件，校验 session_id、实际项目和工具请求／结果，不扫描最新日志。真实 client 或已配置宿主原生日志位置用于身份识别，身份缺失／冲突不能默认 CLI。WorkBuddy 5.8.3 安装程序源代码表明其桌面使用 CLI 后端协议和原生项目会话 JSONL；本地源代码核对不替代实际回调。--codebuddy-transcript-root／--transcript-root 可设置手动限制，已有 manual roots 不被默认升级放宽；显式 auto 才切回自动。
-
-原型 Hook 的新注册入口是 `<host-base>/i3-composer-agent/hooks/i3-prototype.cjs`，委托本 Skill 的 `scripts/hosts/codebuddy.cjs`；旧入口继续兼容。统一管理入口为同目录 `manage.cjs`，原版三组由 `codebuddy-upstream.cjs` 包装，原脚本不改。项目设置在 `.codebuddy/settings.json`；全局 CodeBuddy 为 CODEBUDDY_CONFIG_DIR 或 ~/.codebuddy，全局 WorkBuddy 为 WORKBUDDY_CONFIG_DIR 或 ~/.workbuddy。原型归属在 <host-base>/state/i3-prototype/installation.json，通用归属在 <host-base>/state/i3-composer-agent/hooks.json。项目注册引用项目副本，全局注册引用全局副本。保留原设置、权限和其他 Hook；无效 JSON、被手改的自有注册或未知配置归属拒绝合并；共享 Buddy 项目只注册一个入口，hosts 分别记录与禁用。Windows 命令引用尚未验证，此 B profile 不宣称支持。
-
-独立统一管理可调用 `node <host-base>/i3-composer-agent/hooks/manage.cjs list|check|enable|disable --host codebuddy|workbuddy --scope project|global --project <project-root> --groups prototype`。旧 `node <skill-root>/scripts/prototype-hooks.cjs check|enable|disable` 参数保持且只针对 prototype。无需指定 product；旧 `--product ide|cli` 兼容，`--product-version <实际版本>` 可记录安装信息；可选 `--transcript-root <目录|auto>`。全局配置根按所选宿主遵循绝对 CODEBUDDY_CONFIG_DIR／WORKBUDDY_CONFIG_DIR，默认 ~/.codebuddy／~/.workbuddy，工具、注册、状态和运行时选择使用同一根。check 不执行安装、不写配置或缓存。首次没有实际日志时 `transcript.status=awaiting-native-event`，配置可注册但证据尚未核验；不是安装失败，也不算 active。CLI 注册后需用户在原生 `/hooks` 审核，然后新建会话；IDE 需重载。状态为 files-present／registered／pending-host-review／active／failed 等，active 只指展示的项目／会话和当前注册／脚本字节的近期事件。它不代表所有项目已激活或业务已通过。原版三组的 triggered 仅表示包装回调观察，仍是未核验等级。
-
-CodeBuddy IDE 对存在的项目设置保守按覆盖处理，不能穿透到全局冒称生效；CodeBuddy CLI／WorkBuddy 在项目／全局合并来源中优先选自有项目绑定，否则全局。未选中的回调退出，选中状态用锁和原生来源游标去重。配置、脚本或 profile 改动使旧观察失效；重复启用不增加注册。disable 仅撤销自有配置，不删除原型与 QA。卸载核心前先 disable，避免悬空自有命令。
+新装不创建原型审计注册。升级按精确归属清理所选宿主范围的旧注册，归属记录归档到 `state/i3-prototype/history/`；用户配置、其他 Hook、旧会话与原型保留。手改或未知归属先停下报告，不能覆盖。旧 helper／参数仅兼容 check、disable／keep 清理；prototype enable 已拒绝。check 只读，不扫描原生日志、不构造新的调用证据。
 
 ## 新实例的固定预期
 
@@ -46,50 +38,14 @@ node <skill-root>/scripts/native-pilot.cjs execution-assertions-template --scope
 
 实际原生 evaluate_script 应读取真实 DOM／组件可观察状态并返回可解析 JSON（或唯一 JSON 代码块），例如 `{"form":{"invalidFields":1}}`。使用正常 click／fill 等完成业务操作，不在求值中直接修改业务状态制造通过。支持 equals、includes、gte、lte，JSON pointer 路径必须存在。视觉、语义、动效中间态、毛玻璃呈现仍按浏览器 Skill 方法复核，数值检查不代替人工质量判断。
 
-## 会话绑定与阶段
-
-以下显式入口仅供已有使用者兼容：通过自然语言／using 选到工作 Skill，或实际 `/i3-prototype` 快捷入口后，执行 `execution-begin <prototype-root>`。B 回查原生来源，关联 projectKey、sessionId、runId、实例、输入、模式、策略与注册。只读或停止请求不能启动写任务。新会话／压缩后的上下文需重新核验适用 Skill；普通追问延续原运行，不要求重新 begin。用户手改保留。初建骨架不等于实际实施。
-
-使用 `state` 中的 `commands.executionBegin.shell` 或拒绝反馈中的绝对路径命令，作为一次独立 Shell 调用；不加 `cd &&`、管道、重定向或 `head`。严格解析器不解释组合 Shell。成功须同时满足进程退出 0 和内层 `status=bound`；外层 `status=success`／`success:true` 不足以证明阶段成功。缺绑定、任务切换、上下文变化或输入变化时重新执行，不能由 CLI 自行写入原生绑定；A 和写入门禁回查当前任务最新一次 begin 的成功结果，失败／待返回不可复用旧成功。
-
-原始工具名 `use_skill`／`skill` 与 `Skill` 通过同一有限别名表识别；IDE 历史转换和原始 JSONL 采用相同规则。保留原始请求／结果摘要、调用 ID、会话与时序校验，普通 Read、未知近似名称仍不算 Skill。原生 execute_command 的内层非零退出、错误结果或 stdout 中完整 JSON `status=failed` 都按失败处理；不会把浏览器返回的任意业务 `result.status` 当成工具错误。
-
-`execution-template <prototype-root>` 只读返回当前证据骨架和已经成功返回的 Skill 引用；保存并填入 `qa/execution-evidence.json`。字段语义：
-
-- 固定身份：schemaVersion=1、runId、sessionId、projectKey、policyDigest、inputDigest、candidateDigest、revision，须与当前绑定一致。
-- frontend：真实 Skill 的 toolCallId／resultDigest；files 覆盖实际 app/src、mocks 和实现映射引用，每项 path／sha256；requirementIds 覆盖固定需求。首次业务 UI Write／Edit 在成功加载之后；实现后依据完整前端规范审查，而非只改 adapted。
-- official：skill 真实 antDv 加载；version 是目标版本包／类型／源码查询的真实 toolCallId 和 quote；queries 每项 component、toolCallId、quote，覆盖当前实现映射的实际框架组件。CLI 数据 1.5.2 不得当成目标 1.5.3。固定 probe 不能替代业务 API 核实。合法 fallback 需 channel=official-source、unavailable.toolCallId 指向真实不可用返回，以及官方资料／目标类型结果。
-- uiux（professional）：真实 skill 引用；queries 每项 query、toolCallId、quote、decisions；decision 字段 identity、decision、rationale，采用／调整还要 implementation 和 scenarioId。原始条目身份必须在返回中，且与 qa/design-advice.json 的 resultIdentity、query、decision、rationale 一致。拒绝或 no-match 允许，不能假称采用。template 需 templateChoice.quote 指向真实用户的明确模式选择，功能场景照验。
-- build：实际 native-pilot build 调用的 toolCallId，成功返回必须包含当前 buildId／buildDigest；类型检查、测试和构建按原构建合同。
-- browser：真实浏览器 Skill 引用、report（尚未 record-run 的业务报告可位于 QA）、preview（当前构建 navigate_page／new_page 引用）、identity（实际页面返回的候选摘要 quote）、observations（六类对应原生方法的 toolCallId／quote）、facts。facts 每项 scenarioId、checkIndex、toolCallId、quote 连接固定预期和实际 JSON；每个场景／检查都有成功的真实工具返回。原 devtools 与业务报告的 ID、方法、场景、构建和文件摘要继续校验。
-
-所有引用回查实际 assistant/tool_use、user/tool_result 原文配对。读取 Skill 文件不当成原生加载；只有请求、失败返回、空结果、假 ID、旧会话、上下文失效、无关查询、错误版本、旧构建、被改写的源前缀均不能通过。来源字段来自 command Hook 的 transcript_path／session_id；若宿主日志不是支持的 JSONL 或缺实际会话字段，则 unverified。auto 只使用回调给定的具体文件，校验绝对路径、普通非链接文件、大小、业务目录排除与会话身份；不把任意父目录纳入信任。manual 还必须落在指定日志根。普通模型 JSON 不能替代原生来源，路径及摘要检查仍非防同用户篡改。
-
-本期按完整当前任务重新核验查询；未提供跨任务自动继承查询的捷径。同一会话与上下文内可复用真实 Skill 加载。修复 U01 时先加载、检查现有页面并作本次真实修订；不把旧写入倒填为已满足历史前置。
-
-## 门禁、回传与限制
-
-`execution-check --stage design|implementation-entry|implementation|build|browser-entry|browser|delivery`、build、record-run、record-devtools-review、finalize 使用同一谓词。state 展示 execution 缺项及恢复命令，finalize 成功收据包含 runId／policyDigest、证据摘要和调用等级；HANDOFF 显示同一结果。修改源码／输入／设计／QA 会使相应检查失效，旧收据不能复用。
-
-B 的 PreToolUse 只拒绝可识别的缺前置 UI 写入或明确阶段命令，不返回强制 allow，不替换原生结果。它不是通用 Shell 文件隔离器；未知 Shell 写法和所有自然语言完成方式不保证被拦截。新 buddy-ab-v2 的 Stop 对已纳管当前任务、可识别的完成声明且缺有效收据时按有限预算反馈；旧 codebuddy-ab-v1 保留原单次反馈合同。进度、blocked、awaiting-input、用户停止正常结束，不能无限循环。崩溃／超时不生成成功记录，A 拒绝无有效来源的严格完成。
-
-本地原文、索引与配置同属用户权限域，`native-source-correlated` 表示受配置来源的逐项回查，不是防篡改签名。文件摘要、chmod、机器落盘或模型自述均不能单独证明可信。若日志本身缺独立可信来源，结果继续披露 unverified，需用户检查真实宿主调用。本测试包原生 profile 状态 pending-user；源码／合成／打包通过不改变它。
-
-旧 HTML／未采用 executionPolicy 的原生实例继续原摘要、输入、场景与基线，不自动迁移，新等级为 unverified。四主题、完整离线 HTML、业务共享索引和 moduleIds→appliesTo 不变；跨宿主可读共享原型，不继承 CodeBuddy 的调用证明。
-
-
-## 补调与恢复验收
-
-首次业务 UI 写入前，当前有效上下文须成功加载前端 Skill；新 buddy-ab-v2 还检查可调用的 antDv Skill 和专业模式 UIUX。阶段命令使用同一 A 谓词，缺 Skill 时反馈准确名称，已有加载但证据缺项时要求 execution-check 和真实引用，不要求重复加载全部 Skill。
-
-B 拒绝后主会话立即补调，等待成功返回，再重试被拒操作；普通 Read 或另开会话不算本主会话 Skill 调用。缺项、反馈事件、后续成功 toolCallId/resultDigest 及重试结果在宿主会话状态落盘。required → ready-to-retry → recovered 分别表示缺项、已可重试、观察到成功重试；recovered 不表示业务验收通过。A 再回查补调及重试的原生引用和时序。
+## 历史 execution-* 兼容
 
-PostToolUse 观察到已落盘的 begin／阶段失败时，通过该事件的 additionalContext 返回补调指令并保留 required；Stop 才使用停止反馈协议。IDE 尚未持久化当前结果时继续等待后续原生来源核验，不制造成功。实际 Skill 已成功但缺绑定时只提示 execution-begin；补调成功不直接记 recovered，仍须观察原操作的成功重试。
+已有 execution-policy、execution-context、execution-evidence 和原始审计报告保留，不自动改写。显式 `execution-begin`、`execution-template`、`execution-check` 及底层协议回放仍可用于历史资料检查，它们继续要求原合同的真实来源、身份与引用；没有来源时如实报告 unverified／failed。这些命令的历史审计失败不再接管正常原型构建或交付。
 
-重试按 kind 区分 ui-write 和 stage；阶段重试绑定实际 operation、stage 与同一原型目录。两类新记录都以 feedbackLine 核对请求发生在反馈之后，旧成功回调不能恢复后续拒绝；旧无 kind 的记录继续仅按页面写入合同核验。
+历史格式中的 runId、sessionId、projectKey、输入／候选摘要、toolCallId 与 resultDigest 只描述对应旧会话。旧 recovered 只表示当时观察到补调和重试；不是当前模型的 Skill 调用证明或业务认可。旧宿主适配导出的纯回放函数仅用于兼容测试；两个可执行回调入口均不再执行审计。
 
-同一会话／有效上下文／原型运行默认同一缺项提示两次、累计六次；重复回调、普通追问、反复 begin 和内部 providerData.isMeta 消息不重置计数。达到上限只停止重复催调，仍缺项则拒绝当前操作，取得真实成功结果后重新按事实放行。required／ready-to-retry／recovered／blocked 保留为兼容审计显示，不构成额外许可或永久锁。允许如实报告阻塞，不无限驱动 Stop。用户只读／暂停优先。入口、Skill 发现、加载成功、CLI 查询、重试成功、交付和用户认可分开记录。
+## 保持的边界
 
-每宿主／范围实测：故意漏调 → 写入被拒且文件未被该操作修改 → 本主会话实际 Skill 成功 → 原操作重试成功；失败调用、旧上下文、假 ID、旧会话及当前构建缺项不能放行。持续缺项须在预算耗尽后报告阻塞。源测试里的合成日志只能验证解析和门禁逻辑，不证明模型会补调。原生 Hooks 没有指定下一工具的执行接口，不能承诺必然调用，也不是任意 Shell 安全隔离。
+旧 HTML、四主题、业务共享索引和 moduleIds→appliesTo 保持；跨宿主读取原型不继承旧调用证明。固定预期不能事后改成与失败结果一致，真实业务意见保留人工判断空间。实际宿主调用、静态测试、安装检查与业务验收分别记录。
 
-antDv 加载与本地 CLI 查询分别留证：`prototype-deps query --host <host> --scope project --project <project> --kind info --component Table --version 1.5.2` 经解析的绝对 Node／入口执行，仅引用知识 1.5.2；目标 1.5.3 仍核对包类型／源码。probe 不是业务查询，退出零的错误内容仍失败，不自动安装。
+antDv 加载与本地 CLI 查询分别留证：`prototype-deps query --host <host> --scope project --project <project> --kind info --component Table --version 1.5.2` 使用解析的本地入口；知识版本与目标组件版本分别核对。probe 不是业务查询，退出零的错误内容仍失败，不自动安装依赖。

package/skills/i3-ui-prototype/scripts/codebuddy-registration.cjs

@@ -32,7 +32,7 @@ function plan(options) {
   const hosts=[...new Set(options.hosts || [...(record?.hosts || (record ? ['codebuddy'] : [])),...(options.agents?.filter(host=>['codebuddy','workbuddy'].includes(host)) || [options.host || 'codebuddy'])])].sort();
   assert.ok((hosts.length||action==='disable')&&hosts.every(host=>['codebuddy','workbuddy'].includes(host)), 'Unsupported prototype Hook host');
   for (const item of [base, project, nodePath, scriptPath]) assert.ok(typeof item === 'string' && path.isAbsolute(item) && !/[\x00\r\n]/.test(item), 'Absolute safe registration paths required');
-  if (process.platform === 'win32') throw new Error('CodeBuddy A+B Windows Hook quoting is not yet verified');
+  if (process.platform === 'win32' && action !== 'disable') throw new Error('CodeBuddy A+B Windows Hook quoting is not yet verified');
   const before = config(currentText), after = structuredClone(before), activeRecord = record && record.owner === OWNER ? record : null;
   if (record) {
     assert.ok(activeRecord && [1,2].includes(activeRecord.schemaVersion), 'Unknown registration ownership');

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

@@ -14,7 +14,7 @@ function policy(directory) {
 function binding(directory) {
  const metadata=inside(directory,'prototype.json');
  const automaticExpected=fs.existsSync(metadata)&&json(metadata).runtime?.executionPolicy===P.AUTO_ID;
- const recover=automaticExpected?'Installed Hooks collect this automatically on the next prototype UI operation. Load the required Skills and continue the UI task; report an infrastructure fault through maintenance if collection fails.':Recovery.instruction(['execution-begin'],{directory});
+ const recover=automaticExpected?'Prototype audit Hooks are retired. Normal prototype commands no longer require this historical audit binding.':Recovery.instruction(['execution-begin'],{directory});
  const pointer=optional(directory,'qa/execution-context.json');assert.ok(pointer?.schemaVersion===1,'No native Hook task binding; '+recover);
  const project=fs.realpathSync(pointer.project),selected=C.select({project,product:pointer.product,host:pointer.host||'codebuddy'});assert.ok(selected,'Hooks are not enabled or are shadowed');
  assert.equal(selected.base,pointer.base,'Effective Hook scope changed');
@@ -47,7 +47,10 @@ function check(directory,stage,lib,options={}) {
  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;
+ assert.ok(P.STAGES.includes(stage),'Unknown execution stage');
+ // Only the automatic callback audit is retired. Existing fixed inputs,
+ // framework/build checks and business/DevTools evidence are checked by their owners.
+ return {status:'not-required',stage,auditHook:'retired',invocationVerification:'unverified',tamperProof:false};
 }
 function template(directory,lib) {
  const fixed=policy(directory);assert.ok(fixed,'This existing prototype retains its original execution contract');

package/skills/i3-ui-prototype/scripts/hosts/codebuddy.cjs

@@ -15,6 +15,7 @@ function main(argv=process.argv.slice(2),raw=fs.readFileSync(0,'utf8')) {
  const result=require('../codebuddy-hook.cjs').handle(JSON.parse(raw),options);
  return format(result,options.event);
 }
-if(require.main===module)try{const result=main();process.stdout.write(JSON.stringify(result.output)+'\n');if(result.code===2)process.stderr.write(result.output.reason+'\n');process.exitCode=result.code;}
-catch(error){process.stderr.write(`i3 prototype audit unavailable: ${error.message}. Strict A gates remain unverified.\n`);process.exitCode=1;}
+// Historical replay helpers above remain available to explicit audit tooling.
+// The old executable callback is retired, including registrations before the wrapper.
+if(require.main===module)process.stdout.write('{}\n');
 module.exports={main,format};

package/skills/i3-ui-prototype/scripts/native-delivery.cjs

@@ -27,7 +27,7 @@ function state(directory,options,lib) {
     } catch(error) { browser={status:'failed',errors:[error.message]}; }
   }
   const devtoolsReview=require('./native-devtools.cjs').check(directory,lib);
-  const execution=require('./execution-runtime.cjs').check(directory,'delivery',lib);
+  const execution=require('./execution-runtime.cjs').requireStage(directory,'delivery',lib);
   const ownership=read(directory,'.prototype-write.lock');
   const savedDelivery=read(directory,'qa/delivery.json');
   const deliveryCurrent=savedDelivery?.schemaVersion===1&&savedDelivery.status==='complete'&&savedDelivery.id===meta.id&&savedDelivery.revision===current.revision&&savedDelivery.candidateDigest===current.digest&&savedDelivery.inputDigest===current.inputDigest&&savedDelivery.buildId===build.buildId&&savedDelivery.buildDigest===build.buildDigest&&savedDelivery.report===browser.report&&savedDelivery.review===review.status&&savedDelivery.humanConfirmationRequired===(review.status!=='approved')&&browser.status==='current'&&((!devtoolsReview.required&&savedDelivery.browserReportDigest===undefined)||savedDelivery.browserReportDigest===browser.reportDigest)&&(!devtoolsReview.required||(devtoolsReview.status==='current'&&savedDelivery.devtoolsReviewDigest===devtoolsReview.reportDigest));
@@ -64,7 +64,7 @@ function state(directory,options,lib) {
   if(generation)commands.replan=command('replan',['--scope',path.join(directory,'inputs/scope.json'),'--revision',nextRevision,...expected]);
   const fixedScope=json(inside(directory,'inputs/scope.json'));
   const scopes=meta.runtime.generationContract===1?{sourceFile:'inputs/scope.json',schemaVersion:fixedScope.schemaVersion,title:fixedScope.title,moduleIds:fixedScope.moduleIds,pages:fixedScope.pages.map(page=>({id:page.id,title:page.title,referencePage:page.referencePage,regions:page.regions.map(region=>({id:region.id,pattern:region.pattern||region.mode,fields:region.fields?.length||0,actions:region.actions?.length||0}))})),requirements:fixedScope.requirements.map(item=>({id:item.id,pages:item.pages,source:{type:item.source.type,reference:item.source.reference}}))}:fixedScope;
-  return {status:structure.status==='passed'?'ready':'failed',operation:'state',readOnly:true,directory,id:meta.id,revision:current.revision,candidateDigest:current.digest,inputDigest:current.inputDigest,identity:current.identity,instanceId:meta.instanceId,scopes,structure,...(generation?{generation}:{}),design,build,browser,devtoolsReview,execution,delivery,browserRuntime:runtime,ownership,verification:meta.verification,review,nextAction,commands,notes:['Design decisions and real provider queries remain the executing role responsibility.','Use the printed prototype commands; installed Hooks execute automatically.','A missing browser provider requires an existing Playwright module path; no automatic install or global changes.','Legacy execution commands remain available for compatibility; prototype work does not require manual binding or Hook diagnosis.']};
+  return {status:structure.status==='passed'?'ready':'failed',operation:'state',readOnly:true,directory,id:meta.id,revision:current.revision,candidateDigest:current.digest,inputDigest:current.inputDigest,identity:current.identity,instanceId:meta.instanceId,scopes,structure,...(generation?{generation}:{}),design,build,browser,devtoolsReview,execution,delivery,browserRuntime:runtime,ownership,verification:meta.verification,review,nextAction,commands,notes:['Design decisions and real provider queries remain the executing role responsibility.','Use the printed prototype commands; automatic prototype audit Hooks are retired and invocation remains unverified.','A missing browser provider requires an existing Playwright module path; no automatic install or global changes.','Legacy execution commands remain available for compatibility; prototype work does not require manual binding or Hook diagnosis.']};
 }
 
 function finalize(directory,options,lib) {

package/skills/i3-ui-prototype/scripts/prototype-hooks.cjs

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 'use strict';
 // Explicit configuration lifecycle. check is read-only and never invokes the installer.
-const fs=require('node:fs'),path=require('node:path'),os=require('node:os'),assert=require('node:assert/strict');
-const R=require('./codebuddy-registration.cjs'),C=require('./codebuddy-context.cjs'),E=require('./execution-evidence.cjs');
+const fs=require('node:fs'),path=require('node:path'),assert=require('node:assert/strict');
+const R=require('./codebuddy-registration.cjs'),C=require('./codebuddy-context.cjs');
 function context(options) {
  const host=options.host||'codebuddy';assert.ok(['codebuddy','workbuddy'].includes(host),'A+B supports CodeBuddy and WorkBuddy');
  const project=fs.realpathSync(path.resolve(options.project||'.')),scope=options.scope;
@@ -15,29 +15,24 @@ function context(options) {
  return {project,scope,base,record,scriptPath,host};
 }
 function prepare(options,runtime={}) {
- const current=runtime.current||context(options),readText=runtime.readText||R.fileIO.read,action=options.action||'keep';
- assert.ok(['keep','enable','disable'].includes(action),'Invalid Hook configuration action');
- if(['keep','disable'].includes(action)&&!current.record){
-  if(action==='disable'){const settings=R.config(readText(path.join(current.base,'settings.json')));assert.ok(!Object.values(settings.hooks||{}).flat().some(g=>g.hooks.some(h=>h.command?.includes(R.OWNER))),'Unknown owned-looking Hook has no ownership record; preserve it for review');}
-  return {summary:{status:'not-enabled',scope:current.scope,changed:false},unchanged:true};
+ const requested=options.action||'keep';
+ assert.ok(['keep','enable','disable'].includes(requested),'Invalid Hook configuration action');
+ assert.notEqual(requested,'enable','Prototype audit Hooks are retired and cannot be enabled');
+ const current=runtime.current||context(options),readText=runtime.readText||R.fileIO.read;
+ const settingsText=readText(path.join(current.base,'settings.json'));
+ if(!current.record) {
+  const settings=R.config(settingsText);
+  assert.ok(!Object.values(settings.hooks||{}).flat().some(g=>g.hooks.some(h=>h.command?.includes(R.OWNER))),'Unknown owned-looking Hook has no ownership record; preserve it for review');
+  return {summary:{status:'retired',scope:current.scope,changed:false},unchanged:true};
  }
- assert.ok(options.product===undefined||['auto','ide','cli'].includes(options.product),'Invalid Buddy product profile');
- const product='auto'; // Legacy product arguments are hints, never a second new registration.
- const explicit=options.transcriptRoot,roots=explicit==='auto'?[]:explicit?[path.resolve(explicit)]:current.record?.transcriptRoots||[];
- const mode=explicit?(explicit==='auto'?'auto':'manual'):current.record?.transcriptMode||(roots.length?'manual':'auto');
- if(action!=='disable') {
-  for(const root of roots){const relative=path.relative(current.project,root);assert.ok(relative==='..'||relative.startsWith('..'+path.sep)||path.isAbsolute(relative),'Native log root must be outside the business project; QA exports are not native provenance');}
- }
- const settingsText=readText(path.join(current.base,'settings.json')),settings=R.config(settingsText);
- if(action!=='disable')assert.ok(!settings.disableAllHooks&&!settings.allowManagedHooksOnly,'Host policy prevents automatic auditing; preserve the existing policy');
- return R.plan({action,...current,product,hosts:options.hosts,agents:options.agents,nodePath:process.execPath,scriptDigest:runtime.scriptDigest||C.bundle(options.entrySource||(path.basename(current.scriptPath)==='i3-prototype.cjs'?current.scriptPath:path.join(__dirname,'hosts/codebuddy.cjs'))),currentText:settingsText,
-  transcriptMode:mode,transcriptRoots:roots,productVersion:options.productVersion||current.record?.productVersion||'unreported'});
+ return R.plan({action:'disable',...current,product:'auto',hosts:[],nodePath:process.execPath,scriptDigest:current.record.scriptDigest,currentText:settingsText});
 }
 function configure(options) {
  const change=prepare(options);if(change.unchanged||options.preview)return change.summary;
  return R.apply(change);
 }
-function check(options,runtime={}) {
+// Explicit historical replay only; normal management must never inspect transcripts.
+function legacyCheck(options,runtime={}) {
  const current=runtime.current||context(options),profile=require('../assets/hosts/codebuddy/profile.json');
  const result={scope:current.scope,base:current.base,scriptPath:current.scriptPath,filesPresent:fs.existsSync(current.scriptPath),profile:profile.id,nativeValidation:profile.nativeValidation,readOnly:true,sideEffects:[]};
  if(process.platform==='win32')return {...result,status:'unsupported',reason:'CodeBuddy Hook quoting on Windows has not been validated'};
@@ -80,6 +75,14 @@ function check(options,runtime={}) {
    next:'CLI: review /hooks; desktop: reload. Verify an actual Skill invocation and missing-Skill recovery in the chosen host.'};
  }catch(error){if(result.transcript)Object.assign(result.transcript,{status:'unverified',invocationVerified:false});return {...result,status:'failed',errors:[error.message]};}
 }
+function check(options,runtime={}) {
+ const current=runtime.current||context(options),readText=runtime.readText||R.fileIO.read;
+ const result={status:'retired',scope:current.scope,base:current.base,readOnly:true,sideEffects:[],invocationVerified:false,registered:!!current.record};
+ try {
+  prepare({...options,action:'disable'},{current,readText});
+  return {...result,cleanupRequired:!!current.record,next:current.record?'Upgrade or explicitly disable to remove the exact owned registration.':'No prototype audit Hooks are enabled.'};
+ }catch(error){return {...result,status:'failed',errors:[error.message]};}
+}
 function main(argv=process.argv.slice(2)) {
  const central=[path.resolve(__dirname,'../../../i3-composer-agent/hooks/manage.cjs'),path.resolve(__dirname,'../../../hooks/manage.cjs')].find(file=>fs.existsSync(file));
  if(central)return require(central).main([...argv,'--groups','prototype']);
@@ -87,5 +90,5 @@ function main(argv=process.argv.slice(2)) {
  while(argv.length){const arg=argv.shift();assert.ok(arg.startsWith('--')&&argv[0]&&!argv[0].startsWith('--'),'Hook option needs a value');const key=arg.slice(2).replace(/-([a-z])/g,(_,c)=>c.toUpperCase());assert.ok(['host','scope','project','product','productVersion','transcriptRoot'].includes(key),'Unknown Hook option');options[key]=argv.shift();}
  return options.action==='check'?check(options):configure(options);
 }
-module.exports={context,globalBase:C.globalBase,prepare,configure,check,main};
+module.exports={context,globalBase:C.globalBase,prepare,configure,check,legacyCheck,main};
 if(require.main===module)try{const result=main();process.stdout.write(JSON.stringify(result,null,2)+'\n');if(result.status==='failed')process.exitCode=1;}catch(error){process.stderr.write(error.message+'\n');process.exitCode=1;}