claude-multiacc 2.0.31 → 2.0.32

package/docs/CODEX.md

@@ -88,16 +88,19 @@ The addon does not choose delegation policy by default. To manage the concurrent
 subagent ceiling across one Codex pool, explicitly configure it (Python 3.11+):
 
 ```bash
-codex-accounts configure --max-subagents 8 --include-global --json
-codex-accounts configure --max-subagents 8 --include-global --check --json
+codex-accounts configure --max-subagents 7 --include-global --json
+codex-accounts configure --max-subagents 7 --include-global --check --json
 ```
 
 An explicitly selected modern Python is preserved. If the shell resolves an older
 system Python, this command tries already installed Python 3.11+ executables on
 PATH and in standard Homebrew locations, with bounded probes and no downloads.
 
-The first command sets `agents.max_concurrent_threads_per_session` in every manifest
+The first command sets `features.multi_agent_v2.max_concurrent_threads_per_session`
+and the compatible `agents.max_concurrent_threads_per_session` in every manifest
 account's `config.toml`, migrating its legacy `agents.max_threads` key when present.
+An existing boolean `multi_agent_v2` becomes a table with the same `enabled` value;
+an existing feature cap is updated along with the agents cap.
 `--include-global` also updates the machine's `~/.codex/config.toml`; without it,
 the global file is untouched. Unrelated models, instructions, MCP servers, project
 trust and custom agents remain intact. Retired directories outside the manifest
@@ -112,16 +115,16 @@ fails sync instead of reporting success. Remote sync does not change the target'
 global config. Without the policy file, existing settings keep their usual
 copy-only-if-missing behavior and no new remote command runs.
 
-`--check` never writes; it checks the requested value against the persisted policy
-and selected configs, returning exit 1 on drift. Without `--max-subagents`, the
-command only reads the current pool policy and configuration. JSON reports contain
+`--check` never writes; it checks both caps against the persisted policy
+and requested value in selected configs, returning exit 1 on drift. Without
+`--max-subagents`, the command only reads the current pool policy and configuration. JSON reports contain
 the installed `plugin_version`, `max_subagents`, `policy_max_subagents`,
 `accounts_total`, `accounts_configured`, `global_configured`, `mismatch_count` and
 `verified`, without account identities, paths, credentials or arbitrary config.
 
-Conflicting profile or `features.multi_agent_v2` object overrides are rejected.
+Conflicting profile overrides are rejected.
 Unusual inline-table layouts are also rejected before configuration changes;
-use an ordinary `[agents]` table for the managed setting. All target configs are
-validated before writes, each replacement is atomic, and repeating the command
+use ordinary `[agents]` and `[features.multi_agent_v2]` tables for the managed settings.
+All target configs are validated before writes, each replacement is atomic, and repeating the command
 repairs an interrupted write. Existing running sessions retain the settings they
 loaded; the policy applies to subsequent sessions.

package/lib/codex_config_edit.py

@@ -8,7 +8,6 @@ except ImportError:
     raise SystemExit("Codex settings configuration requires Python 3.11 or newer") from None
 
 KEY = "max_concurrent_threads_per_session"
-ALIASES = (KEY, "max_threads")
 
 
 def limits(document):
@@ -33,39 +32,61 @@ def validate_overrides(document, value):
             raise ValueError(f"{name}: profile overrides the requested subagent limit")
 
 
+def dotted_pattern(parts):
+    return r'\s*\.\s*'.join(r'(?:' + re.escape(part) + r'|"' + re.escape(part)
+                            + r'"|\x27' + re.escape(part) + r'\x27)' for part in parts)
+
+
+def edit_setting(source, table, key, literal, aliases=()):
+    """Edit table/dotted assignments, or remove one when literal is None."""
+    headers = [re.compile(r'^\s*\[\s*' + dotted_pattern(table[:depth]) + r'\s*\]\s*(?:#.*)?$')
+               for depth in range(1, len(table) + 1)]
+    assignments = [re.compile(r'^\s*(?:' + '|'.join(dotted_pattern((*table[depth:], name))
+                                                 for name in (key, *aliases)) + r')\s*=')
+                   for depth in range(len(table) + 1)]
+    section, output, inserted = 0, [], False
+    for line in source.splitlines(keepends=True):
+        if line.lstrip().startswith("["):
+            section = next((depth for depth, header in enumerate(headers, 1)
+                            if header.match(line.rstrip("\r\n"))), None)
+            if section == len(table) and literal is not None and not inserted:
+                output.extend([line.rstrip("\r\n") + "\n", f"{key} = {literal}\n"])
+                inserted = True
+                continue
+        if section is not None and assignments[section].match(line):
+            if literal is not None and not inserted:
+                output.append(f"{'.'.join((*table[section:], key))} = {literal}\n")
+                inserted = True
+            continue
+        output.append(line)
+    if literal is not None and not inserted:
+        output.extend([f"\n[{'.'.join(table)}]\n", f"{key} = {literal}\n"])
+    return "".join(output)
+
+
 def updated_config(source, value):
