@givolt/i3-composer-agent 3.2.1 → 4.0.0

package/skills/i3-ui-prototype/scripts/project-registry.cjs

@@ -1,126 +0,0 @@
-'use strict';
-const { fs, path, crypto, hash, assert, json, id, inside, write } = require('./native-files.cjs');
-function paths(project, prototypeId) {
-  const root = fs.realpathSync(path.resolve(project || '.'));
-  assert.ok(fs.statSync(root).isDirectory(), 'Project must be a directory');
-  if (prototypeId !== undefined) id(prototypeId);
-  return { project: root, output: inside(root, 'prototypes'), index: inside(root, 'prototypes/index.json'),
-    legacyIndex: inside(root, '.i3-ui-prototypes.json'), lock: inside(root, 'prototypes/.index.lock'), legacyLock: inside(root, '.i3-ui-prototypes.lock'),
-    ...(prototypeId === undefined ? {} : { directory: inside(root, `prototypes/${prototypeId}`), preparation: inside(root, `prototypes/.preparation/${prototypeId}`), scopeFile: inside(root, `prototypes/.preparation/${prototypeId}/scope.json`) }) };
-}
-function moduleIds(scope = {}) {
-  if (scope.schemaVersion !== undefined) assert.ok([1, 2, 3].includes(scope.schemaVersion), 'Unsupported scope schemaVersion');
-  if (scope.moduleIds === undefined && ![2, 3].includes(scope.schemaVersion)) return [];
-  assert.ok(Array.isArray(scope.moduleIds), 'scope.moduleIds must be an array; use [] for unbound scope');
-  for (const value of scope.moduleIds) assert.ok(typeof value === 'string' && value.length <= 128 && /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/.test(value), 'Invalid module identifier in scope.moduleIds; use stable PRD module IDs, not paths or requirement text');
-  return [...new Set(scope.moduleIds)];
-}
-function validate(registry, project) {
-  assert.equal(registry.schemaVersion, 1, 'Invalid project prototype registry version');
-  assert.ok(Array.isArray(registry.prototypes), 'Invalid project prototype registry');
-  const ids = new Set();
-  for (const entry of registry.prototypes) {
-    id(entry.id); assert.ok(!ids.has(entry.id), 'Duplicate prototype ID in registry'); ids.add(entry.id);
-    inside(project, entry.directory);
-    assert.ok(entry.appliesTo === undefined || (Array.isArray(entry.appliesTo) && entry.appliesTo.every(value => typeof value === 'string')), 'Invalid appliesTo array');
-  }
-  return registry;
-}
-function read(project) {
-  const locations = paths(project), modern = fs.existsSync(locations.index), legacy = fs.existsSync(locations.legacyIndex);
-  if (modern && legacy) assert.deepEqual(json(locations.index), json(locations.legacyIndex), 'Conflicting prototype indices; resolve or explicitly migrate before writing');
-  const file = modern || !legacy ? locations.index : locations.legacyIndex;
-  const bytes = fs.existsSync(file) ? fs.readFileSync(file) : null;
-  return { ...locations, file, legacy: !modern && legacy, duplicateLegacy: modern && legacy,
-    bytes, registry: validate(bytes ? JSON.parse(bytes.toString('utf8')) : { schemaVersion: 1, prototypes: [] }, locations.project) };
-}
-function transaction(project, operation, { allowDuplicate = false } = {}) {
-  const initial = read(project);
-  assert.ok(allowDuplicate || !initial.duplicateLegacy, 'Duplicate active indices; explicitly resolve before writing');
-  assert.ok(!fs.existsSync(initial.legacyLock), 'Legacy prototype writer lock is active');
-  const createdOutput = !fs.existsSync(initial.output), locks = [];
-  fs.mkdirSync(initial.output, { recursive: true });
-  const acquire = file => { const fd = fs.openSync(file, 'wx'); locks.push({ file, fd }); };
-  try {
-    acquire(initial.lock);
-    if (initial.legacy || initial.duplicateLegacy) acquire(initial.legacyLock);
-    else assert.ok(!fs.existsSync(initial.legacyLock), 'Legacy prototype writer lock is active');
-    const current = read(project);
-    assert.equal(current.file, initial.file, 'Prototype index location changed while acquiring lock');
-    assert.ok(allowDuplicate || !current.duplicateLegacy, 'Duplicate active indices');
-    return operation({ ...current, save() {
-      const latest = read(project);
-      assert.equal(latest.file, current.file, 'Prototype index location changed');
-      assert.deepEqual(latest.bytes, current.bytes, 'Prototype index changed outside the active writer');
-      validate(current.registry, current.project);
-      write(current.project, path.relative(current.project, current.file).split(path.sep).join('/'), current.registry);
-    } });
-  } finally {
-    for (const { file, fd } of locks.reverse()) { fs.closeSync(fd); fs.unlinkSync(file); }
-    if (createdOutput && fs.existsSync(initial.output) && !fs.readdirSync(initial.output).length) fs.rmdirSync(initial.output);
-  }
-}
-function query(options = {}) {
-  const current = read(options.project), prototypes = current.registry.prototypes;
-  if (options.module !== undefined) assert.ok(typeof options.module === 'string' && options.module.trim(), 'Provide a nonempty module identifier or existing legacy label');
-  const errors = [], invalid = new Set();
-  for (const entry of prototypes) {
-    try {
-      const scopeFile = inside(current.project, `${entry.directory}/inputs/scope.json`);
-      if (fs.existsSync(scopeFile)) {
-        const scope = json(scopeFile);
-        if (scope.schemaVersion === 2 || scope.moduleIds !== undefined) assert.deepEqual(entry.appliesTo || [], moduleIds(scope), 'appliesTo differs from fixed scope.moduleIds; explicitly revise or synchronize the index');
-      }
-    } catch (error) { invalid.add(entry.id); errors.push(`${entry.id}: ${error.message}`); }
-  }
-  const matches = options.module === undefined ? [] : prototypes.filter(entry => !invalid.has(entry.id) && entry.appliesTo?.includes(options.module));
-  return { status: errors.length ? 'failed' : 'checked', index: current.file, legacy: current.legacy, prototypes, errors,
-    matches, unbound: prototypes.filter(entry => !invalid.has(entry.id) && !entry.appliesTo?.length), selection: matches.length > 1 ? 'ambiguous' : matches.length ? 'matched' : 'none', readOnly: true,
-    note: 'Module association does not prove implementation, current verification or human approval.' };
-}
-function withInstanceAssociation(directory, scope, operation) {
-  const parent = path.dirname(path.resolve(directory));
-  if (path.basename(parent) !== 'prototypes' || (scope.schemaVersion !== 2 && scope.moduleIds === undefined)) return operation();
-  const project = path.dirname(parent), current = read(project);
-  if (!current.registry.prototypes.some(entry => path.resolve(project, entry.directory) === path.resolve(directory))) return operation();
-  const appliesTo = moduleIds(scope), metadataFile = inside(directory, 'prototype.json'), before = fs.readFileSync(metadataFile);
-  return transaction(project, store => {
-    const entry = store.registry.prototypes.find(item => path.resolve(project, item.directory) === path.resolve(directory));
-    assert.ok(entry, 'Prototype entry disappeared during revision');
-    try { const result = operation(); entry.appliesTo = appliesTo; store.save(); return result; }
-    catch (error) { write(directory, 'prototype.json', before.toString('utf8')); throw error; }
-  });
-}
-function migrate(options = {}) {
-  assert.ok(options.check === undefined || typeof options.check === 'boolean', '--check must be a boolean flag');
-  const initial = read(options.project);
-  if (!fs.existsSync(initial.legacyIndex)) return { status: 'current', index: initial.index, sideEffects: [] };
-  const original = fs.readFileSync(initial.legacyIndex), digest = hash(original);
-  if (options.expectedDigest !== undefined) assert.equal(options.expectedDigest, digest, 'Legacy index changed since preview');
-  const plan = { source: initial.legacyIndex, destination: initial.index, sourceDigest: digest, prototypes: initial.registry.prototypes.length };
-  if (options.check) return { status: 'migration-preview', ...plan, sideEffects: [] };
-  return transaction(options.project, store => {
-    assert.deepEqual(fs.readFileSync(store.legacyIndex), original, 'Legacy index changed during migration');
-    const folder = inside(store.project, `prototypes/.migration/index-${crypto.randomUUID()}`);
-    fs.mkdirSync(folder, { recursive: true });
-    const backup = inside(folder, 'legacy-index.json'), temp = inside(store.project, `prototypes/.index-${crypto.randomUUID()}.tmp`);
-    fs.writeFileSync(backup, original, { flag: 'wx' });
-    write(folder, 'source.json', { ...plan, backup, purpose: 'Source snapshot before explicit index migration' });
-    let created = false;
-    try {
-      if (!fs.existsSync(store.index)) {
-        fs.writeFileSync(temp, original, { flag: 'wx' });
-        try { fs.linkSync(temp, store.index); created = true; }
-        finally { if (fs.existsSync(temp)) fs.unlinkSync(temp); }
-      } else assert.deepEqual(fs.readFileSync(store.index), original, 'Destination index already exists with different content');
-      assert.deepEqual(fs.readFileSync(backup), original, 'Migration backup mismatch');
-      assert.deepEqual(fs.readFileSync(store.legacyIndex), original, 'Legacy index changed before commit');
-      fs.unlinkSync(store.legacyIndex);
-      return { status: 'migrated', ...plan, backup };
-    } catch (error) {
-      if (created && fs.existsSync(store.index) && fs.readFileSync(store.index).equals(original)) fs.unlinkSync(store.index);
-      throw error;
-    }
-  }, { allowDuplicate: true });
-}
-module.exports = { paths, moduleIds, read, transaction, query, withInstanceAssociation, migrate };

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

