agent-policy-kit 0.1.0 → 0.3.0

package/src/output.mjs

@@ -0,0 +1,108 @@
+import {PRESETS} from './release.mjs';
+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={
+ '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.',
+ '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.',
+};
+const REASONS={
+ OWNED_DRIFT:'Local edits prevent an update',
+ 'kimi-provisioned-models-required':'Required model aliases are missing',
+ 'native-home-override-unsupported':'The active client profile uses a nonstandard location',
+ 'client-not-selected':'This tool is not selected in the configuration',
+ 'claude-force-model-conflict':'A forced model conflicts with the selected roles',
+ 'kimi-supported-effort-required':'A selected alias does not declare the required effort support',
+ 'kimi-main-effort-conflict':'The requested effort would change the main model defaults',
+ 'kimi-thinking-disabled':'Thinking is disabled for a model that requires it',
+ 'kimi-mixed-native-default-effort':'A shared effort override conflicts with native-default roles',
+ 'kimi-catalog-alias-ambiguous':'More than one existing model alias matches',
+ 'kimi-resolved-model-avoided':'The matching alias is on the avoid list',
+ 'kimi-resolved-effort-conflict':'Roles sharing an alias request conflicting effort levels',
+ INSTALLATION_CONFLICT:'Installed preferences differ from this request',
+ POLICY_CONFLICT:'Saved preferences differ from this request',
+ RECOVERY_REQUIRED:'An interrupted transaction requires recovery',
+ INSTALL_LOCKED:'Another configuration operation holds the lock',
+};
+export const useJsonOutput=({isTTY,json=false}={})=>json||!isTTY;
+function reason(value){const id=code(value);return (REASONS[id]??'Configuration could not be completed')+` (${id})`;}
+function row(client,text,mark='✓'){return `${mark} ${label(client).padEnd(14)} ${text}`;}
+function setup(result,{apply}){
+ const results=result.results??[],failed=results.some(r=>['error','prerequisite','invalid','timeout'].includes(r.status));
+ const changed=results.filter(r=>r.status==='configured');
+ const heading=failed?'Setup incomplete':result.status==='no_clients'?'No supported selected tools found':!apply?'Preview · no files changed':changed.length?'Configuration applied':'Already up to date';
+ const lines=[heading,''],missing=[],notes=new Set();
+ for(const r of results){
+  if(r.status==='not_selected')continue;
+  if(r.status==='not_found'){missing.push(label(r.client));continue;}
+  const warnings=r.warnings??r.plan?.warnings??[];
+  let text,mark='✓';
+  if(r.status==='configured')text='Configuration applied'+preset(r.appliedPreset);
+  else if(r.status==='unchanged'||r.status==='planned'&&r.plan?.files?.length===0)text='Already up to date'+preset(r.appliedPreset);
+  else if(r.status==='planned'){text='Would configure'+preset(r.targetPreset);mark='·';}
+  else if(r.status==='invalid'){text='Client executable identity could not be verified';mark='!';}
+  else if(r.status==='timeout'){text='Client detection timed out';mark='!';}
+  else {text=reason(r.error??warnings[0]);mark='!';}
+  lines.push(row(r.client,text,mark));
+  if(r.status==='prerequisite'&&r.appliedReleaseVersion&&/^\d+\.\d+\.\d+(?:[-+][A-Za-z0-9.-]+)?$/.test(r.appliedReleaseVersion))lines.push(`  Existing configuration retained · ${r.appliedReleaseVersion}${preset(r.appliedPreset)}`);
+  if(['configured','unchanged','planned'].includes(r.status))for(const warning of warnings)notes.add(NOTES[warning]??`Client note: ${code(warning)}`);
+ }
+ if(missing.length)lines.push(`Skipped: ${missing.join(', ')} — not installed.`);
+ if(changed.length)lines.push('',`Open a new session in ${changed.map(r=>label(r.client)).join(', ')} to load the changes.`);
+ if(results.some(r=>r.error==='OWNED_DRIFT'))lines.push('Review local edits before retrying; APK will not overwrite them.');
+ if(results.some(r=>(r.warnings??r.plan?.warnings??[]).includes('kimi-provisioned-models-required')))lines.push('Configure the selected model aliases in Kimi, then run the same command again.');
+ if(notes.size)lines.push('',...notes);
+ lines.push('Native configuration only; model execution was not checked.');
+ return lines;
+}
+function uninstall(result,{apply}){
+ const results=result.results??(result.client?[result]:[]);
+ const lines=[!apply?'Preview · no files changed':result.status==='partial'?'Removal incomplete':result.status==='not_installed'?'Nothing to remove':'Configuration removal',''];
+ for(const r of results){const bad=r.status==='error';lines.push(row(r.client,bad?reason(r.error):r.status==='unchanged'||r.files?.length===0?'Nothing to remove':apply?'Configuration removed':'Would remove',bad?'!':apply?'✓':'·'));}
+ return lines;
+}
+const setting=value=>typeof value==='string'&&/^[A-Za-z0-9][A-Za-z0-9 _.:@/\[\]-]{0,127}$/.test(value)?value:'native default';
+function show(result){
+ const lines=['User configuration · subagents',''];
+ for(const[id,c]of Object.entries(result.clients??{})){
+  lines.push(`${label(id)}${c.status==='attention'?' · incomplete read':c.status==='not_configured'?' · no explicit subagent settings':''}`);
+  if(c.status!=='not_configured'){
+   if(c.defaults.enabled===false)lines.push('  Subagents explicitly disabled.');
+   lines.push(`  Default model: ${setting(c.defaults.model)} · effort: ${setting(c.defaults.effort)}`);
+   lines.push(`  Max concurrent: ${Number.isSafeInteger(c.concurrency.value)?c.concurrency.value:'not explicitly set'}${c.concurrency.kind==='guidance'?' (guidance)':' (native setting)'}`);
+   for(const role of c.roles)lines.push(`  ${setting(role.name).padEnd(22)} ${setting(role.model)} · ${setting(role.effort)}${role.modelSelection==='guidance'?' (routing guidance)':role.modelSelection==='parent'?' (parent selects model)':''}${role.enabled===false?' (delegation disabled)':''}`);
+   for(const entry of c.pool)lines.push(`  Pool: ${setting(entry.alias)} · ${setting(entry.effort)}${entry.configured?'':' · alias not provisioned'}`);
+   for(const[field,value]of Object.entries(c.overrides??{}))lines.push(`  Override ${field}: ${typeof value==='boolean'?String(value):typeof value==='number'?value:setting(value)}`);
+  }
+  if(c.apk.status==='modified')lines.push('  APK-managed files have local edits; the values above come from current files.');
+  for(const warning of c.warnings)lines.push(`  ! ${code(warning)}`);
+  lines.push('');
+ }
+ lines.push('User-level files only; project, managed and session settings may override them.','Native configuration only; model execution was not checked.');
+ return lines;
+}
+export function formatResult(command,result,{version='',apply=false}={}){
+ let lines;
+ if(result.error)lines=[`Operation failed (${code(result.error)})`];
+ else if(command==='setup'||command==='install')lines=setup(result,{apply});
+ else if(command==='uninstall')lines=uninstall(result,{apply});
+ else if(command==='show')lines=show(result);
+ else if(command==='init')lines=['Preferences created.'];
+ else if(command==='detect')lines=result.map(r=>row(r.client,r.status==='detected'?`Detected${typeof r.version==='string'&&/^[0-9A-Za-z.+-]{1,128}$/.test(r.version)?' · '+r.version:''}`:r.status==='not_found'?'Not installed':r.status==='timeout'?'Detection timed out':'Identity unverified',r.status==='detected'?'✓':r.status==='not_found'?'·':'!'));
+ else if(command==='doctor'){
+  lines=['Configuration check',''];
+  for(const[client,r]of Object.entries(result.clients??{})){const c=r.configuration;lines.push(row(client,c.status==='verified'?`Verified${preset(c.preset)}`:c.status==='not_configured'?'Not configured':reason(c.reason),c.status==='attention'?'!':c.status==='verified'?'✓':'·'));}
+  lines.push('Native configuration only; model execution was not checked.');
+ }else if(command==='release')lines=[`Configuration release ${/^\d+\.\d+\.\d+(?:[-+][A-Za-z0-9.-]+)?$/.test(result.version)?result.version:''}${preset(result.preset)}`,'','Use setup --release to preview; add --apply to configure.'];
+ else lines=['Operation completed.'];
+ return [`Agent Policy Kit${/^\d+\.\d+\.\d+(?:[-+][A-Za-z0-9.-]+)?$/.test(version)?' · '+version:''}`,'',...lines].join('\n')+'\n';
+}

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']);
+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}$/;
@@ -21,12 +21,13 @@ export function validatePolicy(value) {
   object(value.clients,CLIENTS);
   if (!Object.keys(value.clients).length) invalid();
   for (const [client,config] of Object.entries(value.clients)) {
-    object(config,['code','light','roles','avoidModels']);
+    object(config,['code','light','roles','avoidModels','maxConcurrent']);
+    if(config.maxConcurrent!==undefined&&(!Number.isInteger(config.maxConcurrent)||config.maxConcurrent<1||config.maxConcurrent>32))invalid();
     if(config.roles!==undefined)object(config.roles,Object.keys(ROLES));
     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:'Fast & economical',description:'For small, well-defined tasks. Lighter models, with extra reasoning for review and tests.'},{id:'balanced',label:'Balanced',description:'Stronger coding and verification, lighter exploration and mechanical work.'},{id:'quality',label:'Quality first',description:'For demanding implementation and verification. Prioritizes capability over response time and usage.'}].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

