agent-bios 0.2.0 → 0.4.0

package/scripts/check-parity.sh

@@ -111,8 +111,41 @@ current-state dashboard|claude/CLAUDE.md|claude/guides/implementation-map.md
 Verification Menus|claude/CLAUDE.md|claude/guides/coding-staged-workflow.md
 real Microsoft Excel engine|claude/CLAUDE.md|claude/guides/coding-staged-workflow.md
 severity contract|README.md|claude/guides/coding-staged-workflow.md
+Ambient state|claude/CLAUDE.md|claude/guides/tooling-gotchas.md
+the full lifecycle of what you create|claude/CLAUDE.md|claude/guides/tooling-gotchas.md
+dual-provider frontier design drafts|claude/CLAUDE.md|claude/guides/cli-multi-model-workflow.md
 ANCHORS
 
+# Domain-manifest gate: bullet<->anchor bijection, file coverage, router
+# co-packaging (config/domains.json vs the monolith); its --self-test proves
+# every negative control still fails, so a green gate is falsifiable.
+if [ -f config/domains.json ]; then
+  python3 scripts/check-domains.py >/dev/null \
+    || { echo "FAIL: domains manifest gate (run scripts/check-domains.py)"; fail=1; }
+  python3 scripts/check-domains.py --self-test >/dev/null \
+    || { echo "FAIL: domains gate self-test missed a negative control"; fail=1; }
+  bash scripts/test-assemble.sh >/dev/null \
+    || { echo "FAIL: assembler scenario suite (run scripts/test-assemble.sh)"; fail=1; }
+fi
+
+# Learning record gate: config/learning.schema.json (collection-loop
+# SSOT) vs its fixtures; --self-test proves every mutation is still caught.
+if [ -f config/learning.schema.json ]; then
+  python3 scripts/check-learning.py >/dev/null \
+    || { echo "FAIL: learning record gate (run scripts/check-learning.py)"; fail=1; }
+  python3 scripts/check-learning.py --self-test >/dev/null \
+    || { echo "FAIL: learning gate self-test missed a negative control"; fail=1; }
+fi
+
+# Lexicon gate: forbid deprecated terminology tokens in live files
+# (LEXICON.md is the SSOT); --self-test proves the detector can fire.
+if [ -f LEXICON.md ]; then
+  python3 scripts/check-lexicon.py >/dev/null \
+    || { echo "FAIL: lexicon gate (run scripts/check-lexicon.py)"; fail=1; }
+  python3 scripts/check-lexicon.py --self-test >/dev/null \
+    || { echo "FAIL: lexicon gate self-test failed"; fail=1; }
+fi
+
 # The launcher's Textual preflight UI tests need the managed venv (textual).
 # Provision it if missing; every non-UI check above runs under system python.
 VENV="${AGENT_LAUNCH_VENV:-$HOME/.local/share/agent-launch/venv}"
@@ -264,6 +297,33 @@ for filename, (expected_name, expected_model, expected_effort) in expected_agent
             f"want {expected_effort!r}"
         )
 
+# codex/config-additions.toml is the additive fragment install merges into the
+# live ~/.codex/config.toml; its agent entries are projections of the canonical
+# codex/agents/*.toml templates and must not drift from them.
+fragment_path = pathlib.Path("codex/config-additions.toml")
+if not fragment_path.is_file():
+    mark_fail("required file missing: codex/config-additions.toml")
+else:
+    fragment = tomllib.loads(fragment_path.read_text())
+    if fragment.get("features", {}).get("multi_agent") is not True:
+        mark_fail("config-additions must set features.multi_agent = true")
+    fragment_agents = fragment.get("agents", {})
+    if set(fragment_agents) != {"frontier", "workhorse", "sweep"}:
+        mark_fail(
+            "config-additions agents must be exactly the spawnable tiers "
+            f"(no helm): {sorted(fragment_agents)}"
+        )
+    for tier, spec in fragment_agents.items():
+        template_path = agent_dir / f"{tier}.toml"
+        template = tomllib.loads(template_path.read_text()) if template_path.is_file() else {}
+        if spec.get("description") != template.get("description"):
+            mark_fail(f"config-additions {tier} description drifted from {template_path}")
+        if spec.get("config_file") != f"${{CODEX_HOME}}/agents/{tier}.toml":
+            mark_fail(
+                f"config-additions {tier} config_file must be "
+                f"${{CODEX_HOME}}/agents/{tier}.toml"
+        )
+
 
 def table_row(path, slot):
     for raw_line in path.read_text().splitlines():