@@ -1,103 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-const fs = require('node:fs');
-const path = require('node:path');
-const { spawnSync } = require('node:child_process');
-const { checkDesignProvider } = require('./prototype-lib.cjs');
-const { discoverProviderCandidates } = require('./design-provider-discovery.cjs');
-const { resolveLocations, scopeBases, toolCandidates } = require('./prototype-locations.cjs');
-
-function skillAt(project, name, options = {}) {
-  const context = resolveLocations({ ...options, project });
-  const candidates = scopeBases(context).map(([root, scope]) => [path.join(root, 'skills', name), `${scope}-skill`]);
-  const legacyConfig = (options.env || process.env).CODEBUDDY_CONFIG_DIR;
-  if (context.host === 'codebuddy' && legacyConfig) candidates.push([path.resolve(legacyConfig, 'skills', name), 'global-skill']);
-  const found = candidates.find(([root]) => fs.existsSync(path.join(root, 'SKILL.md')));
-  return found ? { availability: 'available', root: found[0], source: found[1], invocationVerified: false }
-    : { availability: 'missing', searched: candidates.map(([root]) => root), invocationVerified: false };
-}
-function antdvTool(project, options = {}) {
-  const candidates = toolCandidates(resolveLocations({ ...options, project }), options);
-  const found = candidates.find(item => fs.existsSync(item.root));
-  if (!found) return { availability: 'missing', searched: candidates.map(item => item.root), componentVersion: '1.5.3' };
-  const { root, source } = found;
-  try {
-    const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
-    if (pkg.name !== '@antdv-next/cli' || typeof pkg.bin?.antdv !== 'string') throw new Error('Unexpected antDv CLI package');
-    const entry = path.resolve(root, pkg.bin.antdv), relative = path.relative(root, entry);
-    if (relative.startsWith('..') || path.isAbsolute(relative)) throw new Error('CLI entry escapes its package');
-    const args = [entry, 'info', 'Table', '--ver', '1.5.2', '--format', 'json'];
-    const result = spawnSync(process.execPath, args, { cwd: project, env: { ...(options.env || process.env), ANTDV_NO_AUTO_REPORT: '1' }, encoding: 'utf8', timeout: 15000, maxBuffer: 5 * 1024 * 1024 });
-    if (result.status !== 0) throw new Error(result.error?.message || result.stderr || 'CLI query failed');
-    const data = JSON.parse(result.stdout);
-    if (!data || data.name !== 'Table' || !Array.isArray(data.props) || data.error) throw new Error('CLI returned no Table knowledge');
-    return { availability: 'available', root, source, entry, nodePath:process.execPath, version: pkg.version, command: [process.execPath, ...args], invocationVerified:false, knowledgeProbe:'Table-only', knowledgeVersion: '1.5.2', componentVersion: '1.5.3', exactKnowledgeMatch: false,
-      limitation: 'CLI knowledge 1.5.2 is reference only; verify target 1.5.3 package types/source.' };
-  } catch (error) { return { availability: 'unusable', root, source, reason: error.message }; }
-}
-function query(options={}) {
-  const kinds=['info','demo','token','semantic','doc','list','design.md'];
-  assertQuery(kinds.includes(options.kind),'Choose a read-only antDv query: '+kinds.join(', '));
-  const locations=resolveLocations(options),tool=antdvTool(locations.project,{...options,host:locations.host,scope:locations.scope});
-  assertQuery(tool.availability==='available',`Local antDv CLI ${tool.availability}: ${tool.reason||'use prototype-deps check; installation requires separate authorization'}`);
-  const component=options.component,version=options.version||tool.knowledgeVersion;
-  assertQuery(/^\d+\.\d+\.\d+(?:-[A-Za-z0-9.-]+)?$/.test(version),'Explicit safe knowledge version required');
-  const args=[tool.entry,options.kind];
-  if(!['list','design.md'].includes(options.kind)){
-    assertQuery(typeof component==='string'&&/^[A-Za-z][A-Za-z0-9-]{0,99}$/.test(component),'Component name required');args.push(component);
-  }
-  if(options.demo!==undefined){assertQuery(options.kind==='demo'&&/^[A-Za-z0-9_-]{1,100}$/.test(options.demo),'Safe demo name required');args.push(options.demo);}
-  args.push('--ver',version,'--format','json');
-  const result=spawnSync(tool.nodePath,args,{cwd:locations.project,env:{...(options.env||process.env),ANTDV_NO_AUTO_REPORT:'1'},encoding:'utf8',timeout:15000,maxBuffer:5*1024*1024});
-  let data=null;try{data=JSON.parse(result.stdout);}catch{/* Some official doc/demo commands return text. */}
-  const stdout=result.stdout||'',stderr=result.stderr||'';
-  const invalid=result.status!==0||!stdout.trim()||/^\s*(?:Error\b|错误[:：])/i.test(stdout)||data?.error||data?.success===false||data?.status==='failed'||options.kind==='info'&&(!data||data.name!==component||!Array.isArray(data.props));
-  return {status:invalid?'failed':'queried',host:locations.host,scope:locations.scope,command:[tool.nodePath,...args],source:tool.source,cliVersion:tool.version,knowledgeVersion:version,componentVersion:tool.componentVersion,exactKnowledgeMatch:version===tool.componentVersion,
-    component:component||null,kind:options.kind,exitCode:result.status,stdout,stderr,...(data?{data}:{}),...(result.error?{error:result.error.message}:{}),skillInvocationVerified:false,
-    note:'This is a CLI query only. Load the official Skill through the host before business queries; native Hooks must correlate the actual request/result. Verify target package types/source when knowledge versions differ.'};
-}
-function assertQuery(condition,message){if(!condition)throw new Error(message);}
-function check(options = {}) {
-  const locations = resolveLocations(options), { project, host, scope } = locations;
-  const roots = scopeBases(locations).map(([base]) => path.join(base, 'skills/ui-ux-pro-max'));
-  const sources = new Map(scopeBases(locations).map(([base, scope]) => [path.join(base, 'skills/ui-ux-pro-max'), `${scope}-skill`]));
-  let discovery;
-  if (options.provider === undefined) {
-    const aliases = { 'gemini-cli': 'gemini', 'claude-code': 'claude' };
-    // Resolve global registrations from home so project-scoped plugins from the
-    // business workspace are never reused by a global installation.
-    discovery = discoverProviderCandidates({ ...options, project: scope === 'global' ? locations.home : project, host: aliases[host] || host });
-    for (const item of discovery.candidates) { roots.push(item.root); if (!sources.has(item.root)) sources.set(item.root, item.source); }
-  }
-  const uiux = checkDesignProvider({ ...options, project, host, ...(options.provider === undefined ? { providerRoots: [...new Set(roots)] } : {}) });
-  if (discovery) {
-    uiux.diagnostics.push(...discovery.diagnostics);
-    if (uiux.root) uiux.source = sources.get(uiux.root) || uiux.source;
-    for (const attempt of uiux.attempts) attempt.source = sources.get(attempt.root) || attempt.source;
-    const failure = ['ambiguous', 'disabled', 'discovery-error'].map(status => discovery.diagnostics.find(item => item.availability === status)).find(Boolean);
-    if (uiux.availability === 'missing' && failure) Object.assign(uiux, { availability: failure.availability, reason: failure.reason });
-  }
-  const scoped = { ...options, host, scope };
-  const antdv = { skill: skillAt(project, 'antdv', scoped), tool: antdvTool(project, scoped) };
-  return { status: 'checked', host, scope, project, locations, uiux, antdv, optional: true, professionalReady: uiux.availability === 'available',
-    invocationVerified: false, note: 'Read-only availability probe; the selected host must discover and actually invoke Skills. No dependency installation, migration or prototype changes.' };
-}
-function parse(argv) {
-  const operation = argv.shift() || 'check', options = {};
-  if (!['check', 'install','query'].includes(operation)) throw new Error('Use check or install or query');
-  const flags = new Set(['project', 'host', 'scope', 'skills', 'provider', 'python', 'tool',...(operation==='query'?['kind','component','version','demo']:[])]);
-  while (argv.length) {
-    const key = argv.shift();
-    if (key === '--migrate-tools' && operation === 'install') { options.migrateTools = true; continue; }
-    if (!key.startsWith('--') || !flags.has(key.slice(2)) || !argv[0] || argv[0].startsWith('--')) throw new Error(`Invalid option: ${key}`);
-    options[key.slice(2)] = argv.shift();
-  }
-  return { operation, options };
-}
-async function main(argv = process.argv.slice(2)) {
-  const { operation, options } = parse([...argv]);
-  return operation === 'check' ? check(options) : operation==='query'?query(options):require('./optional-skill-install.cjs').install(options);
-}
-module.exports = { check, skillAt, antdvTool, query, parse, main };
-if (require.main === module) main().then(result => {const {options}=parse(process.argv.slice(2));require('./ptc-callbacks.cjs').captureResult({script:__filename,argv:process.argv.slice(2),project:path.resolve(options.project||process.cwd()),result,exitCode:result.status==='failed'?1:0});process.stdout.write(JSON.stringify(result, null, 2) + '\n');if(result.status==='failed')process.exitCode=1;})
-  .catch(error => { process.stderr.write(JSON.stringify({ status: 'failed', errors: [error.message] }) + '\n'); process.exitCode = 1; });

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

