@yunhozz/arc 0.2.4 → 0.2.5

package/codex/skill/references/planning.md

@@ -24,7 +24,7 @@ If explicitly requested probe+implementation is fully specified, classify the wh
 
 Initial design/brainstorming may precede target choice. Formal spec/plan includes complete pre-save drafts returned only in chat. Before that, Orchestrator records actual absolute workspace/repository, branch/detached HEAD/HEAD, changes/ownership, explicit choice/preparation and in-target absolute document paths. Planner drafts for verified target; Orchestrator saves there. Missing/mismatched evidence stops affected drafting/saving. Planned paths prove no actual preparation. Initial preparation never starts Implementer without full handoff.
 
-Small-task direct edits follow only [handoff](handoff.md#orchestrator-direct-path-for-small-tasks), stopping/reclassifying changed scope/risk. Otherwise follow this reference. `brainstorming`/`writing-plans` instruct existing roles, not extra agents; ARC routing/approval overrides alternate executors. Missing required skills block their stage. Integration means save/route/request approval, never author.
+Small-task direct edits follow only [handoff](handoff.md#orchestrator-direct-path-for-small-tasks), stopping/reclassifying changed scope/risk. Otherwise follow this reference. `brainstorming`/`writing-plans` instruct existing roles, not extra agents; ARC routing/approval overrides alternate executors. Missing required skills block their stage. Integration includes saving, reviewing and directly revising the same spec or plan after the complete Planner first draft; design/brainstorming retain their Planner drafting path.
 
 For Korean requests/briefs, Planner uses Korean titles/prose unless another language is requested, preserving identifiers, skill/API names, code, paths, commands and literals. Orchestrator preserves agreed language when saving.
 
@@ -36,10 +36,10 @@ Planner reports initial/revision progress only to Orchestrator: brief stage/feed
 1. Preflight relevant policy/references/profiles/tests/parity/manifest/conflicts. Apply formal-target and coordination provenance/input/local-skill gates, including required paths, approved bounded read alternatives and return conditions. Missing inputs/conflicts hold drafting. Read recovery grants no preparation/check/write/approval authority.
 2. Maintain a compact ledger of original requirements/IDs, approved/open decisions, exclusions and scope deltas. Consolidate intervening user changes into one brief delta. Separate approvals, path/line-verified facts, assumptions and open decisions.
 3. Send one complete stage-specific initial brief: prepared target/HEAD/ownership, scope/exclusions/depth/dependencies/shared contracts/criteria/checks/evidence/holds; preceding approved versions, paths, current behavior and connected source/generated/runtime/installer/docs, policy conflicts/resolution direction and exact deliverable. Visual work includes approved sources/versions/criteria/open interpretations.
-4. Planner returns complete proportional draft/self-review; Orchestrator integrates/saves/reviews/requests approval without authoring missing content. Review once with the fixed checklist: scope/evidence; targets/ownership/paths; policy/conflicts; task boundaries/dependencies/criteria; checks/evidence/holds; roles/approval/commit boundaries; completeness. Finish before one consolidated correction covering every substantive omission with criterion/defect/evidence/expected fix. Use deltas/`unchanged`; never split by omission.
-5. Further calls after correction need approved material scope/evidence changes or concrete unmet checklist items plus meaningful new input/criterion progress. State changed input/target criterion/expected artifact/progress. Existing-scope omissions need no renewed scope approval. Repeated unmet criteria without new input/evidence/progress hold the stage; report criterion/observation/exact unblock decision. Do not repeat resolved questions or count rewording/agent replacement as progress.
+4. Planner returns the complete proportional first draft and self-review. Orchestrator saves and reviews it against the fixed checklist: scope/evidence; targets/ownership/paths; policy/conflicts; task boundaries/dependencies/criteria; checks/evidence/holds; roles/approval/commit boundaries; completeness. For spec or plan, Orchestrator directly revises the same document, including substantive omissions, before requesting approval. New product decisions outside approved scope require user input first; Orchestrator then revises the document. Missing or failed first drafts stop the stage and do not transfer initial authorship.
+5. For design and brainstorming, finish the checklist before one consolidated correction covering every substantive omission with criterion/defect/evidence/expected fix. Use deltas/`unchanged`; never split by omission. Further calls after correction need approved material scope/evidence changes or concrete unmet checklist items plus meaningful new input/criterion progress. State changed input/target criterion/expected artifact/progress. Existing-scope omissions need no renewed scope approval. Repeated unmet criteria without new input/evidence/progress hold the stage; report criterion/observation/exact unblock decision. Do not repeat resolved questions or count rewording/agent replacement as progress.
 
-Allow initial draft and one consolidated correction. Reformatting/re-expression/save/patch errors belong to Orchestrator, not Planner calls. Separate substantive work uses normal gates. Design/spec/plan stages remain separately ordered; spec approval precedes dependent planning. Add no fixed call cap/profile count condition or incomplete-draft acceptance.
+For design and brainstorming, allow initial draft and one consolidated correction. Reformatting/re-expression/save/patch errors belong to Orchestrator, not Planner calls. Separate substantive work uses normal gates. Design/spec/plan stages remain separately ordered; spec approval precedes dependent planning. Add no fixed call cap/profile count condition or incomplete-draft acceptance.
 
 <a id="design-and-planning"></a>
 <a id="design-path-and-plan-depth"></a>
@@ -55,7 +55,7 @@ Record depth separately from risk. Risk controls checks/review, not design paths
 
 If Bounded requires written spec, record necessity/scope using approved short design as basis. Planner returns proportional full spec/self-review; Orchestrator saves/reviews/obtains individual approval before dependent plan/preparation. Short design approval never substitutes. This applies recorded judgment, not new spec necessity. Required plans alone imply no written spec.
 
-Only Planner drafts. Never substitute Orchestrator-authored specs/plans. Return substantive omissions; unavailable/failed Planner stops work rather than transferring authorship. Design approval does not transfer ownership.
+Only Planner authors the first complete spec or plan draft and self-review. Orchestrator reviews and directly revises the same document before approval. Unavailable/failed Planner stops first drafting rather than transferring authorship. Design approval does not transfer initial authorship.
 
 <a id="top-level-plan-tasks"></a>
 ## Top-level plan tasks
@@ -151,7 +151,7 @@ Generated from lib/policy/role-policy.json; do not edit this managed section man
 - [review.significant-plan] Significant/high-risk plan work follows Implementer → required fresh QA → Orchestrator acceptance and focused commit for each task. After all tasks are accepted and required QA is complete, Reviewer reviews the final full change once. Reviewer is not a per-task or per-commit gate. Preserve required checks and necessary finding rechecks.
 - [review.final-plan-recheck] Final overall Reviewer findings on plan work, including behavior findings, follow Implementer → Reviewer without QA reassignment until resolved. This exception applies only at the final plan stage. Preserve required QA and QA failure rechecks before the initial final review and outside this exception.
 - [planning.plan-amend] Mechanical plan progress records during approved execution need no new user approval. Changes to goals, scope, criteria, method, risk, dependencies or required verification need revised-version approval and preparation before affected work. In both cases Orchestrator amends the original planning-document commit at a safe boundary, with no separate document or fixup commit. Preserve actual approval chronology, recoverable old/new content, hashes, versions and SHA mappings; never authorize past work retroactively. Rewrite only unpublished, unshared local linear history with clear ownership and no merges. Unknown publication/ownership, unexpected state or replay conflicts stop rewriting; no force push or fallback document commit. Preserve implementation task boundaries and revalidate affected evidence. Follow planning, handoff-prep, commit and verification for the full contract.
-- [planning.planner-brief] Follow planning.md's Planner drafting preparation and consolidated feedback procedure, including preflight, ledger, evidence classification, target preparation, preceding approvals, provenance and reference gates. Allow the initial draft and one consolidated correction. Send one complete stage-specific initial brief. Planner returns a complete proportional draft and self-review. Orchestrator reviews once with the fixed checklist and sends one consolidated correction using changed fields only. Further calls require user-approved material scope/evidence changes or concrete unmet checklist items after correction, plus meaningful new input or criterion-state progress. State changed input, target criterion, expected artifact and expected progress. Hold repeated unmet criteria without new input, evidence or progress; report the criterion, observed evidence and exact unblock input/decision. Do not split omissions, repeat resolved items or count rewording/agent replacement as progress. Do not invoke Planner only for reformatting, re-expression, save errors or patch-application errors; Orchestrator handles these. Evaluate separate substantive work under the normal Planner gate. Preserve separate sequential design/spec/plan approvals. Add no fixed call cap or profile call-count conditions, and never accept an incomplete draft. Keep user progress brief and based on Planner status without relaying draft content. At approval, present the integrated, saved and reviewed Markdown without repeating its body in chat.
+- [planning.planner-brief] Follow planning.md's Planner drafting preparation and review procedure, including preflight, ledger, evidence classification, target preparation, preceding approvals, provenance and reference gates. Send one complete stage-specific initial brief. Planner returns a complete proportional first draft and self-review. Orchestrator reviews and directly revises the same spec or plan when needed. A missing or failed first draft does not transfer initial authorship to Orchestrator. New product decisions outside approved scope require user input before Orchestrator revises the document. For design and brainstorming, allow the initial draft and one consolidated correction. Orchestrator reviews once with the fixed checklist and sends one consolidated correction using changed fields only. Further calls require user-approved material scope/evidence changes or concrete unmet checklist items after correction, plus meaningful new input or criterion-state progress. State changed input, target criterion, expected artifact and expected progress. Repeated unmet criteria without new input, evidence or progress hold the stage; report the criterion, observed evidence and exact unblock input/decision. Do not split omissions, repeat resolved items or count rewording/agent replacement as progress. Do not invoke Planner only for reformatting, re-expression, save errors or patch-application errors; Orchestrator handles these. Evaluate separate substantive work under the normal Planner gate. Preserve separate sequential design/spec/plan approvals. Add no fixed call cap or profile call-count conditions, and never accept an incomplete draft. Keep user progress brief and based on Planner status without relaying draft content. At approval, present the integrated, saved and reviewed Markdown without repeating its body in chat.
 - [platform.codex] Role restrictions are prompt-level contracts, not a filesystem sandbox. ARC supplies no native observer hook or role-specific Git guard. Existing shell capabilities are retained because static read access after shell reduction has not been verified; Implementer and QA need shell for approved checks.
 [ARC role policy: contract end]
 

package/codex/skill/references/superpowers-provenance.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 1,
   "repository": "https://github.com/obra/superpowers",
-  "revision": "bb92a77741419a4ab5f06e711a283343f1ada0c3",
-  "fetchedAt": "2026-10-17T07:50:01.077Z",
+  "revision": "2ce8aa15d05bd57213e6f746f953aafb7ded7a8b",
+  "fetchedAt": "2026-10-29T17:10:27.098Z",
   "skills": [
     "brainstorming",
     "writing-plans",
@@ -10,7 +10,7 @@
   ],
   "files": {
     "LICENSE": "a37e0e9697144819e1d965176ac4ae5bc3fa02d11e7812036bbcadf6dafe2400",
-    "brainstorming/SKILL.md": "6ee10d1481b8a2580d5336ff66c5c08acc9d4b251b13bbc3bfd31be99c261d43",
+    "brainstorming/SKILL.md": "61a7ef918652108c76a3fd01e02dd92d39996c6b46d4cb2819cbd03f6c45e46a",
     "brainstorming/builder-check-prompt.md": "36d51a4723d6f0a3ce5811a0ea3b3a8424f07533947e1355f5d8cb8cce40c55e",
     "brainstorming/scripts/frame-template.html": "6a8a4e58bd6a44b904e2e3c57de774481d909204597e1498de53f1b2fecc4c4e",
     "brainstorming/scripts/helper.js": "43c6d69954a46ec34a2a262bcc62a9a7e83e839c739f199cb72646d397c686e3",

package/codex/skill/runtime/role-policy.json

@@ -150,7 +150,7 @@
         "role-ownership"
       ],
       "authority": "orchestrator",
-      "text": "Assign design/spec/plan/brainstorming drafts only to Planner and implementation/configuration/test edits to Implementer. Orchestrator saves complete drafts and owns approval requests, preparation, scheduling, evidence, acceptance and completion. Direct implementation remains limited to the existing small, low-risk path. Use a fresh Implementer per top-level task and a fresh QA per task requiring QA; QA findings alone do not create a new task. While approved scope, workspace, ownership and assignment context remain valid, default same-task corrections to the current Implementer and post-fix rechecks to the current QA. Replace or restart a role only for invalid/unavailable context or a changed task boundary, except that an approved plan or acceptance-criteria amendment requires a fresh Implementer even within the same task. Before Implementer reuse, refresh actual workspace, branch/HEAD and change state. QA reruns reproduction and invalidated related checks and reports actor, target state, outcomes and limits. Preserve task-boundary acceptance and the final plan Reviewer correction exception.",
+      "text": "Assign design/brainstorming drafts and first complete spec/plan drafts only to Planner and implementation/configuration/test edits to Implementer. Orchestrator saves and reviews complete spec/plan drafts and directly revises the same document when needed. Missing or failed first drafts do not transfer initial authorship. New product decisions outside approved scope require user input before revision. Orchestrator owns approval requests, preparation, scheduling, evidence, acceptance and completion. Direct implementation remains limited to the existing small, low-risk path. Use a fresh Implementer per top-level task and a fresh QA per task requiring QA; QA findings alone do not create a new task. While approved scope, workspace, ownership and assignment context remain valid, default same-task corrections to the current Implementer and post-fix rechecks to the current QA. Replace or restart a role only for invalid/unavailable context or a changed task boundary, except that an approved plan or acceptance-criteria amendment requires a fresh Implementer even within the same task. Before Implementer reuse, refresh actual workspace, branch/HEAD and change state. QA reruns reproduction and invalidated related checks and reports actor, target state, outcomes and limits. Preserve task-boundary acceptance and the final plan Reviewer correction exception.",
       "controls": {
         "codex": "prompt",
         "claude": "prompt"
@@ -190,7 +190,7 @@
         "approved-spec-before-dependent-plan"
       ],
       "authority": "orchestrator",
-      "text": "Return design/spec/plan drafts with dependencies, criteria, holds and verification needs in the response. During initial drafting and revisions, report progress only to Orchestrator: briefly state the stage, feedback being applied, actual blocker or next step, without draft prose or excerpts. Return the complete draft and self-review for review and correction. Raw responses may appear in app/tool surfaces; prompt policy cannot hide them. Do not save documents, implement, run checks, prepare targets, request user approval or decide acceptance. Stop formal target-dependent drafting when actual prepared-target evidence is missing. Route decisions to Orchestrator.",
+      "text": "Return design/brainstorming drafts and complete first spec/plan drafts with dependencies, criteria, holds and verification needs in the response. During initial drafting and revisions, report progress only to Orchestrator: briefly state the stage, feedback being applied, actual blocker or next step, without draft prose or excerpts. Return the complete first draft and self-review for Orchestrator review; Orchestrator directly revises the same spec or plan when needed. Raw responses may appear in app/tool surfaces; prompt policy cannot hide them. Do not save documents, implement, run checks, prepare targets, request user approval or decide acceptance. Stop formal target-dependent drafting when actual prepared-target evidence is missing. Route decisions to Orchestrator.",
       "controls": {
         "codex": "prompt",
         "claude": "prompt"
@@ -372,7 +372,7 @@
         "preceding-approval"
       ],
       "authority": "orchestrator",
-      "text": "Follow planning.md's Planner drafting preparation and consolidated feedback procedure, including preflight, ledger, evidence classification, target preparation, preceding approvals, provenance and reference gates. Allow the initial draft and one consolidated correction. Send one complete stage-specific initial brief. Planner returns a complete proportional draft and self-review. Orchestrator reviews once with the fixed checklist and sends one consolidated correction using changed fields only. Further calls require user-approved material scope/evidence changes or concrete unmet checklist items after correction, plus meaningful new input or criterion-state progress. State changed input, target criterion, expected artifact and expected progress. Hold repeated unmet criteria without new input, evidence or progress; report the criterion, observed evidence and exact unblock input/decision. Do not split omissions, repeat resolved items or count rewording/agent replacement as progress. Do not invoke Planner only for reformatting, re-expression, save errors or patch-application errors; Orchestrator handles these. Evaluate separate substantive work under the normal Planner gate. Preserve separate sequential design/spec/plan approvals. Add no fixed call cap or profile call-count conditions, and never accept an incomplete draft. Keep user progress brief and based on Planner status without relaying draft content. At approval, present the integrated, saved and reviewed Markdown without repeating its body in chat.",
+      "text": "Follow planning.md's Planner drafting preparation and review procedure, including preflight, ledger, evidence classification, target preparation, preceding approvals, provenance and reference gates. Send one complete stage-specific initial brief. Planner returns a complete proportional first draft and self-review. Orchestrator reviews and directly revises the same spec or plan when needed. A missing or failed first draft does not transfer initial authorship to Orchestrator. New product decisions outside approved scope require user input before Orchestrator revises the document. For design and brainstorming, allow the initial draft and one consolidated correction. Orchestrator reviews once with the fixed checklist and sends one consolidated correction using changed fields only. Further calls require user-approved material scope/evidence changes or concrete unmet checklist items after correction, plus meaningful new input or criterion-state progress. State changed input, target criterion, expected artifact and expected progress. Repeated unmet criteria without new input, evidence or progress hold the stage; report the criterion, observed evidence and exact unblock input/decision. Do not split omissions, repeat resolved items or count rewording/agent replacement as progress. Do not invoke Planner only for reformatting, re-expression, save errors or patch-application errors; Orchestrator handles these. Evaluate separate substantive work under the normal Planner gate. Preserve separate sequential design/spec/plan approvals. Add no fixed call cap or profile call-count conditions, and never accept an incomplete draft. Keep user progress brief and based on Planner status without relaying draft content. At approval, present the integrated, saved and reviewed Markdown without repeating its body in chat.",
       "controls": {
         "codex": "prompt",
         "claude": "prompt"

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

@@ -39,5 +39,5 @@ export function renderWaitSettings(original){
  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/plan.mjs

@@ -1,7 +1,8 @@
 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');
@@ -15,9 +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));
+ 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}){
@@ -45,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/management/operations.mjs

@@ -21,7 +21,7 @@ export async function prepareOperation(context,options,{selections=[]}={}){
  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,removeCompletion:options.removeCli!==false});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);

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/policy/role-policy.json