-    """Edit ordinary [agents] or dotted keys, then prove no unrelated TOML value changed."""
+    """Set the v2 feature cap and agents fallback, preserving enablement and unrelated values."""
     original = tomllib.loads(source)
-    validate_overrides(original, value)
+    validate_overrides({"profiles": original.get("profiles", {})}, value)
     expected = copy.deepcopy(original)
     agents = expected.setdefault("agents", {})
     agents.pop("max_threads", None)
     agents[KEY] = value
-    lines, section, output, inserted = source.splitlines(keepends=True), "", [], False
-    header = re.compile(r'^\s*\[\s*(?:agents|"agents"|\x27agents\x27)\s*\]\s*(?:#.*)?$')
-    assignment = re.compile(r'^\s*(?:"|\x27)?(?:' + '|'.join(ALIASES) + r')(?:"|\x27)?\s*=')
-    dotted = re.compile(r'^\s*agents\s*\.\s*(?:' + '|'.join(ALIASES) + r')\s*=')
-    for line in lines:
-        if header.match(line.rstrip("\r\n")):
-            section = "agents"
-            output.extend([line.rstrip("\r\n") + "\n", f"{KEY} = {value}\n"])
-            inserted = True
-            continue
-        if line.lstrip().startswith("["):
-            section = "other"
-        if (section == "agents" and assignment.match(line)) or (not section and dotted.match(line)):
-            continue
-        output.append(line)
-    if not inserted:
-        if any(dotted.match(line) for line in lines):
-            output.insert(0, f"agents.{KEY} = {value}\n")
-        else:
-            output.extend(["\n[agents]\n", f"{KEY} = {value}\n"])
-    result = "".join(output)
+    features = expected.setdefault("features", {})
+    feature = features.get("multi_agent_v2")
+    result = edit_setting(source, ("agents",), KEY, value, ("max_threads",))
+    if isinstance(feature, bool):
+        result = edit_setting(result, ("features",), "multi_agent_v2", None)
+        result = edit_setting(result, ("features", "multi_agent_v2"), "enabled", str(feature).lower())
+        features["multi_agent_v2"] = {"enabled": feature}
+    elif feature is None:
+        features["multi_agent_v2"] = {}
+    features["multi_agent_v2"][KEY] = value
+    result = edit_setting(result, ("features", "multi_agent_v2"), KEY, value)
     try:
         unchanged = tomllib.loads(result) == expected
     except tomllib.TOMLDecodeError:
         unchanged = False
     if not unchanged:
-        raise ValueError("unsupported agents TOML layout; use a normal [agents] table before configuring")
+        raise ValueError("unsupported Codex TOML layout; use normal [agents] and [features.multi_agent_v2] tables")
     return result

package/lib/codex_settings.py

@@ -92,7 +92,9 @@ def readback(paths, value):
     result = {}
     for path in paths:
         document = tomllib.loads(path.read_text()) if path.exists() else {}
-        matches = limits(document)["effective"] == value if value is not None else True
+        current = limits(document)
+        matches = (all(current[key] == value for key in ("configured", "feature_override"))
+                   if value is not None else True)
         try:
             validate_overrides(document, value)
         except ValueError:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-multiacc",