@@ -1,94 +0,0 @@
-#!/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'),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;
- assert.ok(['project','global'].includes(scope),'Specify project or global installation scope');
- const base=scope==='project'?path.join(project,'.codebuddy'):C.globalBase(options);
- const recordText=R.fileIO.read(path.join(base,'state/i3-prototype/installation.json'));
- const record=recordText?JSON.parse(recordText):null;
- const unified=path.join(base,'i3-composer-agent/hooks/i3-prototype.cjs');
- const scriptPath=options.entryPath||(fs.existsSync(unified)?unified:path.join(base,'skills/i3-ui-prototype/scripts/hosts/codebuddy.cjs'));
- return {project,scope,base,record,scriptPath,host};
-}
-function prepare(options,runtime={}) {
- 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};
- }
- 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);
-}
-// 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'};
- if(!current.record){
-  const settings=R.config(R.fileIO.read(path.join(current.base,'settings.json')));
-  if(Object.values(settings.hooks||{}).flat().some(group=>group.hooks.some(h=>h.command?.includes(R.OWNER))))return {...result,status:'failed',errors:['Unknown prototype Hook registration has no ownership record; preserve it for review']};
-  return {...result,status:result.filesPresent?'files-present':'not-enabled'};
- }
- try {
-  const record=(runtime.registration||C.registration)(current.base),host=options.host||'codebuddy',products=record.product==='auto'?(host==='workbuddy'?['ide']:['ide','cli']):[record.product];
-  const effectiveByProduct=Object.fromEntries(products.map(product=>[product,(runtime.select||C.select)({project:current.project,product,host,home:options.home,env:options.env})?.base===current.base]));
-  Object.assign(result,{host,product:record.product,productVersion:record.productVersion,registrationDigest:record.registrationDigest,effective:Object.values(effectiveByProduct).every(Boolean),effectiveByProduct,transcriptRoots:record.transcriptRoots,
-   transcript:{mode:record.transcriptMode||(record.transcriptRoots?.length?'manual':'auto'),status:'awaiting-native-event',invocationVerified:false}});
-  let observation=null;
-  const parent=path.join(current.base,'state/i3-prototype',C.projectKey(current.project));
-  const entries=runtime.entries||[];
-  if(!runtime.entries&&fs.existsSync(parent))for(const name of fs.readdirSync(parent)) {
-   if(!/^[a-f0-9]{24}$/.test(name))continue;
-   const raw=R.fileIO.read(path.join(parent,name,'session.json'));
-   if(raw)entries.push(...Object.values(JSON.parse(raw).bindings||{}));
-   const observed=R.fileIO.read(path.join(parent,name,'observation.json'));if(observed)entries.push(JSON.parse(observed));
-  }
-  for(const entry of entries)if((entry.host||'codebuddy')===host&&entry.project===current.project&&entry.registrationDigest===record.registrationDigest&&entry.settingsDigest===record.settingsDigest&&(!observation||entry.lastHook.at>observation.lastHook.at))observation=entry;
-  if(observation) {
-   result.transcript.path=observation.source.path;
-   C.prefix(observation.source.path,observation.source.bytes,observation.source.digest);
-   C.source({session_id:observation.sessionId,transcript_path:observation.source.path},record,current.project);
-   Object.assign(result.transcript,{status:'verified',invocationVerified:true});
-   result.observation={sessionId:observation.sessionId,projectKey:observation.projectKey,runId:observation.runId,event:observation.lastHook.event,at:observation.lastHook.at};
-   const observedProduct=observation.product||(record.product!=='auto'?record.product:null);
-   assert.ok(['ide','cli'].includes(observedProduct),'Observed native product identity missing');
-   Object.assign(result,{product:observedProduct,productVersion:observation.productVersion||'unreported',effective:effectiveByProduct[observedProduct]===true,identitySource:observation.identitySource||'legacy-profile',recovery:observation.recovery||null,...(observation.callMode?{callMode:observation.callMode,skills:observation.skills}:{})});
-  }
-  const recent=observation&&Date.now()-Date.parse(observation.lastHook.at)>=0&&Date.now()-Date.parse(observation.lastHook.at)<30*60*1000;
-  const failure=require('./execution-diagnostics.cjs').latest({base:current.base,project:current.project,host,record});
-  if(failure&&(!observation||failure.at>=observation.lastHook.at))return {...result,status:'failed',failure,errors:[failure.reason],transcript:{...result.transcript,status:'failed',invocationVerified:false},
-   next:failure.status==='blocked'?'修复宿主或适配后，由用户发起新的继续任务；只读诊断不消耗恢复次数。':'按 failure.reason 检查当前宿主协议；最多两次补调，不能将注册状态当作执行成功。'};
-  return {...result,status:result.effective&&recent?'active':record.product==='cli'?'pending-host-review':'registered',
-   activationScope:'Only the displayed project/session/configuration and adapter bytes; not all projects or business acceptance',
-   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']);
- const options={action:argv.shift()||'check',host:'codebuddy',project:process.cwd()};
- 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,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;}

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

@@ -1,277 +0,0 @@
-'use strict';
-const fs = require('node:fs');
-const path = require('node:path');
-const crypto = require('node:crypto');
-const { spawnSync } = require('node:child_process');
-const templateRegistry = require('./template-adapters.cjs').createTemplateRegistry();
-const { discoverProviderCandidates } = require('./design-provider-discovery.cjs');
-const projectRegistry = require('./project-registry.cjs');
-const hash = value => crypto.createHash('sha256').update(value).digest('hex');
-const json = file => JSON.parse(fs.readFileSync(file, 'utf8'));
-function ensure(condition, message) { if (!condition) throw new Error(message); }
-function identifier(value) { ensure(typeof value === 'string' && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(value), 'Invalid identifier / 无效标识'); return value; }
-function contained(root, relative) {
-  ensure(typeof relative === 'string' && relative && !path.isAbsolute(relative) && !relative.split(/[\\/]/).some(p => p === '..'), 'Path must remain inside prototype');
-  root = fs.existsSync(root) ? fs.realpathSync(root) : path.resolve(root);
-  const file = path.resolve(root, relative);
-  ensure(file.startsWith(root + path.sep), 'Path escapes prototype');
-  let current = root;
-  for (const part of path.relative(root, file).split(path.sep)) {
-    current = path.join(current, part);
-    ensure(!fs.existsSync(current) || !fs.lstatSync(current).isSymbolicLink(), 'Refusing symlink / 符号链接');
-  }
-  return file;
-}
-function files(root, prefix = '') {
-  return fs.readdirSync(path.join(root, prefix), { withFileTypes: true }).flatMap(entry => {
-    const relative = prefix ? `${prefix}/${entry.name}` : entry.name;
-    ensure(!entry.isSymbolicLink(), `Refusing symlink: ${relative}`);
-    return entry.isDirectory() ? files(root, relative) : entry.isFile() ? [relative] : [];
-  }).sort();
-}
-function write(root, relative, value) {
-  const file = contained(root, relative);
-  fs.mkdirSync(path.dirname(file), { recursive: true });
-  fs.writeFileSync(file, typeof value === 'string' ? value : JSON.stringify(value, null, 2) + '\n');
-}
-function atomicJson(root, relative, value) {
-  const file = contained(root, relative);
-  const temp = `${file}.${crypto.randomUUID()}.tmp`;
-  try { fs.writeFileSync(temp, JSON.stringify(value, null, 2) + '\n', { flag: 'wx' }); fs.renameSync(temp, file); }
-  finally { if (fs.existsSync(temp)) fs.unlinkSync(temp); }
-}
-function listTemplates(options = {}, registry = templateRegistry) {
-  return registry.list(options);
-}
-function tokensCss(tokens) {
-  const entries = Object.entries({ ...tokens.semantic, ...tokens.component });
-  ensure(entries.length && entries.every(([key, value]) => /^[a-z][a-z0-9-]*$/.test(key) && typeof value === 'string' && !/[;{}<>\n\r]/.test(value)), 'Invalid design token values');
-  return ':root {\n' + entries.map(([key, value]) => `  --${key}: ${value};`).join('\n') + '\n}\n';
-}
-function providerVersion(root) {
-  const receipt = path.join(root, 'UPSTREAM-ORIGIN.json');
-  if (fs.existsSync(receipt)) {
-    try { const source = json(receipt); if (source.packageName === 'ui-ux-pro-max-cli' && typeof source.version === 'string') return source.version; } catch {}
-  }
-  for (let folder = root, i = 0; i < 5; i++, folder = path.dirname(folder)) {
-    for (const name of ['skill.json', '.claude-plugin/plugin.json', '.codebuddy-plugin/plugin.json', 'package.json']) {
-      const file = path.join(folder, name);
-      if (fs.existsSync(file)) {
-        try {
-          const metadata = json(file);
-          if (name === 'package.json' && !['ui-ux-pro-max', 'ui-ux-pro-max-cli'].includes(metadata.name)) continue;
-          if (metadata.version) return metadata.version;
-        } catch {}
-      }
-    }
-  }
-  return 'unversioned';
-}
-function queryProvider(root, query, options = {}) {
-  const mode = options.stack ? ['--stack', options.stack] : options.designSystem ? ['--design-system'] : ['--domain', options.domain || 'ux'];
-  const run = spawnSync(options.python || (process.platform === 'win32' ? 'python' : 'python3'), ['-B', path.join(root, 'scripts/search.py'), query, ...mode, '--json'], { encoding: 'utf8', timeout: 15000, maxBuffer: 5 * 1024 * 1024 });
-  ensure(run.status === 0, `UI/UX Pro Max query unavailable: ${run.error?.code || (run.stderr || '').trim().slice(0, 400)}`);
-  return JSON.parse(run.stdout);
-}
-function checkDesignProvider(options = {}) {
-  const discovery = discoverProviderCandidates(options);
-  const attempts = [];
-  const roots = discovery.candidates.map(candidate => path.resolve(candidate.root));
-  const diagnostics = discovery.diagnostics;
-  if (discovery.contextRequired) return { availability: 'needs-context', searched: roots, attempts, diagnostics, reason: '请指定当前宿主 --host，或传入宿主实际提供的 --provider 技能路径；尚不能判断是否已安装' };
-  for (const candidate of discovery.candidates) {
-    const root = path.resolve(candidate.root);
-    if (!fs.existsSync(root)) { attempts.push({ root, source: candidate.source, availability: 'missing', reason: '技能路径不存在' }); continue; }
-    const required = ['SKILL.md', 'scripts/search.py', 'scripts/core.py', 'scripts/design_system.py', ...['ux-guidelines', 'styles', 'colors', 'typography', 'products', 'landing', 'ui-reasoning'].map(name => `data/${name}.csv`)];
-    const missing = required.filter(file => !fs.existsSync(path.join(root, file)));
-    if (missing.length) { attempts.push({ root, source: candidate.source, availability: 'unusable', missing, reason: '技能资源不完整' }); continue; }
-    try {
-      const probe = queryProvider(root, 'error summary validation', { python: options.python, domain: 'ux' });
-      ensure(probe.domain === 'ux' && probe.results?.length, 'No verified UX probe result');
-      attempts.push({ root, source: candidate.source, availability: 'available' });
-      return { availability: 'available', root, source: candidate.source, version: providerVersion(root), digest: hash(required.map(file => hash(fs.readFileSync(path.join(root, file)))).join('\n')), searched: roots, attempts, diagnostics };
-    } catch (error) { attempts.push({ root, source: candidate.source, availability: 'unusable', reason: error.message }); }
-  }
-  const failure = attempts.find(attempt => attempt.availability === 'unusable') || ['ambiguous', 'disabled', 'discovery-error'].map(status => diagnostics.find(item => item.availability === status)).find(Boolean);
-  return { ...(failure || {}), availability: failure?.availability || 'missing', searched: roots, attempts, diagnostics, reason: failure?.reason || (options.provider ? '指定的 UI/UX Pro Max 技能路径不存在，请核对 --provider' : '当前宿主未发现 UI/UX Pro Max；可安装，或传入宿主实际提供的 --provider 技能路径') };
-}
-function initPrototype(options, registry = templateRegistry) {
-  if (options.framework === 'vue-antdv-next' || options.template === 'admin-list') return require('./native-pilot-lib.cjs').createPrototype(options);
-  const project = path.resolve(options.project || '.');
-  const id = identifier(options.id);
-  const selected = registry.resolve(options.template || registry.defaultId());
-  const template = selected.entry;
-  const expertMode = options.expertMode || 'professional';
-  ensure(['professional', 'template'].includes(expertMode), 'Mode must be professional or template');
-  const provider = expertMode === 'professional' ? checkDesignProvider({ ...options, project }) : null;
-  if (provider && provider.availability !== 'available') {
-    let action = { id: 'locate', label: '提供当前宿主或实际技能路径' };
-    if (provider.availability === 'missing' && !options.provider) action = { id: 'install', label: '安装并继续' };
-    if (provider.availability === 'unusable') action = { id: 'repair', label: '修复已安装技能并重试' };
-    if (provider.availability === 'disabled') action = { id: 'enable', label: '启用已安装插件并重试' };
-    return { status: 'needs-design-provider', provider, message: `专业增强模式需要可用的 UI/UX Pro Max。${provider.reason}。也可明确选择模板模式继续。`, choices: [action, { id: 'template', label: '模板模式继续' }, { id: 'prepare', label: '先整理需求和模板选择' }] };
-  }
-  ensure(fs.existsSync(project) && fs.statSync(project).isDirectory(), 'Project directory does not exist');
-  const directory = contained(project, `prototypes/${id}`);
-  ensure(!fs.existsSync(directory), 'Prototype already exists / 原型已存在，使用 revise 或另选标识');
-  return projectRegistry.transaction(project, store => {
-  const registry = store.registry;
-  ensure(registry.schemaVersion === 1 && Array.isArray(registry.prototypes), 'Invalid project prototype registry');
-  ensure(!registry.prototypes.some(entry => entry.id === id), 'Prototype registry already contains identifier');
-  const preset = selected.preset;
-  const sourceDigest = template.digest;
-  fs.mkdirSync(path.dirname(directory), { recursive: true });
-  const staging = fs.mkdtempSync(path.join(path.dirname(directory), '.i3-prototype-'));
-  let created = false;
-  try {
-    const metadata = { schemaVersion: 1, id, revision: 'r001', artifactKind: 'html-review', title: options.title || selected.context.manifest.defaultTitle, template: { id: template.id, version: template.version, digest: sourceDigest, adapter: selected.adapterId }, expertMode, expert: { status: provider ? 'pending' : 'skipped', provider }, verification: { status: 'not-run' }, review: { status: 'pending-review' } };
-    const initialized = selected.adapter.initialize(staging, { id, title: metadata.title, purpose: options.purpose }, selected.context);
-    Object.assign(metadata, initialized.metadata);
-    selected.adapter.validateRuntime(metadata);
-    write(staging, 'prototype.json', metadata);
-    write(staging, 'app/config.json', { id, title: metadata.title, templateName: template.name, layout: preset.layout });
-    const tokens = { primitive: preset.primitive, semantic: preset.semantic, component: preset.component };
-    write(staging, 'design-system/tokens.json', tokens);
-    write(staging, 'app/tokens.css', tokensCss(tokens));
-    write(staging, 'qa/design-advice.json', { schemaVersion: 1, mode: expertMode, provider, records: [] });
-    write(staging, 'HANDOFF.md', `# ${metadata.title} 原型交接\n\n模板：${template.name} ${template.version}。模式：${expertMode === 'template' ? '模板模式' : '专业增强模式（专业建议待适配）'}。\n\n运行：在本目录执行 \`node app/serve.cjs\`，按终端显示地址打开。业务数据是本地演示。\n\n${initialized.handoff || ''}读取 requirements-map.json、design-system/MASTER.md 与 qa/REPORT.md。当前为 pending-review；用户明确确认同一版本后才可冻结基线。HTML 交互参考进入框架工程时需要组件和接口映射。\n`);
-    write(staging, 'qa/REPORT.md', '# 原型检查\n\n尚未执行浏览器验收。验证及用户评审分别记录。\n');
-    ensure(!fs.existsSync(directory), 'Prototype already exists');
-    fs.renameSync(staging, directory);
-    created = true;
-    registry.prototypes.push({ id, directory: `prototypes/${id}`, appliesTo: [] });
-    store.save();
-  } catch (error) { if (created) fs.rmSync(directory, { recursive: true, force: true }); throw error; }
-  finally { if (fs.existsSync(staging)) fs.rmSync(staging, { recursive: true, force: true }); }
-  return { status: 'created', directory, template: template.id, expertMode };
-  });
-}
-function contentManifest(directory, registry = templateRegistry) {
-  const metadata = json(contained(directory, 'prototype.json'));
-  if (metadata.schemaVersion === 2) return require('./native-pilot-lib.cjs').manifest(directory);
-  const identity = { id: metadata.id, revision: metadata.revision, template: metadata.template, expertMode: metadata.expertMode, artifactKind: metadata.artifactKind };
-  for (const field of registry.forInstance(metadata).runtime.identityFields) if (Object.hasOwn(metadata, field)) identity[field] = metadata[field];
-  const paths = ['requirements-map.json', 'qa/design-advice.json', ...['app', 'mocks', 'design-system'].flatMap(folder => files(directory, folder))];
-  const entries = Object.fromEntries(paths.sort().map(file => [file, hash(fs.readFileSync(contained(directory, file)))]));
-  return { schemaVersion: 1, revision: metadata.revision, identity, files: entries, digest: hash(JSON.stringify({ identity, files: entries })) };
-}
-function checkPrototype(directory, options = {}, registry = templateRegistry) {
-  if (json(contained(directory, 'prototype.json')).schemaVersion === 2) return require('./native-pilot-lib.cjs').inspect(directory, options);
-  const errors = [];
-  try {
-    const metadata = json(contained(directory, 'prototype.json'));
-    ensure(metadata.schemaVersion === 1 && metadata.artifactKind === 'html-review', 'Invalid prototype contract');
-    ensure(metadata.template?.id && metadata.template.version && /^[a-f0-9]{64}$/.test(metadata.template.digest), 'A computed template version and SHA-256 digest are required');
-    identifier(metadata.id); identifier(metadata.revision);
-    ensure(['professional', 'template'].includes(metadata.expertMode), 'Invalid expert mode');
-    const selected = registry.forInstance(metadata);
-    selected.adapter.validateRuntime(metadata, options);
-    const tokens = json(contained(directory, 'design-system/tokens.json'));
-    ensure(fs.readFileSync(contained(directory, 'app/tokens.css'), 'utf8') === tokensCss(tokens), 'Design tokens and actual stylesheet are inconsistent');
-    const mapping = json(contained(directory, 'requirements-map.json'));
-    ensure(mapping.schemaVersion === 1 && mapping.requirements?.length, 'Requirements mapping is required');
-    const ids = new Set();
-    for (const requirement of mapping.requirements) {
-      ensure(requirement.id && !ids.has(requirement.id), 'Requirement identifiers must be unique'); ids.add(requirement.id);
-      ensure(requirement.pages?.length && requirement.scenarios?.length && requirement.roles?.length && requirement.actions?.length, `Incomplete business mapping: ${requirement.id}`);
-    }
-    const runtimeFiles = [...selected.runtime.requiredFiles];
-    if (metadata.runtime?.offlineVersion === 1) runtimeFiles.push('app/offline.js');
-    for (const file of ['app/index.html', 'app/tokens.css', 'app/config.json', 'design-system/MASTER.md', 'design-system/tokens.json', ...runtimeFiles]) contained(directory, file) && ensure(fs.existsSync(path.join(directory, file)), `Missing resource: ${file}`);
-    const browserFiles = files(directory, 'app').filter(file => /\.(?:html|mjs|js|css)$/.test(file) && !selected.runtime.excludedBrowserPrefixes.some(prefix => file.startsWith(prefix)));
-    for (const file of browserFiles) {
-      const content = fs.readFileSync(path.join(directory, file), 'utf8');
-      for (const match of content.matchAll(/(?:\s|<)(?:src|href)=["']([^"'#]+)["']|(?:import[^;]*?from\s*|import\s*)["']([^"']+)["']/g)) {
-        const reference = match[1] || match[2];
-        if (/^(?:https?:|data:|mailto:|node:)/.test(reference)) continue;
-        const relative = path.relative(directory, path.resolve(path.dirname(path.join(directory, file)), reference));
-        ensure(fs.existsSync(contained(directory, relative)), `Missing local reference: ${file} → ${reference}`);
-      }
-    }
-    const manifest = contentManifest(directory, registry);
-    if (metadata.expertMode === 'professional' && options.acceptance) {
-      const advice = json(contained(directory, 'qa/design-advice.json'));
-      ensure(advice.provider?.digest && advice.records.length && advice.records.every(record => ['adopted', 'adjusted', 'rejected', 'no-match'].includes(record.decision) && record.query && record.resultIdentity && record.rationale && record.verification), 'Professional advice has not been queried and reviewed');
-    }
-    if (options.acceptance) {
-      const evidence = json(contained(directory, 'qa/browser.json'));
-      ensure(evidence.status === 'passed' && evidence.digest === manifest.digest && evidence.revision === manifest.revision, 'Current matching browser evidence / 浏览器证据 required');
-      ensure(evidence.source && evidence.journeys?.length && evidence.journeys.every(item => item.status === 'passed') && Array.isArray(evidence.consoleErrors) && !evidence.consoleErrors.length && evidence.screenshots?.length && evidence.viewports?.length >= 2, 'Browser acceptance incomplete');
-      for (const file of evidence.screenshots) ensure(fs.statSync(contained(directory, file)).size > 0, 'Missing screenshot evidence');
-      const required = new Set(mapping.requirements.flatMap(requirement => requirement.scenarios));
-      for (const scenario of required) ensure(evidence.journeys.some(item => item.id === scenario && item.status === 'passed'), `Missing browser scenario: ${scenario}`);
-    }
-    return { status: 'passed', revision: manifest.revision, digest: manifest.digest, acceptance: Boolean(options.acceptance) };
-  } catch (error) { errors.push(error.message); return { status: 'failed', errors }; }
-}
-function freezeBaseline(directory, confirmation, registry = templateRegistry) {
-  if (json(contained(directory, 'prototype.json')).schemaVersion === 2) return require('./native-pilot-lib.cjs').confirmBaseline(directory, confirmation);
-  const current = contentManifest(directory, registry);
-  ensure(confirmation.revision === current.revision && confirmation.digest === current.digest, 'Human confirmation must match current changed content / 确认版本及内容必须一致');
-  ensure(confirmation.reviewer?.trim() && confirmation.statement?.trim() && confirmation.source?.trim(), 'Explicit human confirmation / 人类确认 required');
-  const target = contained(directory, `baselines/${identifier(current.revision)}`);
-  ensure(!fs.existsSync(target), 'Baseline already exists / 基线已存在');
-  const result = checkPrototype(directory, { acceptance: true }, registry);
-  ensure(result.status === 'passed', result.errors?.join('; '));
-  const staging = contained(directory, `baselines/.${current.revision}-${crypto.randomUUID()}`);
-  try {
-    fs.mkdirSync(staging, { recursive: true });
-    for (const file of Object.keys(current.files)) { const destination = contained(staging, file); fs.mkdirSync(path.dirname(destination), { recursive: true }); fs.copyFileSync(contained(directory, file), destination); }
-    write(staging, 'manifest.json', current);
-    write(staging, 'review.json', { ...confirmation, approvedAt: new Date().toISOString() });
-    ensure(Object.entries(current.files).every(([file, digest]) => hash(fs.readFileSync(contained(staging, file))) === digest) && contentManifest(directory, registry).digest === current.digest, 'Candidate changed while freezing snapshot');
-    const reviewDigest = hash(fs.readFileSync(contained(staging, 'review.json')));
-    fs.renameSync(staging, target);
-    atomicJson(directory, 'baseline.json', { schemaVersion: 1, revision: current.revision, digest: current.digest, reviewDigest, directory: `baselines/${current.revision}` });
-    const metadata = json(contained(directory, 'prototype.json'));
-    metadata.review = { status: 'approved', revision: current.revision, digest: current.digest, source: confirmation.source };
-    metadata.verification = { status: 'passed', digest: current.digest };
-    if (metadata.expertMode === 'professional') {
-      const advice = json(contained(directory, 'qa/design-advice.json'));
-      metadata.expert.status = advice.records.some(record => ['adopted', 'adjusted'].includes(record.decision)) ? 'used' : advice.records.every(record => record.decision === 'no-match') ? 'no-match' : 'reviewed';
-    }
-    atomicJson(directory, 'prototype.json', metadata);
-  } finally { if (fs.existsSync(staging)) fs.rmSync(staging, { recursive: true, force: true }); }
-  return current;
-}
-function compareBaseline(directory, registry = templateRegistry) {
-  if (json(contained(directory, 'prototype.json')).schemaVersion === 2) return require('./native-pilot-lib.cjs').compareBaseline(directory);
-  if (!fs.existsSync(contained(directory, 'baseline.json'))) return { status: 'no-baseline', changes: [], protectedChanges: [] };
-  const baseline = json(contained(directory, 'baseline.json'));
-  const snapshot = contained(directory, baseline.directory);
-  const approved = json(contained(snapshot, 'manifest.json'));
-  const reviewFile = contained(snapshot, 'review.json');
-  if (baseline.revision !== approved.revision || !fs.existsSync(reviewFile) || hash(fs.readFileSync(reviewFile)) !== baseline.reviewDigest) return { status: 'corrupt-baseline', changes: [], protectedChanges: [] };
-  if (approved.digest !== baseline.digest || hash(JSON.stringify({ identity: approved.identity, files: approved.files })) !== approved.digest || Object.entries(approved.files).some(([file, digest]) => !fs.existsSync(contained(snapshot, file)) || hash(fs.readFileSync(contained(snapshot, file))) !== digest)) return { status: 'corrupt-baseline', changes: [], protectedChanges: [] };
-  const current = contentManifest(directory, registry);
-  const changes = [...new Set([...Object.keys(approved.files), ...Object.keys(current.files)])].filter(file => approved.files[file] !== current.files[file]);
-  const selectionChanged = JSON.stringify(approved.identity.template) !== JSON.stringify(current.identity.template) || approved.identity.expertMode !== current.identity.expertMode;
-  const runtime = registry.forInstance(current.identity).runtime;
-  // Shared design contracts remain protected for every runtime; adapters add
-  // their own runtime resources and identity fields rather than replacing it.
-  const shared = ['app/tokens.css', 'app/index.html', 'requirements-map.json'];
-  const protectedChanges = changes.filter(file => file.startsWith('design-system/') || shared.includes(file) || runtime.protectedFiles.includes(file) || runtime.protectedDirectories.some(prefix => file.startsWith(prefix)));
-  if (runtime.identityFields.some(field => JSON.stringify(approved.identity[field]) !== JSON.stringify(current.identity[field]))) protectedChanges.push('runtime-contract');
-  if (selectionChanged) protectedChanges.push('template-or-expert-mode');
-  return { status: changes.length || protectedChanges.length ? 'changed' : 'unchanged', baselineRevision: baseline.revision, currentRevision: current.revision, changes, protectedChanges };
-}
-function revisePrototype(directory, revision, options = {}) {
-  if (json(contained(directory, 'prototype.json')).schemaVersion === 2) return require('./native-pilot-lib.cjs').revise(directory, { ...options, revision });
-  identifier(revision);
-  const metadata = json(contained(directory, 'prototype.json'));
-  ensure(revision !== metadata.revision && !fs.existsSync(contained(directory, `baselines/${revision}`)), 'Use a new unused revision identifier');
-  metadata.revision = revision; metadata.review = { status: 'pending-review' }; metadata.verification = { status: 'not-run' };
-  atomicJson(directory, 'prototype.json', metadata);
-  return { status: 'revised', revision };
-}
-function parseArgs(argv) {
-  const options = {}, positional = [];
-  for (let i = 0; i < argv.length; i++) {
-    if (!argv[i].startsWith('--')) { positional.push(argv[i]); continue; }
-    const key = argv[i].slice(2).replace(/-([a-z])/g, (_, char) => char.toUpperCase());
-    if (['acceptance', 'enforceBaseline', 'designSystem'].includes(key)) options[key] = true;
-    else { ensure(argv[i + 1] && !argv[i + 1].startsWith('--'), `Missing option value: ${argv[i]}`); options[key] = argv[++i]; }
-  }
-  return { options, positional };
-}
-module.exports = { initPrototype, listTemplates, checkDesignProvider, queryProvider, contentManifest, checkPrototype, freezeBaseline, compareBaseline, revisePrototype, parseArgs };