@@ -1,6 +1,6 @@
 // Pure URL state codec, also embedded in the offline configuration page.
 const SHARE_BYTES=65536,SHARE_TOKEN=87384;
-const SHARE_VERSION=/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
+const SHARE_VERSION=/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*))*)?$/;
 const SHARE_UNSAFE=new Set(['__proto__','constructor','prototype']);
 function invalidShare(){throw Object.assign(new Error('Invalid shared configuration link.'),{code:'INVALID_SHARE_LINK'});}
 
@@ -46,46 +46,67 @@ 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);presets.set(preset.id,preset);
+  shareRecord(shareRecord(preset.preferences).clients);
+  if(preset.topModels!==undefined&&Object.values(shareRecord(preset.topModels)).some(model=>typeof model!=='string'))invalidShare();
+  presets.set(preset.id,preset);
  }
  if(!presets.has(release.preset))invalidShare();
  return {clients,roles,presets,catalog};
 }
 function shareChoice(choice,id,metadata){
  shareRecord(choice,['model','effort']);
- if(typeof choice.model!=='string'||choice.model.length>128||(choice.effort!==null&&(id==='agy'||!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){
- shareRecord(payload,['v','release','roles','tools','scope','maxConcurrent']);
- if(payload.v!==1||typeof payload.release!=='string'||!SHARE_VERSION.test(payload.release))invalidShare();
- if(payload.release!==release.version)throw Object.assign(new Error('This link uses a different release.'),{code:'SHARE_RELEASE_MISMATCH'});
- if(!Number.isInteger(payload.maxConcurrent)||payload.maxConcurrent<1||payload.maxConcurrent>32)invalidShare();
+ shareRecord(payload);const legacy=payload.v===1;
+ if(!legacy&&payload.v!==2)invalidShare();
+ shareRecord(payload,legacy?['v','release','roles','tools','scope','maxConcurrent']:['v','release','roles','tools','scope']);
+ if(typeof payload.release!=='string'||payload.release.length>128||!SHARE_VERSION.test(payload.release))invalidShare();
+ if(legacy&&(!Number.isInteger(payload.maxConcurrent)||payload.maxConcurrent<1||payload.maxConcurrent>32))invalidShare();
+ if(payload.release!==release.version){
+  // Validate the wire shape without imposing today's models or preset values on
+  // an older release. Invalid links must never turn into navigation.
+  const identifier=value=>typeof value==='string'&&/^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/.test(value);
+  if(!Array.isArray(payload.roles)||payload.roles.length>1000||payload.roles.some(role=>!identifier(role)))invalidShare();
+  const roles=shareList(payload.roles,payload.roles),ids=[];
+  if(!Array.isArray(payload.tools)||payload.tools.length>32)invalidShare();
+  for(const tool of payload.tools){
+   shareRecord(tool,legacy?['id','mode','base','choices']:['id','mode','base','choices','maxConcurrent']);if(!legacy&&(!Number.isInteger(tool.maxConcurrent)||tool.maxConcurrent<1||tool.maxConcurrent>32))invalidShare();if(!identifier(tool.id)||ids.includes(tool.id)||!identifier(tool.base)||(tool.mode!==null&&!identifier(tool.mode)))invalidShare();ids.push(tool.id);
+   shareRecord(tool.choices,roles);for(const role of roles){const choice=shareRecord(tool.choices[role],['model','effort']);if(typeof choice.model!=='string'||choice.model.length>128||(choice.effort!==null&&(typeof choice.effort!=='string'||choice.effort.length>32)))invalidShare();}
+  }
+  if(payload.scope!==null&&(typeof payload.scope!=='string'||(payload.scope==='all'?ids.length<2:!ids.includes(payload.scope))))invalidShare();
+  throw Object.assign(new Error('This link uses a different release.'),{code:'SHARE_RELEASE_MISMATCH',releaseVersion:payload.release});
+ }
  const roles=shareList(payload.roles,[...metadata.roles.keys()]);
  if(!Array.isArray(payload.tools)||payload.tools.length>metadata.clients.length)invalidShare();
  const selected=[];
  const tools=payload.tools.map(tool=>{
-  shareRecord(tool,['id','mode','base','choices']);
+  shareRecord(tool,legacy?['id','mode','base','choices']:['id','mode','base','choices','maxConcurrent']);if(!legacy&&(!Number.isInteger(tool.maxConcurrent)||tool.maxConcurrent<1||tool.maxConcurrent>32))invalidShare();
   const {id,mode,base}=tool;
   if(!metadata.clients.includes(id)||selected.includes(id)||!metadata.presets.has(base)||(mode!==null&&mode!=='custom'&&!metadata.presets.has(mode)))invalidShare();
   selected.push(id);shareRecord(tool.choices,roles);
   const choices=Object.fromEntries(roles.map(role=>[role,shareChoice(tool.choices[role],id,metadata)]));
   if(mode!==null&&mode!=='custom'){
    if(mode!==base)invalidShare();
-   const clients=metadata.presets.get(mode).preferences.clients;
+   const named=metadata.presets.get(mode),preset=named.preferences,clients=preset.clients;
+   if(!legacy&&tool.maxConcurrent!==(clients[id]?.maxConcurrent??preset.maxConcurrent))invalidShare();
    if(!Object.hasOwn(clients,id))invalidShare();
-   const preferences=shareRecord(clients[id]);
+   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.
+   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);
    for(const role of roles){
-    const expected=preferences.roles&&Object.hasOwn(preferences.roles,role)?preferences.roles[role]:preferences[metadata.roles.get(role).kind];
-    const choice=shareChoice(expected,id,metadata);
+    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;
     if(choice.model!==choices[role].model||choice.effort!==choices[role].effort)invalidShare();
    }
   }
-  return {id,mode,base,choices};
+  return {id,mode,base,choices,...(legacy?{}:{maxConcurrent:tool.maxConcurrent})};
  });
  const scope=payload.scope;
  if(scope!==null&&(typeof scope!=='string'||(scope==='all'?tools.length<2:!selected.includes(scope))))invalidShare();
- return {v:1,release:payload.release,roles,tools,scope,maxConcurrent:payload.maxConcurrent};
+ return {v:payload.v,release:payload.release,roles,tools,scope,...(legacy?{maxConcurrent:payload.maxConcurrent}:{})};
 }
 function shareBase64(bytes){return btoa(Array.from(bytes,byte=>String.fromCharCode(byte)).join('')).replaceAll('+','-').replaceAll('/','_').replace(/=+$/,'');}
 function shareJson(text){
@@ -111,15 +132,16 @@ export function encodeFormState(snapshot,release){
   shareData(snapshot);shareRecord(snapshot);
   const metadata=shareRelease(release),state=shareRecord(snapshot.state),profiles=shareRecord(state.profiles),jobs=shareRecord(state.jobs);
   const roles=shareList(snapshot.helpers,[...metadata.roles.keys()]),selected=shareList(snapshot.pickedTools,metadata.clients);
+  const modern=Object.values(profiles).some(profile=>Object.hasOwn(profile,'maxConcurrent'));
   const tools=selected.map(id=>{
    if(!Object.hasOwn(profiles,id)||!Object.hasOwn(jobs,id))invalidShare();
    const profile=shareRecord(profiles[id]),choices=shareRecord(jobs[id]);
    if(typeof profile.custom!=='boolean'||(profile.modeSelected!==undefined&&typeof profile.modeSelected!=='boolean'))invalidShare();
-   return {id,mode:profile.modeSelected===false?null:profile.custom?'custom':profile.presetId,base:profile.presetId,choices:Object.fromEntries(roles.map(role=>{
+   return {id,...(modern?{maxConcurrent:Object.hasOwn(profile,'maxConcurrent')?profile.maxConcurrent:state.maxConcurrent}:{}),mode:profile.modeSelected===false?null:profile.custom?'custom':profile.presetId,base:profile.presetId,choices:Object.fromEntries(roles.map(role=>{
     if(!Object.hasOwn(choices,role))invalidShare();return [role,shareChoice(choices[role],id,metadata)];
    }))};
   });
-  const payload=sharePayload({v:1,release:release.version,roles,tools,scope:snapshot.selectedScope,maxConcurrent:state.maxConcurrent},release,metadata);
+  const payload=sharePayload({v:modern?2:1,release:release.version,roles,tools,scope:snapshot.selectedScope,...(modern?{}:{maxConcurrent:state.maxConcurrent})},release,metadata);
   if(!roles.length&&!tools.length)return '';
   const bytes=new TextEncoder().encode(JSON.stringify(payload));if(bytes.length>SHARE_BYTES)invalidShare();
   const token=shareBase64(bytes);if(token.length>SHARE_TOKEN)invalidShare();return '#setup='+token;
@@ -139,3 +161,12 @@ export function decodeFormState(fragment,release){
   return sharePayload(payload,release,shareRelease(release));
  }catch(error){if(error?.code==='INVALID_SHARE_LINK'||error?.code==='SHARE_RELEASE_MISMATCH')throw error;invalidShare();}
 }
+
+export function archivedReleaseUrl(error,href,hostedReleases=[]){
+ if(error?.code!=='SHARE_RELEASE_MISMATCH'||typeof error.releaseVersion!=='string'||error.releaseVersion.length>128||!SHARE_VERSION.test(error.releaseVersion)||!Array.isArray(hostedReleases)||!hostedReleases.includes(error.releaseVersion))return null;
+ try{
+  const current=new URL(href);if(!['http:','https:'].includes(current.protocol)||current.username||current.password||current.pathname!=='/'||!current.hash.startsWith('#setup='))return null;
+  const target=new URL(`/v/${error.releaseVersion}/`,current.origin);target.hash=current.hash;
+  return target.origin===current.origin?target.href:null;
+ }catch{return null;}
+}