@@ -150,7 +150,7 @@
         "role-ownership"
       ],
       "authority": "orchestrator",
-      "text": "Assign design/spec/plan/brainstorming drafts only to Planner and implementation/configuration/test edits to Implementer. Orchestrator saves complete drafts and owns approval requests, preparation, scheduling, evidence, acceptance and completion. Direct implementation remains limited to the existing small, low-risk path. Use a fresh Implementer per top-level task and a fresh QA per task requiring QA; QA findings alone do not create a new task. While approved scope, workspace, ownership and assignment context remain valid, default same-task corrections to the current Implementer and post-fix rechecks to the current QA. Replace or restart a role only for invalid/unavailable context or a changed task boundary, except that an approved plan or acceptance-criteria amendment requires a fresh Implementer even within the same task. Before Implementer reuse, refresh actual workspace, branch/HEAD and change state. QA reruns reproduction and invalidated related checks and reports actor, target state, outcomes and limits. Preserve task-boundary acceptance and the final plan Reviewer correction exception.",
+      "text": "Assign design/brainstorming drafts and first complete spec/plan drafts only to Planner and implementation/configuration/test edits to Implementer. Orchestrator saves and reviews complete spec/plan drafts and directly revises the same document when needed. Missing or failed first drafts do not transfer initial authorship. New product decisions outside approved scope require user input before revision. Orchestrator owns approval requests, preparation, scheduling, evidence, acceptance and completion. Direct implementation remains limited to the existing small, low-risk path. Use a fresh Implementer per top-level task and a fresh QA per task requiring QA; QA findings alone do not create a new task. While approved scope, workspace, ownership and assignment context remain valid, default same-task corrections to the current Implementer and post-fix rechecks to the current QA. Replace or restart a role only for invalid/unavailable context or a changed task boundary, except that an approved plan or acceptance-criteria amendment requires a fresh Implementer even within the same task. Before Implementer reuse, refresh actual workspace, branch/HEAD and change state. QA reruns reproduction and invalidated related checks and reports actor, target state, outcomes and limits. Preserve task-boundary acceptance and the final plan Reviewer correction exception.",
       "controls": {
         "codex": "prompt",
         "claude": "prompt"
@@ -190,7 +190,7 @@
         "approved-spec-before-dependent-plan"
       ],
       "authority": "orchestrator",
