@yunhozz/arc 0.2.3 → 0.2.5

package/codex/skill/scripts/model_config.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import copy
 import json
 import re
 import tomllib
@@ -77,10 +78,14 @@ PRESETS = ("economy", "balanced", "smart")
 
 
 def validate_config(config: dict, path: Path) -> dict:
-    if not isinstance(config, dict) or set(config) != {"version", "preset", "roles"} or type(config["version"]) is not int or config["version"] != 1:
-        raise _error(path, "settings", "update to version 1 unified presets; reinstall ARC or edit models.toml to include preset and all role presets")
-    if not isinstance(config["preset"], str) or config["preset"] not in PRESETS:
-        raise _error(path, "preset", "must be economy, balanced or smart")
+    if not isinstance(config, dict) or type(config.get("version")) is not int or config["version"] not in (1, 2):
+        raise _error(path, "settings", "update to version 1 or 2 unified presets; reinstall ARC or edit models.toml to include preset and all role presets")
+    has_custom = "custom" in config
+    allowed = {"version", "preset", "roles"} | ({"custom"} if config["version"] == 2 and has_custom else set())
+    if set(config) != allowed:
+        raise _error(path, "settings", "update to version 1 or 2 unified presets; reinstall ARC or edit models.toml to include preset and all role presets")
+    if not isinstance(config["preset"], str) or config["preset"] not in (*PRESETS, "custom") or (config["preset"] == "custom" and not has_custom):
+        raise _error(path, "preset", "must select an available preset")
     roles = config["roles"]
     if not isinstance(roles, dict) or set(roles) != set(ROLE_FILES):
         raise _error(path, "roles", "must define exactly the five ARC roles")
@@ -89,24 +94,38 @@ def validate_config(config: dict, path: Path) -> dict:
             raise _error(path, f"roles.{role}", "must contain exactly economy, balanced and smart")
         for preset, values in variants.items():
             _settings_for_profile(values, f"{role}.{preset}", path)
-    return config
+    if has_custom:
+        custom = config["custom"]
+        if not isinstance(custom, dict) or set(custom) != set(ROLE_FILES):
+            raise _error(path, "custom", "must define exactly the five ARC roles")
+        for role, values in custom.items():
+            _settings_for_profile(values, f"custom.{role}", path)
+    result = copy.deepcopy(config)
+    result["version"] = 2
+    return result
 
 
 def load_settings(config_path: Path) -> dict[str, RoleSettings]:
     """Validate every preset and return the active role settings."""
     _, _, config = _parse_file(config_path, "settings")
     config = validate_config(config, config_path)
+    if config["preset"] == "custom":
+        return config["custom"]
     return {role: dict(variants[config["preset"]]) for role, variants in config["roles"].items()}
 
 
 def serialize_settings(config: dict) -> bytes:
     """Serialize a complete unified configuration without losing inactive presets."""
     config = validate_config(config, Path("models.toml"))
-    lines = ["version = 1", f'preset = {json.dumps(config["preset"])}']
+    lines = ["version = 2", f'preset = {json.dumps(config["preset"])}']
     for role in ROLE_FILES:
         for preset in PRESETS:
             lines.extend(["", f"[roles.{role}.{preset}]"])
             lines.extend(f"{key} = {json.dumps(config['roles'][role][preset][key], ensure_ascii=False)}" for key in _MODEL_FIELDS)
+    if "custom" in config:
+        for role in ROLE_FILES:
+            lines.extend(["", f"[custom.{role}]"])
+            lines.extend(f"{key} = {json.dumps(config['custom'][role][key], ensure_ascii=False)}" for key in _MODEL_FIELDS)
     return ("\n".join(lines) + "\n").encode("utf-8")
 
 

package/lib/installer/global-config.mjs

@@ -38,5 +38,6 @@ export function renderWaitSettings(original){
  try{if(!isDeepStrictEqual(parseToml(updated),expected))return manual('automatic edit could not be verified');}catch{return manual('automatic edit could not be verified');}
  return{content:Buffer.from(updated),action:'set ARC wait settings'};
 }
