agent-policy-kit 0.2.0 → 0.4.0

package/src/detect.mjs

@@ -4,17 +4,65 @@ import os from 'node:os';
 import path from 'node:path';
 import { spawn } from 'node:child_process';
 
-const CLIENTS = ['codex','claude','kimi','agy','grok'];
+const CLIENTS = ['chatgpt','claude','kimi','gemini','grok'];
+// Each tool's own executable keeps its native name: ChatGPT runs Codex, and Gemini runs Antigravity (agy).
+const EXECUTABLES = {chatgpt:'codex',claude:'claude',kimi:'kimi',gemini:'agy',grok:'grok'};
 const OUTPUT_LIMIT = 65536;
 const VERSION = String.raw`(\d{1,4}\.\d{1,4}\.\d{1,4}(?:-[A-Za-z0-9][A-Za-z0-9.-]{0,63})?(?:\+[A-Za-z0-9][A-Za-z0-9.-]{0,63})?)`;
 function failure(code) { return Object.assign(new Error(code),{code}); }
-function options({env=process.env,hostHome=os.homedir(),timeoutMs=5000} = {}) {
-  if (!env || typeof env !== 'object' || typeof hostHome !== 'string' || !path.isAbsolute(hostHome) || hostHome.includes('\0') || !Number.isInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 30000) throw failure('INVALID_DETECTION_OPTIONS');
-  return {env,hostHome:path.resolve(hostHome),timeoutMs};
+const absolute = value => typeof value === 'string' && path.isAbsolute(value) && !value.includes('\0');
+function options({env=process.env,hostHome=os.homedir(),timeoutMs=5000,platform=process.platform,systemApplications} = {}) {
+  // AGENT_POLICY_APPLICATIONS_DIR replaces /Applications, so hermetic runs never see the host's installed apps.
+  systemApplications ??= (typeof env?.AGENT_POLICY_APPLICATIONS_DIR === 'string' && env.AGENT_POLICY_APPLICATIONS_DIR) || '/Applications';
+  if (!env || typeof env !== 'object' || !absolute(hostHome) || !Number.isInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 30000 || typeof platform !== 'string' || !absolute(systemApplications)) throw failure('INVALID_DETECTION_OPTIONS');
+  return {env,hostHome:path.resolve(hostHome),timeoutMs,platform,systemApplications:path.resolve(systemApplications)};
 }
-function candidates(client,{env,hostHome}) {
+// Desktop apps ship their own copy of a CLI and keep it off PATH. ChatGPT Desktop runs Codex from a
+// fixed bundle path; Claude Desktop keeps one Claude Code per <version>/<build> directory.
+const CHATGPT_CODEX = 'ChatGPT.app/Contents/Resources/codex-cli/CodexCLI.app/Contents/MacOS/codex';
+const CLAUDE_DESKTOP = 'Library/Application Support/Claude/claude-code';
+const DESKTOP_VERSION = /^(\d{1,4})\.(\d{1,4})\.(\d{1,4})$/;
+const DESKTOP_BUILD = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+const DESKTOP_LIMIT = 8;
+async function directories(dir) {
+  try { return (await fs.readdir(dir,{withFileTypes:true})).filter(entry=>entry.isDirectory()).map(entry=>entry.name); }
+  catch { return []; }
+}
+function newerFirst(a,b) {
+  const [x,y] = [a,b].map(name=>name.match(DESKTOP_VERSION).slice(1).map(Number));
+  return y[0]-x[0] || y[1]-x[1] || y[2]-x[2];
+}
+async function desktopCandidates(client,{hostHome,platform,systemApplications}) {
+  if (platform !== 'darwin') return [];
+  if (client === 'chatgpt') return [systemApplications,path.join(hostHome,'Applications')].map(dir=>path.join(dir,CHATGPT_CODEX));
+  if (client !== 'claude') return [];
+  const base = path.join(hostHome,CLAUDE_DESKTOP), files = [];
+  for (const version of (await directories(base)).filter(name=>DESKTOP_VERSION.test(name)).sort(newerFirst)) {
+    // Only builds that contain the CLI count toward the limit, so empty or partial folders cannot hide a working one.
+    // Within one version the most recently written CLI comes first; the name breaks ties.
+    const builds = [];
+    for (const build of (await directories(path.join(base,version))).filter(name=>DESKTOP_BUILD.test(name))) {
+      const file = path.join(base,version,build,'claude.app/Contents/MacOS/claude');
+      try { const stat = await fs.stat(file); if (stat.isFile()) builds.push({file,build,mtime:stat.mtimeMs}); } catch {}
+    }
+    builds.sort((a,b)=>b.mtime-a.mtime || (a.build < b.build ? -1 : a.build > b.build ? 1 : 0));
+    for (const {file} of builds) {
+      files.push(file);
+      // The limit bounds detection time: each candidate that exists is started once with --version.
+      if (files.length === DESKTOP_LIMIT) return files;
+    }
+  }
+  return files;
+}
+async function candidates(client,settings) {
+  const result = cliCandidates(client,settings);
+  for (const file of await desktopCandidates(client,settings)) result.push({file,origin:'desktop_app'});
+  return result.filter((candidate,index) => result.findIndex(c=>c.file === candidate.file) === index);
+}
+function cliCandidates(client,{env,hostHome}) {
   const dirs = typeof env.PATH === 'string' ? env.PATH.split(path.delimiter) : [];
-  const names = process.platform === 'win32' ? [client + '.exe',client] : [client];
+  const executable = EXECUTABLES[client];
+  const names = process.platform === 'win32' ? [executable + '.exe',executable] : [executable];
   const result = [];
   for (const dir of dirs) {
     // Never search the working directory through empty/relative PATH segments.
@@ -23,9 +71,9 @@ function candidates(client,{env,hostHome}) {
   }
   const conventional = client === 'kimi' ? ['.kimi-code/bin/kimi']
     : client === 'claude' ? ['.local/bin/claude','.claude/local/claude']
-    : [`.local/bin/${client}`];
+    : [`.local/bin/${executable}`];
   for (const relative of conventional) result.push({file:path.join(hostHome,relative),origin:'known_location'});
-  return result.filter((candidate,index) => result.findIndex(c=>c.file === candidate.file) === index);
+  return result;
 }
 async function inspect(file) {
   try {
@@ -78,10 +126,10 @@ function probe(executable,arg,{env,timeoutMs}) {
 }
 function identity(client,output) {
   const patterns = {
-    codex:[new RegExp(String.raw`^\s*codex(?:-cli)?\s+v?${VERSION}(?:\s|$)`,'im')],
+    chatgpt:[new RegExp(String.raw`^\s*codex(?:-cli)?\s+v?${VERSION}(?:\s|$)`,'im')],
     claude:[new RegExp(String.raw`^\s*v?${VERSION}\s+\(Claude Code\)(?:\s|$)`,'im'),new RegExp(String.raw`^\s*Claude Code\s+v?${VERSION}(?:\s|$)`,'im')],
     kimi:[new RegExp(String.raw`^\s*kimi(?:\s+code(?:\s+cli)?)?(?:,?\s+version)?\s+v?${VERSION}(?:\s|$)`,'im')],
-    agy:[new RegExp(String.raw`^\s*(?:Antigravity|agy)\s+v?${VERSION}(?:\s|$)`,'im')],
+    gemini:[new RegExp(String.raw`^\s*(?:Antigravity|agy)\s+v?${VERSION}(?:\s|$)`,'im')],
     grok:[new RegExp(String.raw`^\s*grok\s+v?${VERSION}(?:\s|$)`,'im')],
   };
   for (const pattern of patterns[client]) { const match = output.match(pattern); if (match && match[1].length <= 128) return match[1]; }
@@ -92,7 +140,7 @@ async function verify(client,executable,opts) {
   if (version.status !== 'ok') return {status:version.status};
   const branded = identity(client,version.output);
   if (branded) return {status:'detected',version:branded};
-  if (client !== 'kimi' && client !== 'agy') return {status:'invalid'};
+  if (client !== 'kimi' && client !== 'gemini') return {status:'invalid'};
   const number = version.output.match(new RegExp(String.raw`^\s*v?${VERSION}(?:\s|$)`));
   if (!number || number[1].length > 128) return {status:'invalid'};
   const help = await probe(executable,'--help',opts);
@@ -110,7 +158,7 @@ export async function resolveClient(client,opts = {}) {
   const settings = options(opts);
   let best = {client,status:'not_found',version:null,origin:null,executable:null};
   const checked = new Set();
-  for (const candidate of candidates(client,settings)) {
+  for (const candidate of await candidates(client,settings)) {
     const inspected = await inspect(candidate.file);
     if (inspected.status === 'not_found') continue;
     if (inspected.status === 'invalid') {
@@ -132,6 +180,6 @@ export function summarizeDetection(records) {
   return records.filter(r=>CLIENTS.includes(r?.client)).map(({client,status,version,origin})=>{
     status = ['detected','not_found','invalid','timeout'].includes(status) ? status : 'invalid';
     if (status === 'detected' && (typeof version !== 'string' || version.length > 128 || !new RegExp(`^${VERSION}$`).test(version))) status = 'invalid';
-    return {client,status,version:status === 'detected' ? version : null,origin:['path','known_location'].includes(origin) ? origin : null};
+    return {client,status,version:status === 'detected' ? version : null,origin:['path','known_location','desktop_app'].includes(origin) ? origin : null};
   });
 }

package/src/explicit.mjs

@@ -1,5 +1,5 @@
 // Pure command codec, also embedded in the offline configuration page.
-export const TOOL_FLAGS=Object.freeze({codex:'codex',claude:'claude',kimi:'kimi',antigravity:'agy',grok:'grok'});
+export const TOOL_FLAGS=Object.freeze({chatgpt:'chatgpt',claude:'claude',kimi:'kimi',gemini:'gemini',grok:'grok'});
 export const EXPLICIT_FIELDS=Object.freeze(['roles','max-concurrent',...Object.keys(TOOL_FLAGS),...Object.keys(TOOL_FLAGS).map(flag=>'avoid-'+flag),...Object.keys(TOOL_FLAGS).map(flag=>flag+'-max-concurrent')]);
 const EXPLICIT_MODEL=/^[A-Za-z0-9][A-Za-z0-9._:@/\[\]-]{0,127}$/;
 const EXPLICIT_EFFORTS=['none','minimal','low','medium','high','xhigh','max'];
@@ -31,7 +31,7 @@ export function parseExplicitOptions(options,roleIds){
    const at=entry.indexOf('='),role=entry.slice(0,at).trim(),value=entry.slice(at+1).trim();
    if(at<1||!roles.includes(role)||Object.hasOwn(choices,role))invalidExplicit();
    let model=value,effort=null;
-   if(client==='agy'){if(!['pro','flash','flash_lite','inherit'].includes(model))invalidExplicit();}
+   if(client==='gemini'){if(!['pro','flash','flash_lite','inherit'].includes(model))invalidExplicit();}
    else if(client==='grok'){if(grokEffortSuffix(value))invalidExplicit();}
    else{
     const colon=value.lastIndexOf(':');if(colon<1)invalidExplicit();
@@ -68,9 +68,9 @@ export function explicitOptions(config,roleCatalog){
   options[flag]=roles.map(role=>{
    const selected=preferences.roles?.[role]??preferences[kinds.get(role)];
    if(!selected||typeof selected.model!=='string'||!EXPLICIT_MODEL.test(selected.model)||(selected.effort!==null&&!EXPLICIT_EFFORTS.includes(selected.effort)))invalidExplicit();
-   if(['agy','grok'].includes(client)&&selected.effort!==null)invalidExplicit();
+   if(['gemini','grok'].includes(client)&&selected.effort!==null)invalidExplicit();
    if(client==='grok'&&grokEffortSuffix(selected.model))invalidExplicit();
-   return `${role}=${selected.model}${['agy','grok'].includes(client)?'':':'+(selected.effort??'native')}`;
+   return `${role}=${selected.model}${['gemini','grok'].includes(client)?'':':'+(selected.effort??'native')}`;
   }).join(',');
   if(preferences.maxConcurrent!==undefined)options[flag+'-max-concurrent']=String(preferences.maxConcurrent);
   if(!Array.isArray(preferences.avoidModels)||preferences.avoidModels.some(model=>typeof model!=='string'||!EXPLICIT_MODEL.test(model)))invalidExplicit();

package/src/inspect.mjs

@@ -5,8 +5,8 @@ import {parseToml} from './toml.mjs';
 import {CLIENTS} from './policy.mjs';
 import {inspectConfiguration} from './install.mjs';
 
-const ROOTS={codex:'.codex',claude:'.claude',kimi:'.kimi-code',agy:'.gemini',grok:'.grok'};
-const ENV_ROOTS={codex:'CODEX_HOME',claude:'CLAUDE_CONFIG_DIR',kimi:'KIMI_CODE_HOME',grok:'GROK_HOME'};
+const ROOTS={chatgpt:'.codex',claude:'.claude',kimi:'.kimi-code',gemini:'.gemini',grok:'.grok'};
+const ENV_ROOTS={chatgpt:'CODEX_HOME',claude:'CLAUDE_CONFIG_DIR',kimi:'KIMI_CODE_HOME',grok:'GROK_HOME'};
 const MAX_FILE=1024*1024,MAX_TOTAL=4*MAX_FILE,MAX_ENTRIES=256;
 const identifier=/^[A-Za-z0-9][A-Za-z0-9._:@/\[\]-]{0,127}$/;
 const namePattern=/^[A-Za-z0-9][A-Za-z0-9 _.-]{0,79}$/;
@@ -88,7 +88,7 @@ function extractSettings(client,id,native,env,models){
   if(subagents.max_concurrent!==undefined)client.concurrency.value=cap(subagents.max_concurrent);
   return;
  }
- if(id==='codex'){
+ if(id==='chatgpt'){
   const agents=native.agents??{};if(!record(agents))throw failure('UNSUPPORTED_NATIVE_SETTING');
   client.defaults.model=optionalString(agents.default_subagent_model);
   client.defaults.effort=optionalString(agents.default_subagent_reasoning_effort);
@@ -100,10 +100,11 @@ function extractSettings(client,id,native,env,models){
  }else if(id==='claude'){
   const stored=native.env??{};if(!record(stored))throw failure('UNSUPPORTED_NATIVE_SETTING');
   client.defaults.model=optionalString(stored.CLAUDE_CODE_SUBAGENT_MODEL);
+  client.defaults.effort=optionalString(stored.CLAUDE_CODE_SUBAGENT_EFFORT);
   const count=stored.CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS;
   if(count!==undefined){if(typeof count!=='string'||!/^\d{1,9}$/.test(count))throw failure('UNSUPPORTED_NATIVE_SETTING');client.concurrency.value=cap(Number(count));}
   client.overrides={};
-  for(const[key,field]of [['CLAUDE_CODE_SUBAGENT_MODEL','model'],['CLAUDE_CODE_EFFORT_LEVEL','effort']]){
+  for(const[key,field]of [['CLAUDE_CODE_SUBAGENT_MODEL','model'],['CLAUDE_CODE_SUBAGENT_EFFORT','subagentEffort'],['CLAUDE_CODE_EFFORT_LEVEL','effort']]){
    const value=env[key]??(field==='effort'?stored[key]:undefined);
    if(value!==undefined)client.overrides[field]=safeString(value);
   }
@@ -132,14 +133,14 @@ async function rolesIn(directory,client,id,budget,models,depth=0){
   try{
    if(entry.isSymbolicLink())throw failure('UNSAFE_FILE');
    if(entry.isDirectory()){
-    if(id==='codex')continue;
+    if(id==='chatgpt')continue;
     if(depth>=4)throw failure('INSPECTION_LIMIT');
     await rolesIn(file,client,id,budget,models,depth+1);continue;
    }
-   if(!entry.name.endsWith(id==='codex'?'.toml':'.md'))continue;
+   if(!entry.name.endsWith(id==='chatgpt'?'.toml':'.md'))continue;
    const body=await readFile(file,budget);if(body===null)throw failure('CONFIG_CHANGED_DURING_READ');
-   const fields=id==='codex'?parseToml(body):frontmatter(body);
-   const role={name:safeString(fields.name,namePattern),model:optionalString(fields.model),effort:optionalString(id==='codex'?fields.model_reasoning_effort:fields.effort)};
+   const fields=id==='chatgpt'?parseToml(body):frontmatter(body);
+   const role={name:safeString(fields.name,namePattern),model:optionalString(fields.model),effort:optionalString(id==='chatgpt'?fields.model_reasoning_effort:fields.effort)};
    if(id==='kimi'){
     // APK's Markdown role files contain explicit routing guidance, not a
     // native model binding. Other prose is never interpreted as configuration.
@@ -154,7 +155,7 @@ async function rolesIn(directory,client,id,budget,models,depth=0){
     role.model=models.get(role.name)??role.model;
     if(fields.effort!==undefined){role.effort=null;warning(client,failure('UNSUPPORTED_ROLE_EFFORT'));}
    }
-   if(id==='agy'){
+   if(id==='gemini'){
     if(role.model!==null&&!['pro','flash','flash_lite','inherit'].includes(role.model))throw failure('UNSUPPORTED_NATIVE_SETTING');
     role.enabled=fields.subagent??null;
     if(fields.effort!==undefined){role.effort=null;warning(client,failure('UNSUPPORTED_ROLE_EFFORT'));}
@@ -179,19 +180,19 @@ export async function readConfiguration({client=null,home,env=process.env,explic
  const report={schemaVersion:1,scope:'user',modelExecution:'not_checked',clients:{}};
  for(const id of client?[client]:CLIENTS){
   const root=path.resolve(!explicitHome&&env[ENV_ROOTS[id]]?env[ENV_ROOTS[id]]:path.join(home,ROOTS[id]));
-  const c={status:'not_configured',defaults:{model:null,effort:null,enabled:null},concurrency:{value:null,kind:['codex','claude','grok'].includes(id)?'native_setting':'guidance'},roles:[],pool:[],warnings:[],apk:{status:'not_checked'}};
+  const c={status:'not_configured',defaults:{model:null,effort:null,enabled:null},concurrency:{value:null,kind:['chatgpt','claude','grok'].includes(id)?'native_setting':'guidance'},roles:[],pool:[],warnings:[],apk:{status:'not_checked'}};
   report.clients[id]=c;const budget={bytes:0,entries:0},models=new Map();
   try{
    await safePath(root);
-   if(id!=='agy'){
+   if(id!=='gemini'){
     try{
      const text=await readFile(path.join(root,id==='claude'?'settings.json':'config.toml'),budget);
      if(text!==null){let native;if(id==='claude'){try{native=JSON.parse(text);}catch{throw failure('INVALID_JSON');}}else native=parseToml(text);extractSettings(c,id,native,env,models);}
      else if(id==='claude')extractSettings(c,id,{},env,models);
     }catch(error){warning(c,error);}
    }
-   await rolesIn(path.join(root,id==='agy'?'config/agents':'agents'),c,id,budget,models);
-   if(id==='kimi'||id==='agy'){try{await readGuidance(root,c,budget);}catch(error){warning(c,error);}}
+   await rolesIn(path.join(root,id==='gemini'?'config/agents':'agents'),c,id,budget,models);
+   if(id==='kimi'||id==='gemini'){try{await readGuidance(root,c,budget);}catch(error){warning(c,error);}}
    if(c.status!=='attention'&&(c.roles.length||c.pool.length||c.defaults.model!==null||c.defaults.effort!==null||c.defaults.enabled!==null||c.concurrency.value!==null||Object.keys(c.overrides??{}).length))c.status='configured';
    if(root===path.resolve(home,ROOTS[id])){
     try{const installed=await inspectConfiguration({client:id,home,stateDir});c.apk.status=installed.status;if(installed.status==='verified'){c.apk.releaseVersion=installed.releaseVersion;c.apk.preset=installed.preset;}}

package/src/install.mjs

@@ -10,7 +10,7 @@ import catalog from '../models/catalog.json' with {type:'json'};
 import { parseToml, setTomlValue, restoreTomlValue, removeTomlValue } from './toml.mjs';
 import { nativeLocations, nativeRoles, instructionBlock, nativeWarnings, BEGIN, END } from './native.mjs';
 
-const CLIENTS = ['codex', 'claude', 'kimi', 'agy', 'grok'];
+const CLIENTS = ['chatgpt', 'claude', 'kimi', 'gemini', 'grok'];
 const LIMIT = 1024 * 1024;
 const digest = value => value === null ? null : createHash('sha256').update(value).digest('hex');
 const json = value => JSON.stringify(value, null, 2) + '\n';
@@ -87,11 +87,15 @@ function ensureObject(parent,key) {
   if(!object(parent[key]))fail('UNSUPPORTED_CONFIG');
   return parent[key];
 }
-function jsonInstall(text,maxConcurrent,defaultModel) {
+// Claude Code 2.1.316+ reads CLAUDE_CODE_SUBAGENT_EFFORT for subagents that name no effort; older versions ignore it.
+// It copies the Coder effort, capped at high, so a Coder at xhigh or max does not raise every unnamed subagent.
+const CLAUDE_SUBAGENT_EFFORTS=['low','medium','high'];
+const claudeSubagentEffort=effort=>effort===null?null:CLAUDE_SUBAGENT_EFFORTS.includes(effort)?effort:'high';
+function jsonInstall(text,maxConcurrent,defaultChoice) {
   const value=configJson(text),ops=[],created=[];
   if(!own(value,'env'))created.push(['env']);
-  const env=ensureObject(value,'env');
-  for(const [key,after] of [['CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS',String(maxConcurrent)],['CLAUDE_CODE_SUBAGENT_MODEL',defaultModel]]) {
+  const env=ensureObject(value,'env'),effort=claudeSubagentEffort(defaultChoice.effort);
+  for(const [key,after] of [['CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS',String(maxConcurrent)],['CLAUDE_CODE_SUBAGENT_MODEL',defaultChoice.model],...(effort===null?[]:[['CLAUDE_CODE_SUBAGENT_EFFORT',effort]])]) {
     if(own(env,key)&&typeof env[key]!=='string')fail('UNSUPPORTED_CONFIG');
     ops.push({kind:'value',path:['env',key],existed:own(env,key),before:env[key]??null,after});env[key]=after;
   }
@@ -155,7 +159,7 @@ function selectedAliases(preferences,selectedRoles=ROLE_IDS) {
 }
 function tomlSettings(client,preferences,maxConcurrent,selectedRoles=ROLE_IDS) {
   const worker=rolePreference(preferences,selectedRoles[0]);
-  if(client==='codex')return [[['agents','max_concurrent_threads_per_session'],maxConcurrent],[['agents','default_subagent_model'],worker.model],...(worker.effort===null?[]:[[['agents','default_subagent_reasoning_effort'],worker.effort]])];
+  if(client==='chatgpt')return [[['agents','max_concurrent_threads_per_session'],maxConcurrent],[['agents','default_subagent_model'],worker.model],...(worker.effort===null?[]:[[['agents','default_subagent_reasoning_effort'],worker.effort]])];
   if(client==='grok')return [[['subagents','max_concurrent'],maxConcurrent],...selectedRoles.map(role=>[['subagents','models','apk-'+role],rolePreference(preferences,role).model]),[['subagents','models','general-purpose'],worker.model]];
   if(client!=='kimi')return [];
   const selected=selectedAliases(preferences,selectedRoles),roles=effectiveRoles(preferences,selectedRoles);
@@ -185,7 +189,7 @@ function scalar(op,target,type) {
 }
 function validateTomlSnapshot(file,client,schemaVersion,selectedRoles=ROLE_IDS) {
   if(!Array.isArray(file.ops)||!file.ops.every(op=>object(op)&&Array.isArray(op.path)&&op.path.every(key=>typeof key==='string')&&op.path.length<=4))fail('INVALID_RECEIPT');
-  if(client==='codex') {
+  if(client==='chatgpt') {
     if(!(schemaVersion===2?[3]:[2,3]).includes(file.ops.length))fail('INVALID_RECEIPT');
     const cap=scalar(file.ops[0],['agents','max_concurrent_threads_per_session'],'number');
     if(cap<1||cap>32)fail('INVALID_RECEIPT');
@@ -235,12 +239,14 @@ function validateTomlSnapshot(file,client,schemaVersion,selectedRoles=ROLE_IDS)
     if(!aliases.includes(name)||pinned.has(name))fail('INVALID_RECEIPT');pinned.add(name);scalar(op,['models',name,'overrides','default_effort'],'string');
   }
 }
-function validateJsonSnapshot(file) {
-  if(!Array.isArray(file.ops)||file.ops.length!==2||!Array.isArray(file.created)||file.created.length>1||!file.created.every(keys=>equal(keys,['env'])))fail('INVALID_RECEIPT');
-  for(const[i,key]of ['CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS','CLAUDE_CODE_SUBAGENT_MODEL'].entries()) {
+function validateJsonSnapshot(file,schemaVersion) {
+  // Receipts before format v4 never owned CLAUDE_CODE_SUBAGENT_EFFORT; v4 owns it only when the Coder effort was pinned.
+  if(!Array.isArray(file.ops)||!(schemaVersion===4?[2,3]:[2]).includes(file.ops.length)||!Array.isArray(file.created)||file.created.length>1||!file.created.every(keys=>equal(keys,['env'])))fail('INVALID_RECEIPT');
+  for(const[i,key]of ['CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS','CLAUDE_CODE_SUBAGENT_MODEL','CLAUDE_CODE_SUBAGENT_EFFORT'].slice(0,file.ops.length).entries()) {
     const op=file.ops[i];fields(op,['kind','path','existed','before','after']);
     if(op.kind!=='value'||!equal(op.path,['env',key])||typeof op.existed!=='boolean'||typeof op.after!=='string'||op.after.length>4096||(op.existed?typeof op.before!=='string'||op.before.length>4096:op.before!==null))fail('INVALID_RECEIPT');
     if(i===0&&(!/^[1-9]\d?$/.test(op.after)||Number(op.after)>32))fail('INVALID_RECEIPT');
+    if(i===2&&!CLAUDE_SUBAGENT_EFFORTS.includes(op.after))fail('INVALID_RECEIPT');
   }
 }
 function validateReceipt(r,plan) {
@@ -260,7 +266,7 @@ function validateReceipt(r,plan) {
       fields(file,['path','type','existed','prefix','block']);
       if(file.type!=='instructions'||!['','\n','\n\n'].includes(file.prefix)||typeof file.block!=='string'||file.block.length>65536||!file.block.startsWith(BEGIN+'\n')||!file.block.endsWith(END+'\n')||file.block.split(BEGIN).length!==2||file.block.split(END).length!==2)fail('INVALID_RECEIPT');
     } else if(plan.client==='claude') {
-      fields(file,['path','type','existed','ops','created']);if(file.type!=='json')fail('INVALID_RECEIPT');validateJsonSnapshot(file);
+      fields(file,['path','type','existed','ops','created']);if(file.type!=='json')fail('INVALID_RECEIPT');validateJsonSnapshot(file,r.schemaVersion);
     } else {
       fields(file,['path','type','existed','ops']);if(file.type!=='toml')fail('INVALID_RECEIPT');validateTomlSnapshot(file,plan.client,r.schemaVersion,r.schemaVersion===4?r.selectedRoles:LEGACY_ROLE_IDS);
     }
@@ -389,15 +395,15 @@ export async function planInstall(options) {
       const cap=subagents?.max_concurrent;
       if(cap!==undefined&&(!Number.isSafeInteger(cap)||cap<1))fail('UNSUPPORTED_CONFIG');
     }
-    if(plan.client==='codex') {
-      if(native.agents&&own(native.agents,'max_threads'))fail('CODEX_CAP_ALIAS_CONFLICT');
+    if(plan.client==='chatgpt') {
+      if(native.agents&&own(native.agents,'max_threads'))fail('CHATGPT_CAP_ALIAS_CONFLICT');
       const cap=native.agents?.max_concurrent_threads_per_session;
       if(cap!==undefined&&(!Number.isSafeInteger(cap)||cap<1))fail('UNSUPPORTED_CONFIG');
     }
   }
   const files=[];plan.warnings=[...nativeWarnings(plan.client),...(resolvedAliases?['kimi-catalog-alias-resolved']:[])];
   if(plan.client==='claude') {
-    const edited=jsonInstall(config.text,maxConcurrent,rolePreference(selected,roleIds[0]).model);nativeChange(l.config,config,edited.text);
+    const edited=jsonInstall(config.text,maxConcurrent,rolePreference(selected,roleIds[0]));nativeChange(l.config,config,edited.text);
     files.push({path:l.config,type:'json',existed:config.text!==null,ops:edited.ops,created:edited.created});
   } else if(config) {
     let text=config.text??'';const ops=[];

package/src/native.mjs

@@ -4,25 +4,25 @@ import {ROLE_DEFINITIONS,ROLE_IDS} from './roles.mjs';
 
 export const BEGIN = '<!-- BEGIN agent-policy-kit -->';
 export const END = '<!-- END agent-policy-kit -->';
-const directory = {codex:'.codex',claude:'.claude',kimi:'.kimi-code',agy:'.gemini',grok:'.grok'};
+const directory = {chatgpt:'.codex',claude:'.claude',kimi:'.kimi-code',gemini:'.gemini',grok:'.grok'};
 export function nativeHomeConflict(client,home,env) {
-  const variable={codex:'CODEX_HOME',claude:'CLAUDE_CONFIG_DIR',kimi:'KIMI_CODE_HOME',grok:'GROK_HOME'}[client];
+  const variable={chatgpt:'CODEX_HOME',claude:'CLAUDE_CONFIG_DIR',kimi:'KIMI_CODE_HOME',grok:'GROK_HOME'}[client];
   const active=variable&&env[variable];
   return typeof active==='string'&&active.length>0&&path.resolve(active)!==path.resolve(home,directory[client]);
 }
 export function nativeLocations(client,home) {
   const root=path.join(home,directory[client]);
   return {
-    config:client==='agy'?null:path.join(root,client==='claude'?'settings.json':'config.toml'),
+    config:client==='gemini'?null:path.join(root,client==='claude'?'settings.json':'config.toml'),
     instructions:path.join(root,client==='claude'?'CLAUDE.md':'AGENTS.md'),
-    roles:Object.keys(ROLES).map(role=>path.join(root,client==='agy'?'config/agents':'agents',`apk-${role}.${client==='codex'?'toml':'md'}`))
+    roles:Object.keys(ROLES).map(role=>path.join(root,client==='gemini'?'config/agents':'agents',`apk-${role}.${client==='chatgpt'?'toml':'md'}`))
   };
 }
 export function nativeRoles(client,config,selectedRoles=ROLE_IDS) {
   return selectedRoles.map(role=>{
     const selected=rolePreference(config,role),name='apk-'+role;
     const {description,prompt}=ROLE_DEFINITIONS.find(value=>value.id===role);
-    if(client==='codex') return Object.entries({name,description,model:selected.model,...(selected.effort===null?{}:{model_reasoning_effort:selected.effort}),developer_instructions:prompt}).map(([k,v])=>`${k} = ${JSON.stringify(v)}\n`).join('');
+    if(client==='chatgpt') return Object.entries({name,description,model:selected.model,...(selected.effort===null?{}:{model_reasoning_effort:selected.effort}),developer_instructions:prompt}).map(([k,v])=>`${k} = ${JSON.stringify(v)}\n`).join('');
     const fields=[`name: ${name}`,`description: ${JSON.stringify(description)}`];
     // Grok selects the model from config.toml [subagents.models]; read-only roles use the bundled plan permission mode.
     if(client==='grok') {
@@ -47,18 +47,18 @@ export function instructionBlock(client,config,maxConcurrent,selectedRoles=ROLE_
     for(const role of selectedRoles) {const selected=rolePreference(config,role);text.push(`For apk-${role}, select pool alias ${selected.model} (effort ${selected.effort??'native default'}).`);}
     text.push('Roles sharing an alias share its native effort default; an explicit effort pin for that alias also affects its native-default roles.');
     text.push("Use the Agent tool's model selection when spawning; the role file alone does not select a model. The concurrency limit is guidance; no native Agent cap is configured.");
-  } else if(client==='agy') {
+  } else if(client==='gemini') {
     for(const role of selectedRoles)text.push(`When delegating to apk-${role}, use model tier ${rolePreference(config,role).model}.`);
     text.push('Per-role effort and a hard concurrency cap are not supported by the documented native agent settings.');
   }
   else if(client==='grok')text.push('Use the named role definitions for model selection. Per-role effort is not supported by the documented native agent settings; subagents use the main session effort. Explicit spawn settings and higher-priority instructions can supersede user defaults.');
   else if(client==='claude')text.push('Use the named role definitions for model and effort selection. Session, project, managed settings, environment overrides and some spawn paths can supersede these user defaults; the native cap applies to ordinary Agent-tool spawns with documented exceptions.');
   else text.push('Use the named role definitions for model and effort selection. Explicit spawn settings and higher-priority instructions can supersede user defaults.');
-  if(client==='codex'||client==='claude')text.push('An omitted role effort uses the native client default; it does not pin a level.');
+  if(client==='chatgpt'||client==='claude')text.push('An omitted role effort uses the native client default; it does not pin a level.');
   if(config.avoidModels.length)text.push(`Avoid these models when delegating: ${config.avoidModels.join(', ')}. This is routing guidance.`);
   text.push(END);
   return text.join('\n')+'\n';
 }
 export function nativeWarnings(client) {
-  return client==='kimi'?['kimi-concurrency-guidance-only','kimi-model-pool-routing-guidance']:client==='agy'?['agy-concurrency-guidance-only','agy-per-role-effort-unsupported']:client==='grok'?['grok-per-role-effort-unsupported','grok-native-precedence-limits']:client==='claude'?['claude-native-precedence-limits']:['codex-native-precedence-limits'];
+  return client==='kimi'?['kimi-concurrency-guidance-only','kimi-model-pool-routing-guidance']:client==='gemini'?['gemini-concurrency-guidance-only','gemini-per-role-effort-unsupported']:client==='grok'?['grok-per-role-effort-unsupported','grok-native-precedence-limits']:client==='claude'?['claude-native-precedence-limits']:['chatgpt-native-precedence-limits'];
 }

package/src/output.mjs

@@ -1,17 +1,17 @@
 import {PRESETS} from './release.mjs';
-const LABELS={codex:'Codex',claude:'Claude Code',kimi:'Kimi',agy:'Antigravity',grok:'Grok Build'};
+const LABELS={chatgpt:'ChatGPT',claude:'Claude',kimi:'Kimi',gemini:'Gemini',grok:'Grok'};
 const label=client=>LABELS[client]??'Tool';
 const code=value=>typeof value==='string'&&/^[A-Za-z][A-Za-z0-9_-]{0,127}$/.test(value)?value:'OPERATION_FAILED';
 const PRESET_LABELS=Object.fromEntries(PRESETS.map(entry=>[entry.id,entry.label]));
 const preset=value=>Object.hasOwn(PRESET_LABELS,value)?' · '+PRESET_LABELS[value]:'';
 const NOTES={
- 'codex-native-precedence-limits':'Project and explicit client settings can override these defaults.',
+ 'chatgpt-native-precedence-limits':'Project and explicit client settings can override these defaults.',
  'claude-native-precedence-limits':'Project and explicit client settings can override these defaults.',
  'kimi-concurrency-guidance-only':'Kimi: the concurrency limit is guidance.',
  'kimi-model-pool-routing-guidance':'Kimi: the parent selects the model alias for each role.',
- 'agy-concurrency-guidance-only':'Antigravity: the concurrency limit is guidance.',
- 'agy-per-role-effort-unsupported':'Antigravity: native tiers do not support per-role effort.',
- 'grok-per-role-effort-unsupported':'Grok Build: native agent settings do not support per-role effort.',
+ 'gemini-concurrency-guidance-only':'Gemini: the concurrency limit is guidance.',
+ 'gemini-per-role-effort-unsupported':'Gemini: native tiers do not support per-role effort.',
+ 'grok-per-role-effort-unsupported':'Grok: native agent settings do not support per-role effort.',
  'grok-native-precedence-limits':'Project and explicit client settings can override these defaults.',
  'kimi-catalog-alias-resolved':'Kimi: an existing matching model alias was selected.',
 };

package/src/policy.mjs

@@ -1,7 +1,7 @@
 import catalog from '../models/catalog.json' with {type:'json'};
 import {ROLES,ROLE_IDS,selectedRoleIds} from './roles.mjs';
 export {ROLES} from './roles.mjs';
-export const CLIENTS = Object.freeze(['codex', 'claude', 'kimi', 'agy', 'grok']);
+export const CLIENTS = Object.freeze(['chatgpt', 'claude', 'kimi', 'gemini', 'grok']);
 export const rolePreference=(config,role)=>config.roles?.[role]??config[ROLES[role]];
 export const NATIVE_EFFORTS=Object.freeze(Object.fromEntries(CLIENTS.map(client=>[client,Object.freeze([...catalog.clients[client].efforts])])));
 const identifier = /^[A-Za-z0-9][A-Za-z0-9._:@/\[\]-]{0,127}$/;
@@ -27,7 +27,7 @@ export function validatePolicy(value) {
     for (const selected of [config.code,config.light,...Object.values(config.roles??{})]) {
       object(selected,['model','effort']); model(selected.model);
       if (client === 'kimi' && selected.model === 'primary') invalid();
-      if(client==='agy'&&!['pro','flash','flash_lite','inherit'].includes(selected.model))invalid();
+      if(client==='gemini'&&!['pro','flash','flash_lite','inherit'].includes(selected.model))invalid();
       if(selected.effort!==null){
         if(!NATIVE_EFFORTS[client].includes(selected.effort))invalid();
         const known=catalog.clients[client].models.find(model=>model.id===selected.model);

package/src/release.mjs

@@ -4,7 +4,7 @@ import {validatePolicy} from './policy.mjs';
 
 export const PACKAGE_VERSION=JSON.parse(fs.readFileSync(new URL('../package.json',import.meta.url),'utf8')).version;
 const canonical=value=>Array.isArray(value)?value.map(canonical):value&&typeof value==='object'?Object.fromEntries(Object.keys(value).sort().map(key=>[key,canonical(value[key])])):value;
-export const PRESETS=Object.freeze([{id:'fast',label:'Light',description:'Light models for every role. Limits last longest.'},{id:'balanced',label:'Standard',description:'Stronger models for code, review, tests and docs. Fits most plans.'},{id:'quality',label:'Top-tier',description:'High-end models for most roles. Uses limits fastest.',topModels:Object.freeze({codex:'gpt-6-astra',claude:'claude-fable-5-1',kimi:'kimi-code/k3.1-pro'})}].map(Object.freeze));
+export const PRESETS=Object.freeze([{id:'fast',label:'Light',description:'Light models for every role. Limits last longest.'},{id:'balanced',label:'Standard',description:'Stronger models for code, review, tests and docs. Fits most plans.'},{id:'quality',label:'Top-tier',description:'High-end models for most roles. Uses limits fastest.',topModels:Object.freeze({chatgpt:Object.freeze({model:'gpt-6-astra',effort:'high'}),claude:Object.freeze({model:'claude-opus-5-5',effort:'xhigh'}),kimi:Object.freeze({model:'kimi-code/k3.1-pro',effort:'high'})})}].map(Object.freeze));
 export function presetPreferences(id='balanced'){
   if(!PRESETS.some(preset=>preset.id===id))throw Object.assign(new Error('Unknown preset.'),{code:'UNKNOWN_PRESET'});
   return validatePolicy(JSON.parse(fs.readFileSync(new URL(`../policies/${id}.json`,import.meta.url),'utf8')));

package/src/setup.mjs

@@ -4,7 +4,7 @@ import { nativeHomeConflict } from './native.mjs';
 import { PACKAGE_VERSION } from './release.mjs';
 import { CLIENTS } from './policy.mjs';
 
-const ERRORS = new Set(['INVALID_PRESET','INVALID_RELEASE','LEGACY_RUNTIME_RECEIPT','INVALID_CLIENT','INVALID_POLICY','INVALID_JSON','INVALID_TOML','UNSUPPORTED_CONFIG','UNSUPPORTED_TOML_STRUCTURE','UNSUPPORTED_TOML_VALUE','CODEX_CAP_ALIAS_CONFLICT','OWNERSHIP_CONFLICT','INVALID_RECEIPT','OWNED_DRIFT','INSTALLATION_CONFLICT','POLICY_CONFLICT','UNSAFE_PATH','UNSAFE_FILE','STALE_PLAN','RECOVERY_REQUIRED','ROLLBACK_CONFLICT','INVALID_PLAN','PLATFORM_UNSUPPORTED','INSTALL_LOCKED','INSTALL_FAILED','EACCES','EPERM','ENOENT','ENOSPC','EIO','EROFS']);
+const ERRORS = new Set(['INVALID_PRESET','INVALID_RELEASE','LEGACY_RUNTIME_RECEIPT','INVALID_CLIENT','INVALID_POLICY','INVALID_JSON','INVALID_TOML','UNSUPPORTED_CONFIG','UNSUPPORTED_TOML_STRUCTURE','UNSUPPORTED_TOML_VALUE','CHATGPT_CAP_ALIAS_CONFLICT','OWNERSHIP_CONFLICT','INVALID_RECEIPT','OWNED_DRIFT','INSTALLATION_CONFLICT','POLICY_CONFLICT','UNSAFE_PATH','UNSAFE_FILE','STALE_PLAN','RECOVERY_REQUIRED','ROLLBACK_CONFLICT','INVALID_PLAN','PLATFORM_UNSUPPORTED','INSTALL_LOCKED','INSTALL_FAILED','EACCES','EPERM','ENOENT','ENOSPC','EIO','EROFS']);
 const safeError = error => ERRORS.has(error?.code) ? error.code : 'SETUP_FAILED';
 function actions(client,warnings) {
   return warnings.map(code=>({client,code,automatable:false}));

package/src/share.mjs

@@ -47,7 +47,7 @@ function shareRelease(release){
  for(const preset of release.presets){
   shareRecord(preset);if(typeof preset.id!=='string'||!preset.id||preset.id==='custom'||SHARE_UNSAFE.has(preset.id)||presets.has(preset.id))invalidShare();
   shareRecord(shareRecord(preset.preferences).clients);
-  if(preset.topModels!==undefined&&Object.values(shareRecord(preset.topModels)).some(model=>typeof model!=='string'))invalidShare();
+  if(preset.topModels!==undefined)for(const top of Object.values(shareRecord(preset.topModels))){shareRecord(top,['model','effort']);if(typeof top.model!=='string'||(top.effort!==null&&typeof top.effort!=='string'))invalidShare();}
   presets.set(preset.id,preset);
  }
  if(!presets.has(release.preset))invalidShare();
@@ -55,7 +55,7 @@ function shareRelease(release){
 }
 function shareChoice(choice,id,metadata){
  shareRecord(choice,['model','effort']);
- if(typeof choice.model!=='string'||choice.model.length>128||(choice.effort!==null&&(['agy','grok'].includes(id)||!metadata.catalog[id].efforts.includes(choice.effort))))invalidShare();
+ if(typeof choice.model!=='string'||choice.model.length>128||(choice.effort!==null&&(['gemini','grok'].includes(id)||!metadata.catalog[id].efforts.includes(choice.effort))))invalidShare();
  return {model:choice.model,effort:choice.effort};
 }
 function sharePayload(payload,release,metadata){
@@ -93,12 +93,12 @@ function sharePayload(payload,release,metadata){
    if(!legacy&&tool.maxConcurrent!==(clients[id]?.maxConcurrent??preset.maxConcurrent))invalidShare();
    if(!Object.hasOwn(clients,id))invalidShare();
    const preferences=shareRecord(clients[id]),own=role=>preferences.roles&&Object.hasOwn(preferences.roles,role);
-   // A preset's optional top model replaces every shared code role that has no role-specific choice, or none of them.
+   // A preset's optional top choice (model and effort) replaces every shared code role that has no role-specific choice, or none of them.
    const top=named.topModels&&Object.hasOwn(named.topModels,id)?named.topModels[id]:null;
-   const topRoles=roles.filter(role=>metadata.roles.get(role).kind==='code'&&!own(role)),topped=top!==null&&topRoles.some(role=>choices[role].model===top);
+   const topRoles=roles.filter(role=>metadata.roles.get(role).kind==='code'&&!own(role)),topped=top!==null&&topRoles.some(role=>choices[role].model===top.model&&choices[role].effort===top.effort);
    for(const role of roles){
     const expected=own(role)?preferences.roles[role]:preferences[metadata.roles.get(role).kind];
-    const choice=shareChoice(expected,id,metadata);if(topped&&topRoles.includes(role))choice.model=top;
+    const choice=shareChoice(expected,id,metadata);if(topped&&topRoles.includes(role)){choice.model=top.model;choice.effort=top.effort;}
     if(choice.model!==choices[role].model||choice.effort!==choices[role].effort)invalidShare();
    }
   }

package/docs/architecture.md

@@ -1,17 +0,0 @@
-# Architecture
-
-APK runs only for configuration commands. It detects installed CLIs, reads release/custom preferences, writes native files and exits. Native agent operation never imports or launches APK.
-
-One npm version is one configuration release. src/release.mjs exposes its presets, catalog date and notes. policies contains Light/Standard/Top-tier data (ids fast/balanced/quality); models/catalog.json is the dated native model/effort snapshot. The self-contained page is generated from that same version and data. src/explicit.mjs supplies the pure command codec to Node and is embedded in the page at build time. Commands always expand selected role values, even for presets. The CLI converts complete maps to normal validated policy. Required code/light fallbacks copy the first explicit role and are unused by the complete per-role map. No browser/backend/provider request is needed to compose a command.
-
-src/share.mjs validates and encodes the visible form state into the URL fragment. It never runs native operations or stores clipboard history. The page restores only release-compatible state, then applies normal command validation.
-
-src/roles.mjs supplies the shared role descriptions/prompts for the page and native generation. src/policy.mjs validates code/light defaults, optional selectedRoles and per-client role overrides. Native generation uses selected roles only. The first selected role in catalog order supplies the native subagent default. Effort null means no explicit pin. Documented levels depend on model and client. Selected Kimi aliases merge explicit effort and resolve only to provisioned entries. Ambiguity fails without writes.
-
-The fixed native role filenames remain apk-worker/reviewer/explorer/tester/writer/routine. Their presence does not require delegation. The main agent decides whether helpers are useful; main models and disabled features are preserved.
-
-Receipt v4 stores the selected role set, bounded ownership snapshots and actual release/source/preset provenance. It verifies that the owned file set matches selectedRoles. Inspection/removal checks old hashes, blocks and typed operations without current templates or catalog validation. Historical v3 and v2 native snapshots remain supported. v2 has unknown release provenance. Unsupported layouts/runtime receipts are refused.
-
-Explicit replacement virtually undoes owned changes to the original user baseline, renders the target, and commits final changes against actual current preimages. The existing transaction protects complete read dependencies, locks, staging, rollback and competing edits. Final uninstall restores original user values and keeps unrelated later edits. Receipts are applied truth; canonical policy is the latest requested snapshot. Per-client partial outcomes are explicit.
-
-There is one TOML parser dependency and no CLI compilation. The static page's data injection is a deterministic release-preparation step. Generated native files have no package/source/state dependency; npm package removal does not remove saved native settings.

package/docs/compatibility.md

@@ -1,23 +0,0 @@
-# Native configuration support
-
-| Client | Written native configuration | Limits |
-|---|---|---|
-| Codex | User role TOMLs, native subagent defaults/concurrency, routing instructions | Higher-priority project/explicit settings still follow Codex rules |
-| Claude Code | User role Markdown with model/effort, native default/concurrency env, routing instructions | Force settings and native execution-path exceptions can override the intended mapping |
-| Kimi Code | User role Markdown, existing secondary-model pool, per-alias effort, routing instructions | Model-role selection and max concurrency are guidance; provisioned aliases/capabilities are required |
-| Antigravity | User role Markdown with Pro/Flash/Flash Lite/inherit tiers and routing instructions | No concrete provider pin, documented per-role effort, or universal native max-three cap |
-| Grok Build | User role Markdown (read-only roles use permission_mode plan), per-role models and a general-purpose fallback in config.toml, native max_concurrent, routing instructions | No documented per-role effort; subagents use the main session effort. Higher-priority project/explicit settings still follow Grok Build rules |
-
-These are preferences implemented through native features. APK does not participate in later agent operation and does not enforce policy on every request. avoidModels is guidance. No hook, wrapper or proxy is installed to bypass native limits.
-
-Global configuration can be superseded by a project's native settings, session flags, environment or plugins. A fresh client session may be needed. Configured files, native loading and actual provider model execution are separate evidence.
-
-macOS is the local acceptance host. Linux has a source-isolation gate using bubblewrap and a hosted workflow prepared; hosted runs are pending. Windows application is explicitly unsupported.
-
-Primary references checked for this design:
-
-- [Codex native subagents](https://learn.chatgpt.com/docs/agent-configuration/subagents).
-- [Claude native subagents](https://code.claude.com/docs/en/sub-agents).
-- [Kimi configuration](https://github.com/MoonshotAI/kimi-code/blob/main/docs/en/configuration/config-files.md) and [agent definitions](https://github.com/MoonshotAI/kimi-code/blob/main/docs/en/customization/agents.md).
-- [Antigravity native subagents](https://antigravity.google/docs/subagents?tab=cli).
-- [Grok Build subagents](https://github.com/xai-org/grok-build/blob/main/crates/codegen/xai-grok-pager/docs/user-guide/16-subagents.md), observed with Grok Build 1.0.70 and an isolated GROK_HOME.

package/docs/configuration-page.md

@@ -1,44 +0,0 @@
-# Configuration page
-
-Open site/index.html in Google Chrome. The page is one self-contained HTML file. It has no backend, telemetry, asset requests or native account access. It embeds this release's model catalog, presets, role definitions, getacc.dev palette and licensed Public Sans font.
-
-## Four steps
-
-1. Add the subagent roles you need. A green check confirms a nonempty role selection. Each question-mark button explains its description and native prompt. Removing a role also removes its configuration rows. Readding it preserves its choices in the current page session.
-2. Add your coding tools. A green check confirms a nonempty tool selection. New tools append to the list. The first becomes active. From the second onward, All is active by default. A manually selected tool or All stays active during later additions. All configures the selected tools together. The CLI, not the browser, detects which selected tools are installed.
-3. Choose a work mode. No mode is selected initially. Each selected tool needs a chosen mode before the command becomes available. The first choice has no replacement warning. Individual tool details show every selected role's model and supported effort, followed by that tool's parallel limit. The shared All view hides these controls. All offers shared presets. Custom can be selected manually and is also set by model or effort edits. Each tool shows its own mode beneath its name. Individual presets warn before changing that tool. Replacing genuinely edited values, mixed per-tool bases or partially chosen modes from All warns before changing all selected tools. Selecting Custom alone without changing values does not create an overwrite warning. Cancel preserves the choices.
-4. Copy the setup command and run it in a terminal. Incomplete selections identify the missing steps with links. Invalid model settings or per-tool limits disable copying and clear the previous command. Clipboard failure selects the full command for manual copying.
-
-The page starts with every subagent role selected and no coding tool. A completed third step requires selected modes and valid model settings. A fourth green check means the current command was successfully copied, not installed. Configuration changes clear that check; opening another tool without changing values preserves it. Reset form clears selections, modes, copy status and the URL fragment without changing any installed native files. Light uses 2 parallel subagents, Standard uses 3 and Top-tier uses 2. Selecting a preset restores its models, effort and parallel limit for the targeted tools. Editing a limit marks only that tool Custom. Effort buttons fill their section and show supported explicit levels. A dash means no native effort setting. Unpinned values remain unpinned until changed. Kimi roles sharing a model alias share its effort. Antigravity offers only native tiers. Other tools also accept custom native model IDs, subject to CLI and account support.
-
-The command is pinned to this page's package version. It always expands every selected tool and role into visible model/effort arguments. Presets fill the form but do not shorten or hide the command. Tools follow their selected order. --roles carries the selected role IDs and --max-concurrent carries the shared fallback. Optional --codex-max-concurrent, --claude-max-concurrent, --kimi-max-concurrent and --antigravity-max-concurrent carry independent overrides. Nonempty --avoid-TOOL lists preserve existing model-avoidance guidance. Omitted tools are not configured.
-
-Each tool uses role=model:effort entries. :native means no explicit effort pin. Antigravity uses role=tier and Grok Build uses role=model, both without an effort suffix. The parser splits at the last colon, preserving model IDs that contain colons or @. Every selected role must be present exactly once for every selected tool. The generated command reports custom provenance because its values are explicit, even when a preset filled the form.
-
-The complete command is visible in a read-only field that grows to fit its contents. Copy preserves the visible POSIX shell line continuations. Soft wrapping adds no additional newlines. [Native field sizing](https://developer.chrome.com/docs/css-ui/css-field-sizing) handles content and window-size changes without a JavaScript resize helper. The page never executes the command or grants model access.
-
-Role/tool changes use native View Transitions with a reduced-motion setting and a synchronous fallback. Section hints are conditional: role guidance after selection, add-more guidance for one tool, individual-configuration guidance for two or more tools, mode guidance when available, and Copied in the fourth heading. Changed hints, step markers, editing-scope labels and per-tool mode captions hold a soft highlight for two seconds, then fade for two seconds. Tool-caption nodes are reused so switching the editing view does not interrupt a pulse. Identical state does not repeat the animation. Labels retain their size during layout changes. No animation dependency is installed.
-
-## Share a setup
-
-The Max at once field appears only in individual coding-tool details. It accepts whole numbers from 1 to 32. Each tool retains its own limit while switching the editing view. Model-preset selection restores that tool's preset limit. Invalid selected-tool limits block the command and copy action. Invalid cached settings on unselected tools do not block selected tools. Kimi and Antigravity use the value as guidance rather than a native hard cap.
-
-Each form edit replaces the current URL fragment with its visible state. Copy the page address to share it. Version 2 fragments contain roles, tool order, mode/base, selected model/effort pairs, each tool's limit and editing scope. Version 1 scalar-limit links remain readable. Their exact count is preserved; a count that differs from the current preset makes the restored tool Custom. It excludes clipboard completion and unselected cached choices. Opening a link restores the form, including unfinished choices and model drafts. Command validation still blocks incomplete or invalid settings.
-
-src/share.mjs is the pure browser/Node codec. It uses versioned base64url JSON with strict IDs, fields, duplicate-key, size, UTF-8 and release checks. The fragment stays in the browser and needs no database or config lookup service. Invalid or mismatched-release links show an error and cannot produce an applicable command. Missing-step links scroll/focus without overwriting the setup fragment.
-
-Public friend links require this static page to be hosted, for example on getacc.dev. A local file URL is machine-local; localhost acceptance proves restoration behavior, not public deployment. Each published release should retain its versioned page so old links can use the matching release.
-
-## Build and host
-
-Run npm run build:site after changing the template, shared CSS, role definitions, command codec, version, presets, catalog or changelog. npm run check rejects a stale generated page. Source assets are in site/template.html, site/base.css and site/fonts/. src/explicit.mjs supplies the same pure codec to the CLI and page. The generated HTML needs no server or build step to open.
-
-Serve site/index.html from any static host. It can become part of getacc.dev without a service or proxy. Publish immutable pages at versioned release paths. A latest landing URL can point to the current one. Set repository/homepage URLs only after the owner creates them.
-
-The current version is unreleased. Its page labels that status. Before npm publication, use the verified local tarball as described in the [AI operator guide](../AGENT_INSTALL.md). The checks do not publish or deploy anything.
-
-The introduction includes a collapsed “How it works and why you need it” explanation aligned with the README. Native details/summary supports keyboard toggling; opening/closing takes 200 ms and honors reduced motion. The hosted versioned URL preserves release-specific shared links.
-
-The footer credits Mykola Maksymenko and links to his supplied LinkedIn profile, Agents Can Communicate and Automatis Skills. Package author metadata is the source for the visible byline, title, author tags and static JSON-LD Person/project/page relationship. The canonical URL follows the homepage origin and bundled release version. These links load only when followed; no social widgets or runtime metadata requests are added.
-
-The latest hosted root can update its interface and author metadata from reviewed main independently of npm publication. Published versioned pages remain exact snapshots. Configuration-sensitive changes must match a published package before the host build accepts them. See [deployment](deployment.md).