-      "text": "Return design/spec/plan drafts with dependencies, criteria, holds and verification needs in the response. During initial drafting and revisions, report progress only to Orchestrator: briefly state the stage, feedback being applied, actual blocker or next step, without draft prose or excerpts. Return the complete draft and self-review for review and correction. Raw responses may appear in app/tool surfaces; prompt policy cannot hide them. Do not save documents, implement, run checks, prepare targets, request user approval or decide acceptance. Stop formal target-dependent drafting when actual prepared-target evidence is missing. Route decisions to Orchestrator.",
+      "text": "Return design/brainstorming drafts and complete first spec/plan drafts with dependencies, criteria, holds and verification needs in the response. During initial drafting and revisions, report progress only to Orchestrator: briefly state the stage, feedback being applied, actual blocker or next step, without draft prose or excerpts. Return the complete first draft and self-review for Orchestrator review; Orchestrator directly revises the same spec or plan when needed. Raw responses may appear in app/tool surfaces; prompt policy cannot hide them. Do not save documents, implement, run checks, prepare targets, request user approval or decide acceptance. Stop formal target-dependent drafting when actual prepared-target evidence is missing. Route decisions to Orchestrator.",
       "controls": {
         "codex": "prompt",
         "claude": "prompt"
@@ -372,7 +372,7 @@
         "preceding-approval"
       ],
       "authority": "orchestrator",