-export function agentsBlockBody(home,userHome,language='en',platform='codex'){const skill=home+'/skills/arc/SKILL.md',within=skill.startsWith(userHome+'/'),shown=within?'~/'+skill.slice(userHome.length+1):skill;return '- '+languagePolicy(language)+'\n'+'- For requests requiring substantive multi-step research, analysis, or implementation, configuration, or test work, and for design, spec, plan, and brainstorming requests (these are NOT standalone document writing), load and follow `'+shown+'`; keep following it in relevant follow-up turns of the same chat without re-reading it unless it changed.'+(within?" Resolve `~` to the current user's home directory.":'')+' ARC subagents (depth 2) follow their role profile and brief instead and do not load `SKILL.md`.\n'+'- Design, spec, plan, and brainstorming drafts are authored ONLY by the Planner. Orchestrator MUST NEVER author them; route drafting skills to the Planner.\n'+
+
+export function agentsBlockBody(home,userHome,language='en',platform='codex'){const skill=home+'/skills/arc/SKILL.md',within=skill.startsWith(userHome+'/'),shown=within?'~/'+skill.slice(userHome.length+1):skill;return '- '+languagePolicy(language)+'\n'+'- For requests requiring substantive multi-step research, analysis, or implementation, configuration, or test work, and for design, spec, plan, and brainstorming requests (these are NOT standalone document writing), load and follow `'+shown+'`; keep following it in relevant follow-up turns of the same chat without re-reading it unless it changed.'+(within?" Resolve `~` to the current user's home directory.":'')+' ARC subagents (depth 2) follow their role profile and brief instead and do not load `SKILL.md`.\n'+'- Design and brainstorming drafts and first complete spec and plan drafts are authored only by the Planner; route drafting skills to the Planner. Orchestrator reviews and directly revises the same spec or plan when needed; a missing or failed first draft does not transfer initial authorship. New product decisions outside approved scope require user input first.\n'+
 '- For repository implementation, configuration, or test work, Orchestrator owns coordination and acceptance; assign file edits and other work to the other roles according to their defined responsibilities. Orchestrator must not edit implementation, configuration, or test-code files directly, except under the ARC Orchestrator direct path for small, low-risk tasks.\n';}

package/lib/installer/manifest.mjs

@@ -40,7 +40,7 @@ export function verifyPayload({packageRoot,safeFs,payloadMode='auto'}){
   for(const platform of ['codex','claude'])referenceTrees[platform]=validateFlatReferenceFiles(files,platform);
   for(const{destination}of REFERENCE_PATH_MAP)if(!referenceTrees.codex.entries.get(destination).bytes.equals(referenceTrees.claude.entries.get(destination).bytes))throw Error('Imported platform parity mismatch: '+destination);
   for(const name of listed.keys())if(!files.has(name))throw Error(`Manifest entry is missing: ${name}`);
-  const required=['claude/skill/hooks/role-git-guard.mjs','claude/skill/hooks/git-policy.json','lib/policy/claude-hook.mjs','lib/policy/role-policy.json','lib/policy/render.mjs','scripts/update-role-policy.mjs','lib/limits.mjs','lib/installer/limits.mjs','lib/installer/runtime-config.mjs','README.md','install.command','package.json','bin/arc.mjs','lib/cli/root.mjs','lib/tui/app.mjs','lib/tui/terminal.mjs','lib/tui/render.mjs','lib/tui/setup.mjs','lib/management/operations.mjs','lib/management/status.mjs','lib/management/update.mjs','lib/management/workflow.mjs','lib/cli/postinstall.mjs','scripts/postinstall.mjs','lib/cli/upgrade.mjs','bin/arc-upgrade.mjs','lib/installer/shell-completion.mjs','lib/installer/manifest.mjs','lib/installer/targets.mjs','lib/installer/global-config.mjs','lib/installer/plan.mjs','lib/safe-fs/index.mjs','lib/safe-fs/native.mjs','lib/models/index.mjs','lib/models/config.mjs','lib/models/profiles.mjs','vendor/toml/LICENSE','vendor/toml/package.json','vendor/toml/provenance.json','vendor/toml/dist/index.js','prebuilds/index.json'];
+  const required=['lib/policy/role-policy.json','lib/policy/render.mjs','scripts/update-role-policy.mjs','lib/limits.mjs','lib/installer/limits.mjs','lib/installer/runtime-config.mjs','README.md','install.command','package.json','bin/arc.mjs','lib/cli/root.mjs','lib/tui/app.mjs','lib/tui/terminal.mjs','lib/tui/render.mjs','lib/tui/setup.mjs','lib/management/operations.mjs','lib/management/status.mjs','lib/management/update.mjs','lib/management/workflow.mjs','lib/cli/postinstall.mjs','scripts/postinstall.mjs','lib/cli/upgrade.mjs','bin/arc-upgrade.mjs','lib/installer/shell-completion.mjs','lib/installer/manifest.mjs','lib/installer/targets.mjs','lib/installer/global-config.mjs','lib/installer/plan.mjs','lib/safe-fs/index.mjs','lib/safe-fs/native.mjs','lib/models/index.mjs','lib/models/config.mjs','lib/models/profiles.mjs','vendor/toml/LICENSE','vendor/toml/package.json','vendor/toml/provenance.json','vendor/toml/dist/index.js','prebuilds/index.json'];
   required.push('lib/installer/runtime-assets.mjs',...RUNTIME_MODULE_PATHS);
   for(const platform of ['codex','claude'])required.push(`${platform}/skill/runtime/role-policy.json`,...RUNTIME_MODULE_PATHS.map(name=>`${platform}/skill/runtime/${name.slice('lib/runtime/'.length)}`));
   for(const tuple of ['darwin-arm64','darwin-x64','linux-arm64-gnu','linux-x64-gnu'])required.push(`prebuilds/${tuple}/arc_safe_fs.node`);

package/lib/installer/plan.mjs

@@ -1,9 +1,8 @@
-import {installClaudeHook} from '../policy/claude-hook.mjs';
-import {validateGitPolicy} from '../../claude/skill/hooks/role-git-guard.mjs';
 import{parseLanguage,serializeLanguage,renderLanguagePolicy,validateLanguage}from'./language.mjs';
 import{resolveLimits}from'../limits.mjs';import{parseLimits,serializeLimits}from'./limits.mjs';import{readRuntimeConcurrency,renderCodexConcurrency,renderClaudeConcurrency}from'./runtime-config.mjs';import{assertPlanSnapshot}from'./transaction.mjs';
 import{validateModelConfig}from'../models/config.mjs';
-import path from'node:path';import{loadModelConfig,applyPreset,serializeModelConfig,renderProfiles,resolveModelSettings}from'../models/index.mjs';import{inspectPath,TargetConfigurationError}from'./targets.mjs';import{renderManagedBlock,renderWaitSettings,agentsBlockBody}from'./global-config.mjs';
+import{assertCatalogRoles}from'../models/catalog.mjs';
+import path from'node:path';import{loadModelConfig,applyPreset,applyCustomRoles,serializeModelConfig,renderProfiles,resolveModelSettings}from'../models/index.mjs';import{inspectPath,TargetConfigurationError}from'./targets.mjs';import{renderManagedBlock,renderWaitSettings,agentsBlockBody}from'./global-config.mjs';
 function fail(message){throw new TargetConfigurationError(message);}
 export function previewLimits({target,safeFs}){
  const snapshot=new Map(),filename=path.join(target.home,'skills/arc/limits.toml');
@@ -17,10 +16,9 @@ export function previewLanguage({target,safeFs}){
  let existing=null;try{if(current.exists)existing=parseLanguage(current.bytes).language;}catch(cause){fail(`Invalid ARC language settings: ${cause.message}`);}
  return{existing,snapshot};
 }
-function renderModelAssets({payload,target,preset,modelConfig,language}){
+function renderModelAssets({payload,target,preset,modelConfig,language,customRoles,preservedCustomRoles,verifiedCatalog}){
  const input=payload.modelInputs[target.platform];if(!input)fail('Selected payload platform is unavailable');
- const config=modelConfig===undefined?applyPreset(loadModelConfig(input.models,target.platform),preset):validateModelConfig(modelConfig);if(config.platform!==target.platform)fail('Model config platform does not match target');const profiles=renderProfiles(input.profiles,resolveModelSettings(config));for(const[name,bytes]of profiles)profiles.set(name,renderLanguagePolicy(bytes,language));const modelBytes=Buffer.from(serializeModelConfig(config));
- if(target.platform==='claude'){try{const script=payload.files.get('claude/skill/hooks/role-git-guard.mjs'),policy=payload.files.get('claude/skill/hooks/git-policy.json');if(!Buffer.isBuffer(script)||!script.length||!Buffer.isBuffer(policy))throw Error('Missing hook assets');validateGitPolicy(JSON.parse(policy.toString('utf8')));for(const[name,bytes]of profiles)profiles.set(name,installClaudeHook(bytes,path.join(target.home,'skills/arc')));}catch(cause){fail(`Invalid Claude Git guard: ${cause.message}`);}}
+ let config;if(modelConfig!==undefined)config=validateModelConfig(modelConfig);else{const base=loadModelConfig(input.models,target.platform);if(preset==='custom'){assertCatalogRoles({platform:target.platform,roles:customRoles,catalog:verifiedCatalog});config=applyCustomRoles(base,customRoles);}else {if(customRoles!==undefined)assertCatalogRoles({platform:target.platform,roles:customRoles,catalog:verifiedCatalog});config=applyPreset(customRoles!==undefined?applyCustomRoles(base,customRoles):preservedCustomRoles!==undefined?applyCustomRoles(base,preservedCustomRoles):base,preset);}}if(config.platform!==target.platform)fail('Model config platform does not match target');const profiles=renderProfiles(input.profiles,resolveModelSettings(config));for(const[name,bytes]of profiles)profiles.set(name,renderLanguagePolicy(bytes,language));const modelBytes=Buffer.from(serializeModelConfig(config));
  return{profiles,modelBytes};
 }
 function renderSkillPayload({payload,target,language,modelBytes,limits}){
@@ -48,14 +46,14 @@ function renderNativeChanges({target,safeFs,snapshot,skipGlobal,preview,concurre
  }
  return globalChanges;
 }
-export function buildInstallPlan({payload,target,preset,skipGlobal=false,safeFs,limits,concurrentExplicit=false,limitsPreview,language='en',languagePreview,modelConfig}){
+export function buildInstallPlan({payload,target,preset,skipGlobal=false,safeFs,limits,concurrentExplicit=false,limitsPreview,language='en',languagePreview,modelConfig,customRoles,preservedCustomRoles,verifiedCatalog}){
  validateLanguage(language);
  if(languagePreview)assertPlanSnapshot({snapshot:languagePreview.snapshot},{safeFs});
  const languageState=languagePreview??previewLanguage({target,safeFs});
  if(limitsPreview)assertPlanSnapshot({snapshot:limitsPreview.snapshot},{safeFs});
  const preview=limitsPreview??previewLimits({target,safeFs});
  limits=resolveLimits({existing:preview.existing,overrides:limits??{}});
- const {profiles,modelBytes}=renderModelAssets({payload,target,preset,modelConfig,language});
+ const {profiles,modelBytes}=renderModelAssets({payload,target,preset,modelConfig,language,customRoles,preservedCustomRoles,verifiedCatalog});
  const skill=renderSkillPayload({payload,target,language,modelBytes,limits});
  const snapshot=new Map(),home=target.home;const skills=path.join(home,'skills'),agents=path.join(home,'agents'),arc=path.join(skills,'arc');
  for(const name of [home,skills,agents])inspectPath(safeFs,name,{kind:'directory',snapshot});

package/lib/installer/preset.mjs

@@ -1,14 +1,17 @@
 import path from 'node:path';
 import {inspectPath,TargetConfigurationError} from './targets.mjs';
-import {loadModelConfig,applyPreset,serializeModelConfig,resolveModelSettings,renderProfiles} from '../models/index.mjs';
+import {loadModelConfig,applyPreset,applyCustomRoles,serializeModelConfig,resolveModelSettings,renderProfiles} from '../models/index.mjs';
 import {assertPlanSnapshot,applyTransaction} from './transaction.mjs';
+import {assertCatalogRoles} from '../models/catalog.mjs';
 import {validatePlanSet} from './plan.mjs';
-export function buildPresetPlan({target,preset,safeFs}){
+export function buildPresetPlan({target,preset,safeFs,customRoles,verifiedCatalog}){
  const snapshot=new Map(),modelsPath=path.join(target.home,'skills/arc/models.toml'),managedPaths=[modelsPath,...target.profileNames.map(name=>path.join(target.home,'agents',name))];
  const read=filename=>{const found=inspectPath(safeFs,filename,{kind:'file',read:true,snapshot});if(!found.exists)throw new TargetConfigurationError(`Installed ARC file missing: ${filename}`);return found.bytes;};
- const originalModels=read(modelsPath),config=loadModelConfig(originalModels,target.platform),next=applyPreset(config,preset),originalProfiles=new Map(target.profileNames.map((name,i)=>[name,read(managedPaths[i+1])]));
+ const originalModels=read(modelsPath),config=loadModelConfig(originalModels,target.platform);
+ if(preset==='custom'||customRoles!==undefined)assertCatalogRoles({platform:target.platform,roles:customRoles,catalog:verifiedCatalog});
+ const next=customRoles!==undefined?applyPreset(applyCustomRoles(config,customRoles),preset):applyPreset(config,preset),originalProfiles=new Map(target.profileNames.map((name,i)=>[name,read(managedPaths[i+1])]));
  const profiles=renderProfiles(originalProfiles,resolveModelSettings(next)),specs=[];
- if(config.preset!==preset)specs.push({path:modelsPath,bytes:Buffer.from(serializeModelConfig(next))});
+ if(config.preset!==preset||(customRoles!==undefined&&(!config.custom||Object.keys(next.custom).some(role=>Object.keys(next.custom[role]).some(key=>config.custom[role]?.[key]!==next.custom[role][key])))))specs.push({path:modelsPath,bytes:Buffer.from(serializeModelConfig(next))});
  for(const[name,bytes]of profiles)if(!bytes.equals(originalProfiles.get(name)))specs.push({path:path.join(target.home,'agents',name),bytes});
  return{target,preset,snapshot,managedPaths,externalPaths:[],specs};
 }

package/lib/installer/uninstall.mjs

@@ -4,7 +4,7 @@ import {SKILLS,snapshotSkill} from './superpowers.mjs';
 import {validatePlanSet} from './plan.mjs';
 import {removeManagedBlock} from './global-config.mjs';
 import {attachShellCompletionCleanup} from './shell-completion.mjs';
-export function buildUninstallPlan({target,safeFs,skipGlobal=false}){
+export function buildUninstallPlan({target,safeFs,skipGlobal=false,removeCompletion=true}){
  const snapshot=new Map(),removals=[],managedPaths=[path.join(target.home,'skills/arc'),...target.profileNames.map(name=>path.join(target.home,'agents',name))],globalChanges=[];
  for(const filename of managedPaths){const directory=filename===managedPaths[0];const found=inspectPath(safeFs,filename,{kind:directory?'directory':'file',tree:directory,allowLinks:directory,snapshot});if(found.exists)removals.push(filename);}
  const linkedSkills=new Set(),arc=managedPaths[0];
@@ -16,7 +16,7 @@ export function buildUninstallPlan({target,safeFs,skipGlobal=false}){
  for(const skill of linkedSkills){const root=arc+'/references/superpowers/'+skill,directory=safeFs.openRoot(root);try{if(!sameIdentity(snapshot.get(root),directory.stat()))throw new TargetConfigurationError('Removal reference root changed');snapshotSkill(directory,root,[]);}finally{directory.close();}}
  if(!skipGlobal){const filename=target.instructionPath??target.globalPaths[0],found=inspectPath(safeFs,filename,{kind:'file',read:true,snapshot});managedPaths.push(filename);if(found.exists){const removed=removeManagedBlock(found.bytes);if(removed.changed)globalChanges.push({path:filename,content:removed.content});}}
  const plan={target,skipGlobal,snapshot,removals,managedPaths,externalPaths:[],globalChanges,summary:[target.platform==='codex'?'Codex config.toml wait settings and native concurrency key are preserved.':'Claude settings.json native concurrency key is preserved.']};
- attachShellCompletionCleanup([plan],{safeFs});return plan;
+ if(removeCompletion)attachShellCompletionCleanup([plan],{safeFs});return plan;
 }
 import {assertPlanSnapshot,applyUninstallTransaction} from './transaction.mjs';
 export async function uninstallTargets(plans,{safeFs,signal,hooks={}}){

package/lib/management/operations.mjs

@@ -19,12 +19,13 @@ export async function createManagementContext(options={}){
 export async function prepareOperation(context,options,{selections=[]}={}){
  if(options.kind==='update'){const{prepareUpdate}=await import('./update.mjs');return prepareUpdate(context);}
  if(!['install','preset','uninstall'].includes(options.kind))throw Object.assign(Error('Unknown management operation'),{code:'ARC_CLI_INPUT'});
+ if(options.kind==='uninstall')options={...options,removeCli:options.removeCli!==false};
  const platforms=options.target==='all'?['codex','claude']:[options.target],payload=options.kind==='install'?verifyPayload(context):null;
- const plans=platforms.map(platform=>{const target=resolveTarget(platform,context),selection=selections.find(item=>item.target.platform===platform&&item.target.home===target.home);if(options.kind==='preset')return buildPresetPlan({target,preset:options.preset,safeFs:context.safeFs});if(options.kind==='uninstall')return buildUninstallPlan({target,safeFs:context.safeFs,skipGlobal:options.skipGlobal});return buildInstallPlan({payload,target,limitsPreview:selection?.preview,languagePreview:selection?.languagePreview,preset:options.preset,language:options.language,skipGlobal:options.skipGlobal,safeFs:context.safeFs,limits:{...(options.maxTotalSubagents===undefined?{}:{max_total_subagents:options.maxTotalSubagents}),...(options.maxConcurrentSubagents===undefined?{}:{max_concurrent_subagents:options.maxConcurrentSubagents})},concurrentExplicit:options.maxConcurrentSubagents!==undefined||Boolean(options.concurrentSelected)});});
+ const plans=platforms.map(platform=>{const target=resolveTarget(platform,context),selection=selections.find(item=>item.target.platform===platform&&item.target.home===target.home);if(options.kind==='preset')return buildPresetPlan({target,preset:options.preset,safeFs:context.safeFs,customRoles:options.customRoles,verifiedCatalog:options.verifiedCatalog});if(options.kind==='uninstall')return buildUninstallPlan({target,safeFs:context.safeFs,skipGlobal:options.skipGlobal,removeCompletion:options.removeCli!==false});return buildInstallPlan({payload,target,limitsPreview:selection?.preview,languagePreview:selection?.languagePreview,preset:options.preset,customRoles:options.customRoles,preservedCustomRoles:options.preservedCustomRoles,verifiedCatalog:options.verifiedCatalog,language:options.language,skipGlobal:options.skipGlobal,safeFs:context.safeFs,limits:{...(options.maxTotalSubagents===undefined?{}:{max_total_subagents:options.maxTotalSubagents}),...(options.maxConcurrentSubagents===undefined?{}:{max_concurrent_subagents:options.maxConcurrentSubagents})},concurrentExplicit:options.maxConcurrentSubagents!==undefined||Boolean(options.concurrentSelected)});});
  if(options.kind==='install')attachShellCompletionCleanup(plans,context);
  // Uninstall plans initially share the completion snapshot; its executor assigns one owner.
  if(options.kind!=='uninstall')validatePlanSet(plans);
- const globalArc=options.kind==='uninstall'?await(context.inspectGlobalArc??inspectGlobalArc)({env:context.env,cwd:context.cwd,runNpm:context.runNpm}):undefined;
+ const globalArc=options.kind==='uninstall'&&options.removeCli!==false?await(context.inspectGlobalArc??inspectGlobalArc)({env:context.env,cwd:context.cwd,runNpm:context.runNpm}):undefined;
  return{kind:options.kind,plans,options:{...options},...(globalArc?{globalArc}:{})};
 }
 export function operationResult(result,successStatuses=['installed']){return{...result,code:result.interrupted?130:result.results.every(item=>successStatuses.includes(item.status)&&!item.error)?0:1,exitSession:false};}
@@ -34,6 +35,7 @@ export async function executeOperation(context,prepared){
  if(prepared.kind==='install')return operationResult(await installTargets(prepared.plans,options));
  if(prepared.kind==='preset')return operationResult(await switchPresetTargets(prepared.plans,options),['updated','unchanged']);
  if(prepared.kind==='uninstall'){
+  if(prepared.options?.removeCli===false)return operationResult(await uninstallTargets(prepared.plans,options),['uninstalled']);
   let result;
   try{
    const current=await(context.inspectGlobalArc??inspectGlobalArc)({context:prepared.globalArc,env:context.env,cwd:context.cwd,runNpm:context.runNpm});

package/lib/management/update.mjs

@@ -12,7 +12,7 @@ export async function runtime(deps){
  return{...context,...state,...upgrade,...npm,...deps,safeFs};
 }
 export function report(result,output,error){
- for(const item of result.results){output.write(item.platform+': '+item.status+'; rollback: '+item.rollback+'\n');for(const filename of item.residualPaths??[])output.write('Residual path: '+filename+'\n');if(item.error)error.write('Error: '+item.error.message+'\n');}
+ for(const item of result.results){output.write(item.platform+': '+item.status+'\n');for(const filename of item.residualPaths??[])output.write('Residual path: '+filename+'\n');if(item.error)error.write('Error: '+item.error.message+'\n');}
  if(result.interrupted)return 130;
  if(result.results.every(item=>item.status==='installed'&&!item.error)){output.write('ARC version '+result.version+' harness upgraded! Previous harness version: not recorded.\n');return 0;}
  error.write('Harness update did not complete. Run arc again and choose Install / Update to retry the harness update.\n');return 1;
@@ -35,18 +35,18 @@ export async function runChild(request,io={},deps={}){
 export async function prepareUpdate(context){
  const root=context.packageRoot??packageRoot,pkg=identity(root),api=await runtime(context),cwd=fs.realpathSync(context.cwd??process.cwd()),env=context.env??process.env;
  const state=api.collectInstalledState({safeFs:api.safeFs,userHome:context.userHome??os.homedir(),env,cwd});
- if(!state.targets.length)throw configurationError('No installed ARC harness found. Run npx --yes @yunhozz/arc to install it first');
  const npmContext=await api.inspectNpmContext({packageRoot:root,entryPath:path.join(root,'bin/arc.mjs'),env,cwd});
  if(!['global','npx'].includes(npmContext.kind))throw configurationError('Run arc from a verified global ARC installation or npx');
  let latestVersion=null,latestError;
  try{const latest=await api.resolveLatest({context:npmContext,env,cwd,signal:context.signal});if(!/^\d+\.\d+\.\d+$/.test(latest.version))throw Error('Invalid latest ARC version');latestVersion=latest.version;}catch(error){if(['ARC_CANCELLED','ARC_NPM_CANCELLED'].includes(error.code))throw error;latestError=error;}
- return{kind:'update',root,pkg,cwd,env,state,npmContext,currentVersion:pkg.version,latestVersion,canUpgrade:latestVersion!==null&&newer(latestVersion,pkg.version),latestError};
+ return{kind:'update',root,pkg,cwd,env,state,npmContext,currentVersion:pkg.version,latestVersion,canUpgrade:state.targets.length>0&&latestVersion!==null&&newer(latestVersion,pkg.version),latestError};
 }
 function newer(left,right){const a=left.split('.').map(BigInt),b=right.split('.').map(BigInt);for(let i=0;i<3;i++){if(a[i]!==b[i])return a[i]>b[i];}return false;}
 
 export async function executeUpdate(context,prepared){
  let packageStarted=false;const messages=[];try{
   const api=await runtime(context),{root,pkg,cwd,env,state}=prepared;
+  if(!state?.targets?.length)throw configurationError('No installed ARC harness found');
   if(!prepared.canUpgrade||typeof prepared.latestVersion!=='string'||!/^\d+\.\d+\.\d+$/.test(prepared.latestVersion)||!newer(prepared.latestVersion,prepared.currentVersion))throw configurationError('No newer ARC version is available');
   if(identity(root).version!==pkg.version||pkg.version!==prepared.currentVersion)throw configurationError('ARC package changed after checking its version');
   const{assertPlanSnapshot}=await import('../installer/transaction.mjs');for(const entry of state.targets)assertPlanSnapshot(entry,{safeFs:api.safeFs});

package/lib/models/catalog-anthropic.mjs

@@ -0,0 +1,46 @@
+const API = 'https://api.anthropic.com/v1/models';
+const EFFORTS = ['low', 'medium', 'high', 'xhigh', 'max'];
+const unavailable = (code, message) => ({ status: 'unavailable', code, message });
+
+export async function discoverAnthropicCatalog({ apiKey, fetchImpl = globalThis.fetch, signal } = {}) {
+  if (typeof apiKey !== 'string' || !apiKey.trim() || /[\r\n]/.test(apiKey)) return unavailable('missing_api_key', 'Anthropic API key is unavailable.');
+  if (typeof fetchImpl !== 'function') return unavailable('unavailable', 'Anthropic catalog is unavailable.');
+  const pairs = [], unavailableModels = [], seenPairs = new Set(), seenModels = new Set(), supportedModels = new Set(), cursors = new Set();
+  let cursor;
+  try {
+    for (let pageNumber = 0; pageNumber < 1000; pageNumber++) {
+      if (signal?.aborted) return unavailable('aborted', 'Catalog lookup was cancelled.');
+      const url = new URL(API);
+      if (cursor) url.searchParams.set('after_id', cursor);
+      const response = await fetchImpl(url, {
+        method: 'GET', redirect: 'manual', signal,
+        headers: { 'anthropic-version': '2026-10-21', Authorization: `Bearer ${apiKey}` },
+      });
+      if (!response?.ok) return unavailable('http_error', 'Anthropic catalog is unavailable.');
+      if (response.url) {
+        const actual = new URL(response.url);
+        if (actual.origin !== url.origin || actual.pathname !== url.pathname) return unavailable('http_error', 'Anthropic catalog is unavailable.');
+      }
+      const page = await response.json();
+      if (!page || !Array.isArray(page.data) || !page.data.length || typeof page.has_more !== 'boolean') throw Error('invalid page');
+      for (const model of page.data) {
+        if (!model || typeof model.id !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9._:/@+\-]*$/.test(model.id) || model.id.includes(apiKey)) throw Error('invalid model');
+        const capability = model.capabilities?.effort;
+        const supported = capability?.supported === true ? EFFORTS.filter(effort => capability[effort]?.supported === true) : [];
+        if (!supported.length && !seenModels.has(model.id)) unavailableModels.push({ model: model.id, reason: 'Effort capability is unavailable.' });
+        seenModels.add(model.id);
+        for (const effort of supported) {
+          supportedModels.add(model.id);
+          const key = JSON.stringify([model.id, effort]);
+          if (!seenPairs.has(key)) { seenPairs.add(key); pairs.push({ model: model.id, effort }); }
+        }
+      }
+      if (!page.has_more) return { status: 'ready', catalog: { platform: 'claude', pairs, unavailable: unavailableModels.filter(item => !supportedModels.has(item.model)) } };
+      if (typeof page.last_id !== 'string' || !page.last_id || page.last_id !== page.data.at(-1).id || cursors.has(page.last_id)) throw Error('invalid cursor');
+      cursor = page.last_id; cursors.add(cursor);
+    }
+    throw Error('too many pages');
+  } catch {
+    return signal?.aborted ? unavailable('aborted', 'Catalog lookup was cancelled.') : unavailable('invalid_response', 'Anthropic catalog is unavailable.');
+  }
+}

package/lib/models/catalog.mjs

@@ -0,0 +1,62 @@
+import { effortField, validateRoles, ModelValidationError } from './config.mjs';
+import { discoverAnthropicCatalog } from './catalog-anthropic.mjs';
+export { discoverAnthropicCatalog } from './catalog-anthropic.mjs';
+export { listCodexModelCapabilities } from './codex-catalog.mjs';
+
+const unavailable = (code, message) => ({ status: 'unavailable', code, message });
+const validText = value => typeof value === 'string' && value.length > 0 && value === value.trim() && !/[\p{Cc}\u2028\u2029]/u.test(value);
+
+function codexCatalog(models, secrets) {
+  if (!Array.isArray(models) || !models.length) throw Error('invalid catalog');
+  const pairs = [], missing = [], seenPairs = new Set(), seenModels = new Set(), supportedModels = new Set();
+  for (const item of models) {
+    if (!item || !validText(item.model) || secrets.some(secret => item.model.includes(secret)) || !Array.isArray(item.efforts) || !item.efforts.every(value => validText(value) && !secrets.some(secret => value.includes(secret)))) throw Error('invalid model');
+    if (!item.efforts.length && !seenModels.has(item.model)) missing.push({ model: item.model, reason: 'Effort capability is unavailable.' });
+    seenModels.add(item.model);
+    for (const effort of item.efforts) {
+      supportedModels.add(item.model);
+      const key = JSON.stringify([item.model, effort]);
+      if (!seenPairs.has(key)) { seenPairs.add(key); pairs.push({ model: item.model, effort }); }
+    }
+  }
+  return { platform: 'codex', pairs, unavailable: missing.filter(item => !supportedModels.has(item.model)) };
+}
+
+export async function discoverModelCatalog({ platform, env = process.env, fetchImpl = globalThis.fetch, listCodexModels, signal, timeoutMs = 10000 } = {}) {
+  if (!['codex', 'claude'].includes(platform)) return unavailable('unsupported_platform', 'Catalog is unavailable.');
+  if (signal?.aborted) return unavailable('aborted', 'Catalog lookup was cancelled.');
+  if (platform === 'codex' && typeof listCodexModels !== 'function') return unavailable('unavailable', 'Codex catalog is unavailable.');
+  const controller = new AbortController(); let timedOut = false, resolveAbort;
+  const abortPromise = new Promise(resolve => { resolveAbort = resolve; });
+  const onAbort = () => { controller.abort(); resolveAbort(); };
+  signal?.addEventListener('abort', onAbort, { once: true });
+  const timer = setTimeout(() => { timedOut = true; onAbort(); }, Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : 10000);
+  const operation = Promise.resolve().then(async () => platform === 'codex'
+    ? { status: 'ready', catalog: codexCatalog(await listCodexModels({ env, signal: controller.signal }), [env?.OPENAI_API_KEY, env?.ANTHROPIC_API_KEY].filter(value => typeof value === 'string' && value.length)) }
+    : discoverAnthropicCatalog({ apiKey: env?.ANTHROPIC_API_KEY, fetchImpl, signal: controller.signal }));
+  const settled = operation.then(value => ({ value }), () => ({ failed: true }));
+  try {
+    const first = await Promise.race([settled, abortPromise.then(() => ({ aborted: true }))]);
+    if (first.aborted) {
+      if (platform === 'codex') {
+        let graceTimer;
+        await Promise.race([settled, new Promise(resolve => { graceTimer = setTimeout(resolve, 2100); })]);
+        clearTimeout(graceTimer);
+      }
+      return timedOut ? unavailable('timeout', 'Catalog lookup timed out.') : unavailable('aborted', 'Catalog lookup was cancelled.');
+    }
+    return first.failed ? unavailable('unavailable', 'Catalog is unavailable.') : first.value;
+  } finally { clearTimeout(timer); signal?.removeEventListener('abort', onAbort); }
+}
+
+export function assertCatalogRoles({ platform, roles, catalog } = {}) {
+  const validRoles = validateRoles(roles, platform);
+  if (!catalog || catalog.platform !== platform || !Array.isArray(catalog.pairs)) throw new ModelValidationError('Catalog is unavailable.');
+  const pairs = new Set();
+  for (const pair of catalog.pairs) {
+    if (!pair || !validText(pair.model) || !validText(pair.effort)) throw new ModelValidationError('Catalog is invalid.');
+    pairs.add(JSON.stringify([pair.model, pair.effort]));
+  }
+  const effort = effortField(platform);
+  if (Object.values(validRoles).some(value => !pairs.has(JSON.stringify([value.model, value[effort]])))) throw new ModelValidationError('Roles contain a pair absent from the catalog.');
+}

package/lib/models/codex-catalog.mjs

@@ -0,0 +1,103 @@
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { StringDecoder } from 'node:string_decoder';
+
+const ENV_KEYS = ['PATH', 'HOME', 'USERPROFILE', 'HOMEDRIVE', 'HOMEPATH', 'APPDATA', 'LOCALAPPDATA', 'SYSTEMROOT', 'WINDIR', 'TMPDIR', 'TEMP', 'TMP', 'CODEX_HOME', 'XDG_CONFIG_HOME', 'XDG_DATA_HOME'];
+const validText = value => typeof value === 'string' && value.length > 0 && value === value.trim() && !/[\p{Cc}\u2028\u2029]/u.test(value);
+const failure = () => new Error('Codex catalog is unavailable.');
+
+export async function listCodexModelCapabilities({ env = process.env, cwd, spawnImpl = spawn, signal, timeoutMs = 10000 } = {}) {
+  if (typeof cwd !== 'string' || !path.isAbsolute(cwd) || path.normalize(cwd) !== cwd || typeof spawnImpl !== 'function' || signal?.aborted) throw failure();
+  const childEnv = Object.fromEntries(ENV_KEYS.filter(key => typeof env?.[key] === 'string').map(key => [key, env[key]]));
+  const secrets = [env?.OPENAI_API_KEY, env?.ANTHROPIC_API_KEY].filter(value => typeof value === 'string' && value.length);
+  const containsSecret = value => secrets.some(secret => value.includes(secret));
+  let child;
+  try { child = spawnImpl('codex', ['app-server'], { cwd, env: childEnv, stdio: ['pipe', 'pipe', 'pipe'], shell: false }); }
+  catch { throw failure(); }
+  if (!child?.stdin || !child?.stdout || !child?.stderr || typeof child.on !== 'function' || typeof child.kill !== 'function') throw failure();
+
+  let closed = false, interrupted = false, cancelled = false, nextId = 0, buffer = '';
+  const pending = new Map(), decoder = new StringDecoder('utf8');
+  let resolveClosed;
+  const closedPromise = new Promise(resolve => { resolveClosed = resolve; });
+  const rejectPending = () => { interrupted = true; for (const entry of pending.values()) entry.reject(failure()); pending.clear(); };
+  const onClose = () => { closed = true; resolveClosed(); rejectPending(); };
+  const onError = () => rejectPending();
+  const onData = chunk => {
+    buffer += decoder.write(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    if (buffer.length > 1048576) { rejectPending(); return; }
+    let newline;
+    while ((newline = buffer.indexOf('\n')) !== -1) {
+      const line = buffer.slice(0, newline); buffer = buffer.slice(newline + 1);
+      if (!line.trim()) continue;
+      let message; try { message = JSON.parse(line); } catch { rejectPending(); return; }
+      if (message?.id === undefined) continue;
+      const entry = pending.get(message.id);
+      if (!entry) { rejectPending(); return; }
+      pending.delete(message.id);
+      if (message.error || !Object.hasOwn(message, 'result')) entry.reject(failure()); else entry.resolve(message.result);
+    }
+  };
+  child.on('close', onClose); child.on('error', onError);
+  child.stdout.on('data', onData); child.stdout.on('error', onError); child.stdin.on('error', onError); child.stderr.on('error', onError); child.stderr.resume();
+  const onAbort = () => { cancelled = true; rejectPending(); };
+  signal?.addEventListener('abort', onAbort, { once: true });
+  if (signal?.aborted) onAbort();
+  const timer = setTimeout(onAbort, Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : 10000);
+  const send = value => { if (interrupted || closed) throw failure(); child.stdin.write(JSON.stringify(value) + '\n'); };
+  const request = (method, params) => new Promise((resolve, reject) => {
+    if (interrupted || closed) { reject(failure()); return; }
+    const id = ++nextId; pending.set(id, { resolve, reject });
+    try { send({ id, method, params }); } catch { pending.delete(id); reject(failure()); }
+  });
+  let result, error;
+  try {
+    const initialized = await request('initialize', { clientInfo: { name: 'arc', title: 'ARC', version: '1.0.0' } });
+    if (!initialized || typeof initialized !== 'object' || Array.isArray(initialized) || !validText(initialized.userAgent)) throw failure();
+    send({ method: 'initialized', params: {} });
+    const models = new Map(), cursors = new Set(); let cursor;
+    for (let pageNumber = 0; pageNumber < 1000; pageNumber++) {
+      const page = await request('model/list', { limit: 100, includeHidden: true, ...(cursor ? { cursor } : {}) });
+      if (interrupted) throw failure();
+      if (!page || !Array.isArray(page.data) || !page.data.length || !(page.nextCursor === null || validText(page.nextCursor))) throw failure();
+      for (const descriptor of page.data) {
+        if (descriptor?.hidden === true) continue;
+        if (!descriptor || !validText(descriptor.model) || containsSecret(descriptor.model) || !Array.isArray(descriptor.supportedReasoningEfforts)) throw failure();
+        let efforts = models.get(descriptor.model);
+        if (!efforts) { efforts = []; models.set(descriptor.model, efforts); }
+        for (const option of descriptor.supportedReasoningEfforts) {
+          if (!validText(option?.reasoningEffort) || containsSecret(option.reasoningEffort)) throw failure();
+          if (!efforts.includes(option.reasoningEffort)) efforts.push(option.reasoningEffort);
+        }
+      }
+      if (page.nextCursor === null) { result = [...models].map(([model, efforts]) => ({ model, efforts })); break; }
+      if (cursors.has(page.nextCursor)) throw failure();
+      cursors.add(page.nextCursor); cursor = page.nextCursor;
+    }
+    if (!result) throw failure();
+  } catch { error = failure(); }
+  finally {
+    rejectPending();
+    try { child.stdin.end(); } catch { error = failure(); }
+    if (!closed) { try { child.kill('SIGTERM'); } catch { error = failure(); } }
+    const wait = async ms => { if (closed) return true; let timerId; const timeout = new Promise(resolve => { timerId = setTimeout(() => resolve(false), ms); }); const value = await Promise.race([closedPromise.then(() => true), timeout]); clearTimeout(timerId); return value; };
+    if (!await wait(1000)) {
+      try { child.kill('SIGKILL'); } catch { error = failure(); }
+      if (!await wait(1000)) error = failure();
+    }
+    if (!closed) {
+      // A failed close may still emit late errors; keep only a guard until close.
+      const guard = () => {};
+      const streams = [child.stdin, child.stdout, child.stderr];
+      child.on('error', guard); for (const stream of streams) stream.on('error', guard);
+      child.once('close', () => { child.removeListener('error', guard); for (const stream of streams) stream.removeListener('error', guard); });
+      for (const stream of streams) stream.destroy();
+    }
+    clearTimeout(timer); signal?.removeEventListener('abort', onAbort);
+    if (cancelled) error = failure();
+    child.stdout.removeListener('data', onData); child.stdout.removeListener('error', onError); child.stdin.removeListener('error', onError); child.stderr.removeListener('error', onError);
+    child.removeListener('close', onClose); child.removeListener('error', onError);
+  }
+  if (error) throw error;
+  return result;
+}

package/lib/models/config.mjs

@@ -5,8 +5,7 @@ export class ModelValidationError extends Error {
 }
 export function fail(message) { throw new ModelValidationError(message); }
 export function platformOf(config) {
-  if (config?.platform === 'codex' && config.version === 1) return 'codex';
-  if (config?.platform === 'claude' && config.version === 1) return 'claude';
+  if (['codex', 'claude'].includes(config?.platform) && [1, 2].includes(config.version)) return config.platform;
   fail('Unsupported model schema version');
 }
 export function effortField(platform) {
@@ -30,29 +29,38 @@ export function validateRoles(roles, platform) {
 }
 export const PRESETS = Object.freeze(['economy', 'balanced', 'smart']);
 export function validateModelConfig(config) {
-  exactKeys(config, ['platform', 'version', 'preset', 'roles'], 'model config'); const platform = platformOf(config);
-  if (!PRESETS.includes(config.preset)) fail('Unsupported performance preset');
+  const platform = platformOf(config);
+  const hasCustom = Object.hasOwn(config, 'custom');
+  exactKeys(config, ['platform', 'version', 'preset', 'roles', ...(hasCustom && config.version === 2 ? ['custom'] : [])], 'model config');
+  if (![...PRESETS, 'custom'].includes(config.preset) || (config.preset === 'custom' && !hasCustom)) fail('Unsupported performance preset or missing custom roles');
   exactKeys(config.roles, ROLES, 'roles');
   for (const role of ROLES) exactKeys(config.roles[role], PRESETS, `roles.${role}`);
   for (const preset of PRESETS) validateRoles(Object.fromEntries(ROLES.map(role => [role, config.roles[role][preset]])), platform);
-  return structuredClone(config);
+  if (hasCustom) validateRoles(config.custom, platform);
+  return { ...structuredClone(config), version: 2 };
 }
 export function resolveModelSettings(config) {
   const validated = validateModelConfig(config);
-  return { platform: validated.platform, roles: Object.fromEntries(ROLES.map(role => [role, validated.roles[role][validated.preset]])) };
+  return { platform: validated.platform, roles: validated.preset === 'custom' ? validated.custom : Object.fromEntries(ROLES.map(role => [role, validated.roles[role][validated.preset]])) };
 }
 export function parseToml(text) {
   try { return parse(typeof text === 'string' ? text : new TextDecoder('utf-8', { fatal: true }).decode(text), { integersAsBigInt: true }); }
   catch (cause) { throw new ModelValidationError(`Invalid TOML: ${cause.message}`, { cause }); }
 }
 export function loadModelConfig(text, platform) {
-  effortField(platform); const config = parseToml(text); exactKeys(config, ['version', 'preset', 'roles'], 'model file (reinstall or update legacy role-only settings)');
-  if (config.version !== 1n) fail(`Expected ${platform} integer schema version 1; reinstall or update models.toml`);
-  return validateModelConfig({ platform, version: 1, preset: config.preset, roles: config.roles });
+  effortField(platform); const config = parseToml(text);
+  if (config.version !== 1n && config.version !== 2n) fail(`Expected ${platform} integer schema version 1 or 2; reinstall or update models.toml`);
+  const hasCustom = Object.hasOwn(config, 'custom');
+  exactKeys(config, ['version', 'preset', 'roles', ...(hasCustom && config.version === 2n ? ['custom'] : [])], 'model file (reinstall or update legacy role-only settings)');
+  return validateModelConfig({ ...config, platform, version: Number(config.version) });
 }
-export function serializeModelConfig(config) { const { version, preset, roles } = validateModelConfig(config); return stringify({ version, preset, roles }); }
+export function serializeModelConfig(config) { const { platform, ...file } = validateModelConfig(config); return stringify(file); }
 export function applyPreset(config, preset) {
   const validated = validateModelConfig(config);
-  if (!PRESETS.includes(preset)) fail('Unsupported performance preset');
+  if (![...PRESETS, 'custom'].includes(preset) || (preset === 'custom' && !validated.custom)) fail('Unsupported performance preset or missing custom roles');
   return { ...validated, preset };
 }
+export function applyCustomRoles(config, roles) {
+  const validated = validateModelConfig(config);
+  return { ...validated, preset: 'custom', custom: validateRoles(roles, validated.platform) };
+}

package/lib/models/index.mjs

@@ -1,2 +1,2 @@
-export { loadModelConfig, applyPreset, serializeModelConfig, resolveModelSettings, ModelValidationError } from './config.mjs';
+export { loadModelConfig, applyPreset, applyCustomRoles, serializeModelConfig, resolveModelSettings, ModelValidationError } from './config.mjs';
 export { renderProfiles } from './profiles.mjs';

package/lib/models/profiles.mjs

@@ -1,4 +1,3 @@
-import {validateClaudeHookCommand} from '../policy/claude-hook.mjs';
 import { parseToml, exactKeys, validateRoles, effortField, ROLES, fail } from './config.mjs';
 const tools = {
   arc_scouter: ['Read', 'Grep', 'Glob', 'WebFetch', 'WebSearch'],
@@ -74,43 +73,6 @@ function renderCodex(text, role, settings) {
   if (checked.name !== role || Object.entries(settings).some(([key, value]) => checked[key] !== value)) fail('Rendered Codex profile does not match settings');
   return Buffer.from(output);
 }
-// Validate the consumed hook subset without rewriting any hook/user bytes.
-// The two ARC entries are exact contracts; user command entries remain data.
-function validateClaudeHooks(lines){
- const managed=new Map();let event;const events=new Set();
- if(lines[0]!=='hooks:')fail('Unsupported managed Claude hooks');
- for(let i=1;i<lines.length;){
-  const heading=/^  (PreToolUse|PostToolUse|SubagentStart):$/.exec(lines[i]);
-  if(heading){event=heading[1];if(events.has(event))fail('Duplicate Claude hook event');events.add(event);i++;continue;}
-  if(!event)fail('Unsupported Claude hook event');
-  const matcher=/^    - matcher: (.+)$/.exec(lines[i]);
-  let parsedMatcher,command;
-  try{
-   if(!matcher)throw Error('Missing matcher');
-   parsedMatcher=matcher[1].startsWith('"')?JSON.parse(matcher[1]):matcher[1];
-   if(typeof parsedMatcher!=='string'||!parsedMatcher||/[\r\n\x00]/.test(parsedMatcher)||(!matcher[1].startsWith('"')&&!/^[A-Za-z][A-Za-z0-9_|]*$/.test(parsedMatcher)))throw Error('Invalid matcher');
-   if(lines[i+1]!=='      hooks:'||lines[i+2]!=='        - type: command'||!lines[i+3]?.startsWith('          command: '))throw Error('Unsupported command entry');
-   command=JSON.parse(lines[i+3].slice('          command: '.length));
-   if(typeof command!=='string'||!command||/[\r\n\x00]/.test(command))throw Error('Invalid command');
-  }catch{fail('Unsupported managed Claude hooks');}
-  let isManaged=false;
-  try{validateClaudeHookCommand(command);isManaged=true;}catch{}
-  const hasFailure=lines[i+4]?.startsWith('          onFailure:');
-  if(isManaged){
-   if(lines[i+4]!=='          onFailure: block')fail('Unsupported managed Claude failure behavior');
-   const encoded=/"([A-Za-z0-9+/]+={0,2})"$/.exec(command)[1];
-   const url=new URL(Buffer.from(encoded,'base64').toString('utf8'));const file=url.pathname.split('/').at(-1);
-   const expected=file==='runtime-gate.mjs'?'"*"':'Bash';
-   if(event!=='PreToolUse'||matcher[1]!==expected||!hasFailure||managed.has(file))fail('Malformed or duplicate managed Claude hooks');
-   managed.set(file,url.href.slice(0,url.href.lastIndexOf('/')+1));
-  }else{
-   if(hasFailure&&!['          onFailure: continue','          onFailure: block'].includes(lines[i+4]))fail('Unsupported Claude failure behavior');
-   if(/runtime-gate\.mjs|role-git-guard\.mjs/.test(command))fail('Unrecognized managed Claude hook command');
-  }
-  i+=hasFailure?5:4;
- }
- if(managed.size!==1||!managed.has('role-git-guard.mjs'))fail('Missing or mismatched managed Claude hooks');
-}
 function renderClaude(text, role, settings) {
   const lines = linesOf(text); if (lines[0]?.replace(/\r?\n$/, '') !== '---') fail('Missing opening Claude frontmatter');
   const fields = {}, indices = {}; let current, closed = false;
@@ -119,7 +81,6 @@ function renderClaude(text, role, settings) {
     if(line==='hooks:') {
       if(Object.hasOwn(fields,'hooks'))fail('Duplicate Claude hooks');
       let end=i+1;while(end<lines.length&&/^[ \t]/.test(lines[end]))end++;
-      validateClaudeHooks(lines.slice(i,end).map(x=>x.replace(/\r?\n$/,'')));
       fields.hooks=true;indices.hooks=i;i=end-1;current='hooks';continue;
     }
     const item = /^  - ([A-Za-z][A-Za-z0-9]*)$/.exec(line);
@@ -130,7 +91,7 @@ function renderClaude(text, role, settings) {
     if (key === 'tools') { if (value !== undefined) fail('Claude tools must be an explicit list'); fields.tools = []; }
     else { if (!value || value !== value.trim() || /[\t\x00{}\[\]#&*!|>"']/.test(value) || value.includes(': ')) fail('Claude frontmatter requires plain scalar values'); fields[key] = value; }
   }
-  if (!closed || !['name', 'description', 'model', 'effort', 'tools', 'hooks'].every(key => Object.hasOwn(fields, key)) || fields.name !== role.replace('_', '-') || JSON.stringify(fields.tools) !== JSON.stringify(tools[role])) fail('Invalid Claude profile identity or role tools');
+  if (!closed || !['name', 'description', 'model', 'effort', 'tools'].every(key => Object.hasOwn(fields, key)) || fields.name !== role.replace('_', '-') || JSON.stringify(fields.tools) !== JSON.stringify(tools[role])) fail('Invalid Claude profile identity or role tools');
   if (!/^[A-Za-z0-9][A-Za-z0-9._:/@+\-]*$/.test(fields.model) || !['low','medium','high','xhigh','max'].includes(fields.effort)) fail('Invalid Claude profile model or effort');
   for (const key of ['model', 'effort']) { const index = indices[key], eol = /\r?\n$/.exec(lines[index])?.[0] ?? ''; lines[index] = `${key}: ${settings[key]}${eol}`; }
   return Buffer.from(lines.join(''));