@@ -522,7 +582,9 @@ if launcher.is_file() and launch_profile:
             def set_plan(self, plan):
                 self.plan = plan
 
-            def choose(self, title, options, default, allow_back, preview=None):
+            def choose(self, title, options, default, allow_back, preview=None, corpus_lines=None):
+                if title == "Mode":
+                    return "builder"
                 if title == "Preset":
                     if preview is not None:
                         balanced = launcher_module.setup_summary_lines(preview("balanced"))
@@ -743,11 +805,17 @@ if launcher.is_file() and launch_profile:
                 os.close(master)
             return bytes(transcript), picker_status
 
+        # Root menu is now a Mode picker (General user / Builder / Session
+        # distill); Builder is the default highlight and lists Custom. Reaching
+        # Custom means: Enter the root to open Builder's preset submenu, then
+        # step down through its fixed presets (Balanced default-highlighted).
         open_custom_steps = (
+            (b"Esc cancel | q cancel", b"\r"),
             (b"native multi-perspective review", b""),
-            (b"Esc cancel | q cancel", b"\x1b[B"),
+            (b"Esc back | q cancel", b"\x1b[B"),
             (b"hybrid onto", b"\x1b[B"),
             (b"high-volume", b"\x1b[B"),
+            (b"the standing spawn policy is lifted", b"\x1b[B"),
             (b"Open a settings hub", b"\r"),
         )
         down = b"\x1b[B"
@@ -768,7 +836,7 @@ if launcher.is_file() and launch_profile:
             b"WORKHORSE",
             b"SWEEP",
             b"About highlighted option",
-            b"HELM default for everyday work",
+            b"Tune tiers, review routes, and permissions",
             b"Options (",
         )
         positions = {token: transcript.find(token) for token in layout_tokens}
@@ -779,7 +847,7 @@ if launcher.is_file() and launch_profile:
             positions[b"Current setup"]
             < min(positions[token] for token in (b"FRONTIER", b"HELM", b"WORKHORSE", b"SWEEP"))
             < positions[b"About highlighted option"]
-            < positions[b"HELM default for everyday work"]
+            < positions[b"Tune tiers, review routes, and permissions"]
             < positions[b"Options ("]
         ):
             mark_fail("agent-launch layout is not setup then description then options")
@@ -791,12 +859,27 @@ if launcher.is_file() and launch_profile:
         if picker_status != 130:
             mark_fail(f"agent-launch root Esc returned {picker_status}, want 130")
 