-  "version": "2.0.31",
+  "version": "2.0.32",
   "description": "Unified Claude Code and OpenAI Codex subscription pooling with quota-aware selection.",
   "type": "module",
   "bin": {

package/tests/test_codex_config_edit.py

@@ -33,14 +33,30 @@ class CodexConfigEditTests(unittest.TestCase):
                 self.assertEqual(tomllib.loads(updated)["agents"][KEY], 8)
                 self.assertEqual(updated_config(updated, 8), updated)
 
-    def test_conflicting_feature_and_profile_overrides_are_rejected(self):
-        for source in ('[features.multi_agent_v2]\nmax_concurrent_threads_per_session = 20\n',
+    def test_conflicting_profile_overrides_are_rejected(self):
+        for source in ('[profiles.quick.features.multi_agent_v2]\nmax_concurrent_threads_per_session = 20\n',
                        '[profiles.quick.agents]\nmax_threads = 20\n'):
             with self.subTest(source=source), self.assertRaisesRegex(ValueError, "overrides"):
                 updated_config(source, 8)
         source = '[features.multi_agent_v2]\nmax_concurrent_threads_per_session = 8\n'
         self.assertEqual(tomllib.loads(updated_config(source, 8))["agents"][KEY], 8)
 
+    def test_existing_eight_thread_policies_and_feature_overrides_change_to_seven(self):
+        for feature in ('[features]\nmulti_agent_v2 = true\n',
+                        '[features]\nmulti_agent_v2 = false\n',
+                        '[features.multi_agent_v2]\nenabled = true\nmax_concurrent_threads_per_session = 20\n',
+                        'features.multi_agent_v2.max_concurrent_threads_per_session = 8\n',
+                        '[features]\nmulti_agent_v2.max_concurrent_threads_per_session = 8\n'):
+            source = feature + '[agents]\nmax_concurrent_threads_per_session = 8\n'
+            with self.subTest(feature=feature):
+                updated = updated_config(source, 7)
+                document = tomllib.loads(updated)
+                self.assertEqual(document["agents"][KEY], 7)
+                self.assertEqual(document["features"]["multi_agent_v2"][KEY], 7)
+                if 'false' in feature:
+                    self.assertFalse(document["features"]["multi_agent_v2"]["enabled"])
+                self.assertEqual(updated_config(updated, 7), updated)
+
     def test_unsupported_layouts_and_string_lookalikes_fail_safely(self):
         for source in ('agents = { max_threads = 4 }\n',
                        'instructions = """\n[agents]\nmax_threads = 99\n"""\n'):

package/tests/test_codex_settings.py

@@ -79,13 +79,31 @@ class CodexSettingsTests(unittest.TestCase):
 
     def test_invalid_config_is_rejected_before_any_configuration_is_changed(self):
         before = self.account.read_text()
-        self.global_config.write_text('[features.multi_agent_v2]\nmax_concurrent_threads_per_session = 20\n')
+        self.global_config.write_text('[profiles.quick.features.multi_agent_v2]\n'
+                                      'max_concurrent_threads_per_session = 20\n')
         result = self.command("configure", "--max-subagents", "8", "--include-global", "--json")
         self.assertNotEqual(result.returncode, 0)
         self.assertIn("overrides", result.stderr)
         self.assertEqual(self.account.read_text(), before)
         self.assertFalse((self.pool / "codex-settings-policy.json").exists())
 
+    def test_seven_thread_policy_requires_v2_setting_and_repairs_legacy_only_configs(self):
+        result = self.command("configure", "--max-subagents", "8", "--include-global", "--json")
+        self.assertEqual(result.returncode, 0, result.stderr)
+        result = self.command("configure", "--max-subagents", "7", "--include-global", "--json")
+        self.assertEqual(result.returncode, 0, result.stderr)
+        for path in (self.account, self.global_config):
+            config = tomllib.loads(path.read_text())
+            self.assertEqual(config["features"]["multi_agent_v2"][KEY], 7)
+            self.assertEqual(config["agents"][KEY], 7)
+        self.account.write_text('[agents]\nmax_concurrent_threads_per_session = 7\n')
+        result = self.command("configure", "--include-global", "--check", "--json")
+        self.assertEqual(result.returncode, 1, result.stderr)
+        self.assertEqual(json.loads(result.stdout)["mismatch_count"], 1)
+        result = self.command("configure", "--max-subagents", "7", "--include-global", "--json")
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertTrue(json.loads(result.stdout)["verified"])
+
     def test_symlinked_global_config_remains_linked(self):
         self.account.unlink()
         self.account.symlink_to(self.global_config)