agent-policy-kit 0.2.0 → 0.3.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);
@@ -132,14 +132,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 +154,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 +179,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';
@@ -155,7 +155,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 +185,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');
@@ -389,8 +389,8 @@ 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');
     }

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:'gpt-6-astra',claude:'claude-fable-5-1',kimi:'kimi-code/k3.1-pro'})}].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

@@ -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){