@event4u/agent-config 1.21.0 → 1.22.0

package/scripts/council_cli.py

@@ -63,6 +63,7 @@ def build_members(
     *,
     invocation_mode: str | None = None,
     model_overrides: dict[str, str] | None = None,
+    siblings_overrides: dict[str, list[str]] | None = None,
 ) -> list[ExternalAIClient]:
     """Construct enabled council members from settings.
 
@@ -73,6 +74,13 @@ def build_members(
     `model_overrides` is a per-invocation `{member_name: model_id}`
     map that wins over the per-member `model` in settings. Members not
     listed fall back to the settings value, then the per-client default.
+
+    `siblings_overrides` is a per-invocation `{member_name: [model, ...]}`
+    map that fans the named provider out to multiple sibling models in
+    one run (e.g. claude-sonnet-4-5 + claude-opus-4-1). Each model
+    becomes its own billable member with independent cost tracking.
+    Mutually exclusive with `model_overrides` for the same provider;
+    requires `mode=api`; provider must be enabled in settings.
     """
     ai = (settings.get("ai_council") or {}) if isinstance(settings, dict) else {}
     if not ai.get("enabled"):
@@ -83,16 +91,34 @@ def build_members(
     members_cfg = ai.get("members") or {}
     global_mode = ai.get("mode")
     overrides = model_overrides or {}
+    siblings = siblings_overrides or {}
     unknown = set(overrides) - set(members_cfg)
     if unknown:
         raise CouncilDisabledError(
             f"--model targets unknown member(s) {sorted(unknown)!r}; "
             f"known members: {sorted(members_cfg)!r}."
         )
+    unknown_sib = set(siblings) - set(members_cfg)
+    if unknown_sib:
+        raise CouncilDisabledError(
+            f"--siblings targets unknown member(s) {sorted(unknown_sib)!r}; "
+            f"known members: {sorted(members_cfg)!r}."
+        )
+    conflict = set(overrides) & set(siblings)
+    if conflict:
+        raise CouncilDisabledError(
+            f"--model and --siblings target the same member(s) {sorted(conflict)!r}; "
+            f"pick one per provider per invocation."
+        )
     members: list[ExternalAIClient] = []
     for name, cfg in members_cfg.items():
         cfg = cfg or {}
         if not cfg.get("enabled"):
+            if name in siblings:
+                raise CouncilDisabledError(
+                    f"--siblings targets member {name!r} but it is not "
+                    f"enabled in .agent-settings.yml (ai_council.members.{name}.enabled)."
+                )
             continue
         mode = resolve_mode(
             name,
@@ -100,13 +126,17 @@ def build_members(
             member_settings=cfg,
             global_mode=global_mode,
         )
+        if name in siblings:
+            if mode != "api":
+                raise CouncilDisabledError(
+                    f"--siblings requires mode=api for member {name!r} (got {mode!r})."
+                )
+            for sib_model in siblings[name]:
+                members.append(_construct_api_member(name, sib_model))
+            continue
         model = overrides.get(name) or cfg.get("model")
-        if mode == "api" and name == "anthropic":
-            members.append(AnthropicClient(model=model or "claude-sonnet-4-5",
-                                           api_key=load_anthropic_key()))
-        elif mode == "api" and name == "openai":
-            members.append(OpenAIClient(model=model or "gpt-4o",
-                                        api_key=load_openai_key()))
+        if mode == "api" and name in {"anthropic", "openai"}:
+            members.append(_construct_api_member(name, model))
         elif mode == "manual":
             members.append(ManualClient(name=name, model=model or "manual"))
         elif mode == "playwright":
@@ -125,6 +155,19 @@ def build_members(
     return members
 
 
+def _construct_api_member(name: str, model: str | None) -> ExternalAIClient:
+    """Build an api-mode client for a known provider name."""
+    if name == "anthropic":
+        return AnthropicClient(model=model or "claude-sonnet-4-5",
+                               api_key=load_anthropic_key())
+    if name == "openai":
+        return OpenAIClient(model=model or "gpt-4o",
+                            api_key=load_openai_key())
+    raise CouncilDisabledError(
+        f"member {name!r} has no api transport (known: anthropic, openai)."
+    )
+
+
 def build_question(
     *,
     input_path: Path,
@@ -164,6 +207,29 @@ def format_estimate_table(
 # ── subcommands ─────────────────────────────────────────────────────
 
 
+def _resolve_rounds(args: argparse.Namespace, ai_cfg: dict[str, Any]) -> int:
+    """Resolve effective debate round count from CLI args + settings.
+
+    Resolution chain (highest priority first):
+      1. ``--rounds N`` — explicit user override, any value.
+      2. ``--depth deep`` — uses ``ai_council.deep_min_rounds``,
+         floored at ``min_rounds`` so the deep tier is monotonic.
+      3. ``ai_council.min_rounds`` — default 2.
+
+    Sub-commands (rule/skill/command) declare ``council_depth: deep``
+    in their frontmatter; the host agent reads that and translates it
+    to ``--depth deep`` on the CLI invocation. The CLI itself stays
+    unaware of frontmatter — the contract is the flag.
+    """
+    if getattr(args, "rounds", None) is not None:
+        return int(args.rounds)
+    min_rounds = int(ai_cfg.get("min_rounds", 2))
+    if getattr(args, "depth", "standard") == "deep":
+        deep = int(ai_cfg.get("deep_min_rounds", min_rounds))
+        return max(deep, min_rounds)
+    return min_rounds
+
+
 def cmd_estimate(
     args: argparse.Namespace,
     *,
@@ -179,6 +245,7 @@ def cmd_estimate(
             settings,
             invocation_mode=args.mode_override,
             model_overrides=_parse_model_overrides(getattr(args, "model", None)),
+            siblings_overrides=_parse_siblings_overrides(getattr(args, "siblings", None)),
         )
     if table is None:
         table = load_prices()
@@ -239,6 +306,7 @@ def cmd_run(
             settings,
             invocation_mode=args.mode_override,
             model_overrides=_parse_model_overrides(getattr(args, "model", None)),
+            siblings_overrides=_parse_siblings_overrides(getattr(args, "siblings", None)),
         )
     if table is None:
         table = load_prices()
@@ -271,7 +339,7 @@ def cmd_run(
         max_calls=int(cost_cfg.get("max_calls", 10)),
         max_total_usd=float(cost_cfg.get("max_total_usd", 0.0) or 0.0),
     )
-    rounds = args.rounds if args.rounds is not None else int(ai_cfg.get("min_rounds", 2))
+    rounds = _resolve_rounds(args, ai_cfg)
     responses = consult(
         members, question, budget,
         table=table, project=project,
@@ -339,6 +407,38 @@ def _parse_model_overrides(items: list[str] | None) -> dict[str, str]:
     return out
 
 
+def _parse_siblings_overrides(items: list[str] | None) -> dict[str, list[str]]:
+    """Parse repeated `--siblings name=model1,model2[,...]` flags.
+
+    Requires ≥ 2 distinct, non-empty models per provider — sibling
+    mode without diversity has no purpose. Repeating the same provider
+    flag is rejected as ambiguous.
+    """
+    out: dict[str, list[str]] = {}
+    for raw in items or []:
+        if "=" not in raw:
+            raise argparse.ArgumentTypeError(
+                f"--siblings expects '<member>=<model1>,<model2>[,...]', got {raw!r}."
+            )
+        name, models_csv = raw.split("=", 1)
+        name = name.strip()
+        models = [m.strip() for m in models_csv.split(",") if m.strip()]
+        if not name or not models:
+            raise argparse.ArgumentTypeError(
+                f"--siblings member and model list must both be non-empty: {raw!r}."
+            )
+        if len(set(models)) < 2:
+            raise argparse.ArgumentTypeError(
+                f"--siblings requires ≥ 2 distinct models for {name!r}, got {models!r}."
+            )
+        if name in out:
+            raise argparse.ArgumentTypeError(
+                f"--siblings repeated for member {name!r}; combine into one flag."
+            )
+        out[name] = models
+    return out
+
+
 def _add_common_input_args(p: argparse.ArgumentParser) -> None:
     p.add_argument("question", type=str,
                    help="Path to the question file (text or roadmap).")
@@ -356,6 +456,16 @@ def _add_common_input_args(p: argparse.ArgumentParser) -> None:
                         "Wins over `ai_council.members.<name>.model` in "
                         ".agent-settings.yml; the settings file is not "
                         "modified.")
+    p.add_argument("--siblings", action="append", default=None, dest="siblings",
+                   metavar="MEMBER=MODEL1,MODEL2[,...]",
+                   help="Fan one provider out to ≥ 2 sibling models in a "
+                        "single run, e.g. --siblings anthropic=claude-sonnet-4-5,"
+                        "claude-opus-4-1. Each model becomes its own billable "
+                        "member with independent cost tracking. Mutually "
+                        "exclusive with --model for the same provider; "
+                        "requires the provider to be enabled with mode=api. "
+                        "Single-provider degraded-run strategy per ai-council "
+                        "skill.")
     p.add_argument("--original-ask", default="",
                    help="The user's framing sentence (flows into handoff).")
 
@@ -377,9 +487,16 @@ def build_parser() -> argparse.ArgumentParser:
     p_run.add_argument("--confirm", action="store_true",
                        help="Required to actually invoke the council.")
     p_run.add_argument("--rounds", type=int, default=None,
-                       help="Number of debate rounds (1-3). Defaults to "
-                            "ai_council.min_rounds in .agent-settings.yml "
-                            "(or 2 if unset).")
+                       help="Number of debate rounds (1-3). Explicit override; "
+                            "wins over --depth. Defaults to ai_council.min_rounds "
+                            "in .agent-settings.yml (or 2 if unset).")
+    p_run.add_argument("--depth", choices=["standard", "deep"], default="standard",
+                       help="Reasoning-depth tier. 'deep' floors rounds at "
+                            "ai_council.deep_min_rounds (max'd with min_rounds) "
+                            "for architecture, refactoring, or bug-diagnosis "
+                            "artefacts. Set by the host agent when the consuming "
+                            "rule/skill/command declares council_depth: deep. "
+                            "Overridden by explicit --rounds.")
 
     p_ren = sub.add_parser("render", help="Re-render a saved responses JSON.")
     p_ren.add_argument("responses",

package/scripts/migrate_command_suggestions.py

@@ -29,7 +29,7 @@ INELIGIBLE: dict[str, str] = {
     "copilot-agents-init": "Project init — only deliberately during onboarding.",
     "copilot-agents-optimize": "Maintenance refactor; only when the maintainer chooses to run it.",
     "do-and-judge": "Subagent orchestration — overlaps /work and judge skills; keep explicit.",
-    "do-in-steps": "Subagent orchestration — overlaps /work and /roadmap-execute; keep explicit.",
+    "do-in-steps": "Subagent orchestration — overlaps /work and /roadmap:process-*; keep explicit.",
     "fix-portability": "Package-internal — only the event4u/agent-config repo runs this.",
     "fix-references": "Package-internal — only the event4u/agent-config repo runs this.",
     "judge": "Sibling of /review-changes — eligibility routed there; keep this explicit.",
@@ -89,7 +89,7 @@ ELIGIBLE: dict[str, tuple[str, str]] = {
     "review-changes": ("self-review my changes, judge this diff before PR", "uncommitted or staged changes pre-PR"),
     "review-routing": ("who should review this, suggest reviewers for this PR", "PR open without assigned reviewers"),
     "roadmap-create": ("create a roadmap for X, plan this work as a roadmap", "multi-phase work without an existing agents/roadmaps/*.md"),
-    "roadmap-execute": ("execute the roadmap, work through the roadmap step by step", "existing agents/roadmaps/*.md referenced in the prompt"),
+    "roadmap-execute": ("process the roadmap, work through the roadmap autonomously, finish this phase", "existing agents/roadmaps/*.md referenced in the prompt"),
     "rule-compliance-audit": ("audit my rules, check rule trigger quality", "maintainer working on .augment/rules/ files"),
     "tests-create": ("write tests for these changes, add tests for this branch", "code changes on the branch without matching test changes"),
     "tests-execute": ("run the tests, execute the test suite", "code changes pending verification"),

package/scripts/schemas/command.schema.json

@@ -49,6 +49,11 @@
       "pattern": "^[0-9]+\\.[0-9]+\\.[0-9]+$",
       "description": "Semver release in which this command became a shim (e.g. '1.15.0')."
     },
+    "council_depth": {
+      "type": "string",
+      "enum": ["deep"],
+      "description": "Optional reasoning-depth marker for AI Council invocations triggered by this command. The only accepted value is 'deep'; omit the key for default depth (setting 'standard' is rejected — every frontmatter byte counts against the context window, and 'standard' is the implicit default). 'deep' instructs the host agent to pass --depth deep to council_cli, which floors rounds at max(ai_council.deep_min_rounds, ai_council.min_rounds). Use for architecture, refactoring, or bug-diagnosis commands. See .agent-src.uncompressed/skills/ai-council/SKILL.md."
+    },
     "suggestion": {
       "type": "object",
       "additionalProperties": false,

package/scripts/schemas/rule.schema.json

@@ -47,6 +47,11 @@
       "enum": ["1", "2a", "2b", "3", "safety-floor", "mechanical-already", "kernel", "tier-1", "tier-2"],
       "description": "Hardening tier. Legacy values (1/2a/2b/3/safety-floor/mechanical-already) accepted; new router-canonical values (kernel/tier-1/tier-2) introduced by road-to-kernel-and-router.md Phase 4."
     },
+    "council_depth": {
+      "type": "string",
+      "enum": ["deep"],
+      "description": "Optional reasoning-depth marker for AI Council invocations triggered while this rule is active. The only accepted value is 'deep'; omit the key for default depth (setting 'standard' is rejected — every frontmatter byte counts against the context window, and 'standard' is the implicit default). 'deep' instructs the host agent to pass --depth deep to council_cli, which floors rounds at max(ai_council.deep_min_rounds, ai_council.min_rounds). Use for rules that gate architecture, refactoring, or bug-diagnosis flows. See .agent-src.uncompressed/skills/ai-council/SKILL.md."
+    },
     "triggers": {
       "type": "array",
       "items": {

package/scripts/schemas/skill.schema.json

@@ -42,6 +42,11 @@
       "enum": ["senior"],
       "description": "Optional tier marker. `senior` opts the skill into the Senior-Tier Required Structure check (Context-First lead, Related Skills, Proactive Triggers, Output Artifacts) per .agent-src.uncompressed/rules/skill-quality.md."
     },
+    "council_depth": {
+      "type": "string",
+      "enum": ["deep"],
+      "description": "Optional reasoning-depth marker for AI Council invocations triggered by this skill. The only accepted value is 'deep'; omit the key for default depth (setting 'standard' is rejected — every frontmatter byte counts against the context window, and 'standard' is the implicit default). 'deep' instructs the host agent to pass --depth deep to council_cli, which floors rounds at max(ai_council.deep_min_rounds, ai_council.min_rounds). Use for architecture, refactoring, or bug-diagnosis skills. See .agent-src.uncompressed/skills/ai-council/SKILL.md."
+    },
     "execution": {
       "type": "object",
       "additionalProperties": false,

package/scripts/skill_linter.py

@@ -1042,7 +1042,7 @@ def _lint_command_suggestion_block(text: str) -> List[Issue]:
     suggestion = data.get("suggestion")
     if suggestion is None:
         issues.append(Issue(
-            "warning", "missing_suggestion_block",
+            "error", "missing_suggestion_block",
             "Command frontmatter is missing the 'suggestion' block — required by "
             "road-to-context-aware-command-suggestion Phase 2.",
         ))

package/.agent-src/commands/roadmap/execute.md

@@ -1,109 +0,0 @@
----
-name: roadmap:execute
-cluster: roadmap
-sub: execute
-skills: [agent-docs-writing]
-description: Read and interactively execute a roadmap from agents/roadmaps/
-disable-model-invocation: true
-suggestion:
-  eligible: true
-  trigger_description: "execute the roadmap, work through the roadmap step by step"
-  trigger_context: "existing agents/roadmaps/*.md referenced in the prompt"
----
-
-# /roadmap execute
-## Instructions
-
-### 1. Find the roadmap
-
-- List all roadmap files: `agents/roadmaps/*.md` (project root) and `app/Modules/*/agents/roadmaps/*.md` (modules).
-- Exclude `template.md`.
-- If only one roadmap exists → use it (confirm with user).
-- If multiple exist → present a numbered list and let the user choose.
-- If none exist → tell the user and suggest running `roadmap-create`.
-
-### 2. Read and understand the roadmap
-
-- Read the full roadmap file.
-- Identify the **phases** and **steps/tasks** within each phase.
-- Determine which steps are already completed (look for checkboxes `[x]`, status markers, or "done" notes).
-- Present a summary to the user:
-  > "Roadmap: {title}"
-  > "Phase 1: {name} — 3/5 Schritte erledigt"
-  > "Phase 2: {name} — noch nicht begonnen"
-  > "Next open step: {step description}"
-
-### 3. Resolve quality cadence (read once, before any step runs)
-
-Read `roadmap.quality_cadence` from `.agent-settings.yml`:
-
-| Value | When the project's quality pipeline runs |
-|---|---|
-| `end_of_roadmap` (default) | Once, in step 7 — before archiving |
-| `per_phase` | Once after every completed phase, plus step 7 |
-| `per_step` | After every completed step, plus step 7 (legacy verbose) |
-
-Missing key, unreadable file, or unknown value → fall back to `end_of_roadmap`.
-Cite the resolved cadence once in step 2's summary so the user can override it.
-
-The Iron Law `verify-before-complete` still applies — fresh quality
-output is mandatory before any "roadmap complete" claim, regardless of
-cadence. Step checkboxes and `agents/roadmaps-progress.md` are ALWAYS
-updated in the same response per `roadmap-progress-sync`; cadence only
-gates the *quality pipeline*, not progress tracking.
-
-### 4. Execute step by step
-
-For each open step:
-
-1. **Summarize** what needs to be done (in the user's language).
-2. **Analyze** the codebase to understand what's needed for this step.
-3. **Present a plan** — what files to change, what approach to take.
-4. **Ask for confirmation**: "Should I implement this step?"
-   - If yes → implement, mark the step `[x]` in the roadmap file.
-   - If no / skip → move to the next step.
-   - If the user wants to stop → stop and summarize progress.
-
-### 5. After each step
-
-- Update the roadmap file: mark the completed step `[x]` (or `[~]` / `[-]`).
-- Regenerate `agents/roadmaps-progress.md` — `./agent-config roadmap:progress`.
-- **Quality pipeline** — run only when `quality_cadence: per_step`.
-  Otherwise skip and proceed.
-- Ask: "Continue with the next step?"
-
-### 6. After all steps in a phase
-
-- Summarize what was accomplished in the phase.
-- **Quality pipeline** — run when `quality_cadence: per_phase` (or `per_step`).
-  Skip when `end_of_roadmap`.
-- Ask: "Phase {N} complete. Continue with Phase {N+1}?"
-
-### 7. When done (or stopped)
-
-- Summarize total progress: steps completed, steps remaining.
-- Update the roadmap file with the current status.
-- Regenerate the dashboard one last time so it matches the final state.
-- **If ALL steps are done** → run the project's quality pipeline now
-  (this is the `verify-before-complete` evidence gate; required for
-  every cadence value, including `end_of_roadmap`). On green, trigger
-  the completion & archiving workflow from the `roadmap-management`
-  skill. On red, stop, surface the failures, do not archive.
-
-### Rules
-
-- **Commits are governed by [`commit-policy`](../rules/commit-policy.md).**
-  By default: only apply local changes and update the roadmap file — no commits.
-  - If the roadmap **does not** contain explicit commit steps → never commit, never ask.
-  - If the roadmap **does** contain explicit commit steps:
-    - **Non-autonomous** (`personal.autonomy: off`, or `auto` before opt-in) →
-      ask before each commit step.
-    - **Autonomous** (`personal.autonomy: on`, or `auto` after opt-in) →
-      pre-scan the roadmap **before starting**, ask **once** upfront whether
-      to execute the listed commit steps, then proceed silently per the answer.
-- **Push, merge, branch, PR, tag** stay permission-gated by [`scope-control`](../rules/scope-control.md#git-operations--permission-gated).
-- **Always ask before implementing** a step — never auto-execute.
-- **Quality cadence** is set by `roadmap.quality_cadence` (see step 3).
-  Step 7 always runs the pipeline before archival regardless of cadence.
-- If a step is unclear or too large, suggest breaking it down further.
-- If a step reveals a problem not covered in the roadmap, flag it to the user.