+        # Root Mode picker navigation: Esc from the Builder preset submenu
+        # returns to a freshly re-rendered Mode picker (Builder's own
+        # description reappears) rather than cancelling the launcher outright.
+        _, picker_status = run_picker_scenario(
+            "mode picker navigation",
+            (
+                (b"Esc cancel | q cancel", b"\r"),
+                (b"native multi-perspective review", b"\x1b"),
+                (b"Tune tiers, review routes, and permissions", b"q"),
+            ),
+        )
+        if picker_status != 130:
+            mark_fail(f"agent-launch mode picker Esc-back returned {picker_status}, want 130")
+
         if argv_log.exists():
             argv_log.unlink()
         _, picker_status = run_picker_scenario(
             "launch confirmation q cancellation",
             (
                 (b"Esc cancel | q cancel", b"\r"),
+                (b"HELM default for everyday work", b"\r"),
                 (b"Launch? [Y/n/q]:", b"q\r"),
             ),
             dry_run=False,
@@ -1098,10 +1181,20 @@ if launcher.is_file() and launch_profile:
         # TERM=dumb routes to numbered prompts (textual renders on any usable
         # terminal, so the numbered fallback is gated on TERM/non-TTY/textual
         # availability, not a terminfo probe). 'b' is the numbered back command.
+        # The root Mode menu is fixed (General=1, Builder=2, Session distill=3)
+        # regardless of preset count; only Custom's position within Builder's
+        # own preset submenu depends on how many builder-mode presets exist.
+        builder_preset_count = sum(
+            1
+            for data in fake_data["presets"].values()
+            if data.get("mode", "builder") == "builder"
+        )
+        custom_number = str(builder_preset_count + 1).encode()
         transcript, picker_status = run_picker_scenario(
             "numbered fallback (TERM=dumb)",
             (
-                (b"Open a settings hub", b"4\n"),
+                (b"Tune tiers, review routes, and permissions", b"2\n"),
+                (b"Open a settings hub", custom_number + b"\n"),
                 (b"Custom settings", b"b\n"),
                 (b"HELM default for everyday work", b"1\n"),
             ),
@@ -1114,6 +1207,28 @@ if launcher.is_file() and launch_profile:
         ):
             mark_fail("agent-launch numbered fallback (TERM=dumb) did not preserve numbered back")
 
+        # Session Distill hub: enter, render status, back out, launch balanced.
+        transcript, picker_status = run_picker_scenario(
+            "numbered distill hub (TERM=dumb)",
+            (
+                (b"Session distill", b"3\n"),
+                (b"Versions & rollback", b"4\n"),
+                (b"Tune tiers, review routes, and permissions", b"2\n"),
+                (b"HELM default for everyday work", b"1\n"),
+            ),
+            term="dumb",
+        )
+        corpus_panel_rendered = (
+            b"Applied version" in transcript or b"not projected yet" in transcript
+        )
+        if (
+            picker_status != 0
+            or b"Traceback" in transcript
+            or not corpus_panel_rendered
+            or b"Preset         Balanced" not in transcript
+        ):
+            mark_fail("agent-launch numbered distill hub did not render or return")
+
         passed = invoke([
             sys.executable, str(launcher), "--no-tui", "codex", "--", "exec", "--json", "probe"
         ], env=env)
@@ -1421,7 +1536,16 @@ if launcher.is_file() and launch_profile:
             except (ValueError, IndexError, json.JSONDecodeError) as exc:
                 mark_fail(f"agent-launch Claude --agents projection is not valid JSON: {exc}")
             else:
-                for tier, (model, effort) in expected_claude_tiers.items():
+                expected_spawnable = {
+                    tier: expected_claude_tiers[tier]
+                    for tier in ("frontier", "workhorse", "sweep")
+                }
+                if set(agents_arg) != set(expected_spawnable):
+                    mark_fail(
+                        "Claude --agents must project exactly the spawnable tiers "
+                        f"(HELM is the main, never a subagent): {sorted(agents_arg)}"
+                    )
+                for tier, (model, effort) in expected_spawnable.items():
                     role = agents_arg.get(tier, {})
                     if role.get("model") != model or role.get("effort") != effort:
                         mark_fail(f"agent-launch Claude {tier} role projection drifted: {role!r}")
@@ -1430,6 +1554,29 @@ if launcher.is_file() and launch_profile:
                         "agent-launch Claude expert overrides were not appended last"
                     )
 