-      "text": "Follow planning.md's Planner drafting preparation and consolidated feedback procedure, including preflight, ledger, evidence classification, target preparation, preceding approvals, provenance and reference gates. Allow the initial draft and one consolidated correction. Send one complete stage-specific initial brief. Planner returns a complete proportional draft and self-review. Orchestrator reviews once with the fixed checklist and sends one consolidated correction using changed fields only. Further calls require user-approved material scope/evidence changes or concrete unmet checklist items after correction, plus meaningful new input or criterion-state progress. State changed input, target criterion, expected artifact and expected progress. Hold repeated unmet criteria without new input, evidence or progress; report the criterion, observed evidence and exact unblock input/decision. Do not split omissions, repeat resolved items or count rewording/agent replacement as progress. Do not invoke Planner only for reformatting, re-expression, save errors or patch-application errors; Orchestrator handles these. Evaluate separate substantive work under the normal Planner gate. Preserve separate sequential design/spec/plan approvals. Add no fixed call cap or profile call-count conditions, and never accept an incomplete draft. Keep user progress brief and based on Planner status without relaying draft content. At approval, present the integrated, saved and reviewed Markdown without repeating its body in chat.",
+      "text": "Follow planning.md's Planner drafting preparation and review procedure, including preflight, ledger, evidence classification, target preparation, preceding approvals, provenance and reference gates. Send one complete stage-specific initial brief. Planner returns a complete proportional first draft and self-review. Orchestrator reviews and directly revises the same spec or plan when needed. A missing or failed first draft does not transfer initial authorship to Orchestrator. New product decisions outside approved scope require user input before Orchestrator revises the document. For design and brainstorming, allow the initial draft and one consolidated correction. Orchestrator reviews once with the fixed checklist and sends one consolidated correction using changed fields only. Further calls require user-approved material scope/evidence changes or concrete unmet checklist items after correction, plus meaningful new input or criterion-state progress. State changed input, target criterion, expected artifact and expected progress. Repeated unmet criteria without new input, evidence or progress hold the stage; report the criterion, observed evidence and exact unblock input/decision. Do not split omissions, repeat resolved items or count rewording/agent replacement as progress. Do not invoke Planner only for reformatting, re-expression, save errors or patch-application errors; Orchestrator handles these. Evaluate separate substantive work under the normal Planner gate. Preserve separate sequential design/spec/plan approvals. Add no fixed call cap or profile call-count conditions, and never accept an incomplete draft. Keep user progress brief and based on Planner status without relaying draft content. At approval, present the integrated, saved and reviewed Markdown without repeating its body in chat.",
       "controls": {
         "codex": "prompt",
         "claude": "prompt"