+        # Vanilla (mode=general): the raw backend with nothing applied — no
+        # launch contract, no agents, no permission-bypass flag.
+        vanilla_configured = invoke([
+            sys.executable, str(launcher), "--preset", "vanilla", "--yes", "--dry-run",
+            "claude",
+        ], env=env)
+        if vanilla_configured.returncode != 0:
+            mark_fail(
+                f"agent-launch vanilla dry-run failed: {vanilla_configured.stderr.strip()}"
+            )
+        else:
+            vanilla_argv = json.loads(vanilla_configured.stdout.splitlines()[-1])
+            for forbidden in (
+                "--append-system-prompt", "--agents", "--dangerously-skip-permissions",
+            ):
+                if forbidden in vanilla_argv:
+                    mark_fail(f"agent-launch vanilla preset unexpectedly carried {forbidden}")
+            if vanilla_argv != [str(backend)]:
+                mark_fail(
+                    "agent-launch vanilla preset must project the bare backend with "
+                    f"nothing applied: {vanilla_argv!r}"
+                )
+
         # Cross-family default: each main routes every review route to the OPPOSITE
         # model family, with concrete tools/paths/bindings named in the contract.
         # The cross CODEX_HOME needs the reviewer wrappers (bin) and the same-family
@@ -1704,5 +1851,5 @@ then
   fail=1
 fi
 
-[ "$fail" -eq 0 ] && echo "PARITY OK: mirrors, globals, guides, launch profile, bypass paths, role bindings, and wrapper defaults aligned"
+[ "$fail" -eq 0 ] && echo "PARITY OK: mirrors, globals, guides, domain manifest, assembler, launch profile, bypass paths, role bindings, and wrapper defaults aligned"
 exit "$fail"

package/scripts/codex-helm.sh

@@ -268,9 +268,27 @@ EOF
 EOF
 }
 
+# Review packets must carry the whole subject: range-based diffs silently omit
+# staged-but-uncommitted changes and untracked files, so the dispatcher itself
+# appends the subject tree's actual state to the packet.
+scope_note=""
+if [ "$mode" = "review" ] && { [ -n "$cd_dir" ] || [ "$reach" != "hermetic" ]; }; then
+  scope_root="${cd_dir:-$PWD}"
+  if git -C "$scope_root" rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+    scope_status="$(git -C "$scope_root" status --porcelain 2>/dev/null || true)"
+    if [ -n "$scope_status" ]; then
+      scope_note="Review scope manifest (dispatcher-generated \`git status --porcelain\` of the subject tree; uncommitted/untracked entries are part of the review subject unless the task says otherwise):
+$scope_status"
+      echo "codex-helm: subject tree has uncommitted/untracked entries; scope manifest appended to the packet" >&2
+    fi
+  fi
+fi
+
 final_prompt="$(build_preamble)
 
-User task:
+${scope_note:+$scope_note
+
+}User task:
 $user_prompt"
 
 cleanup_dirs=()

package/scripts/codex-run.sh

@@ -167,6 +167,25 @@ if [ "${#extra_c[@]}" -gt 0 ]; then
   for kv in "${extra_c[@]}"; do args+=(-c "$kv"); done
 fi
 
+# Dispatch audit: verifier diversity is only as real as the pinned backing
+# model — an unpinned dispatch inherits config defaults and can silently
+# collapse two "different" reviewers onto one backend. The audit line goes to
+# the log file only; stdout/stderr stay reserved for the codex channels.
+sandbox_label="$sandbox"
+if [ "$bypass_sandbox" -eq 1 ]; then sandbox_label="bypass"; fi
+cmodel=""
+if [ "${#extra_c[@]}" -gt 0 ]; then
+  for kv in "${extra_c[@]}"; do
+    case "$kv" in model=*) cmodel="${kv#model=}" ;; esac
+  done
+fi
+dispatch_note="dispatch profile=$profile model=${model:-INHERITED_DEFAULT}${cmodel:+ c-model-override=$cmodel} effort=${effort:-config-default} sandbox=$sandbox_label"
+if [ -z "$model" ] && [ -z "$cmodel" ]; then
+  echo "codex-run: WARNING: no --model pin; the backing model inherits the active config default" >&2
+fi
+mkdir -p "$real_home/log" 2>/dev/null || true
+printf '%s %s\n' "$(date +%Y-%m-%dT%H:%M:%S%z)" "$dispatch_note" >> "$real_home/log/codex-run-dispatch.log" 2>/dev/null || true
+
 # stdin, stdout, and stderr already match this adapter's channel contract.
 set +e
 CODEX_HOME="$run_home" codex "${args[@]}"