arkaos 4.2.0 → 4.3.1

package/README.md

@@ -2,7 +2,7 @@
 
 **The Operating System for AI Agent Teams.**
 
-82 agents. 17 departments. 267 skills. Enterprise frameworks. Multi-runtime. One install.
+82 agents. 17 departments. 268 skills. Enterprise frameworks. Multi-runtime. One install.
 
 ```bash
 npx arkaos install

package/VERSION

@@ -1 +1 @@
-4.2.0
+4.3.1

package/arka/SKILL.md

@@ -24,7 +24,7 @@ does not replace the vault.
 # ArkaOS — Main Orchestrator
 
 > **The Operating System for AI Agent Teams**
-> 82 agents. 17 departments. 267 skills. Multi-runtime. Dashboard. Knowledge RAG.
+> 82 agents. 17 departments. 268 skills. Multi-runtime. Dashboard. Knowledge RAG.
 
 ## ⛔ Evidence flow — 4 gates (NON-NEGOTIABLE)
 

package/arka/skills/fusion/SKILL.md

@@ -0,0 +1,98 @@
+---
+name: arka-fusion
+description: >
+  Model Fabric advisor and fusion configurator. Discovers what the machine
+  can run (Ollama local models, OpenRouter/Anthropic keys), reads the
+  current role routing, interviews the user about goals and constraints,
+  and recommends — with rationale — which model should run each role and
+  which panel+judge combination to use for fusion. Applies the approved
+  configuration via `npx arkaos models`. Trigger: "/arka-fusion", "fusion",
+  "que modelos usar", "configurar modelos", "model routing".
+allowed-tools: [Read, Bash, AskUserQuestion]
+---
+
+# /arka-fusion — Model Fabric Advisor
+
+You are the Model Fabric advisor. Your job: leave the user with a role →
+model mapping and a fusion panel that fit THEIR machine, keys, and goals —
+never a generic default. Constitution `model-routing` sets the posture:
+quality-critical roles get the best model available; only genuinely
+mechanical work economises.
+
+## Phase 1 — Discover (never skip, never assume)
+
+Run and read all three:
+
+```bash
+python -m core.runtime.model_router_cli discover        # Ollama + local models
+python -m core.runtime.model_router_cli --json          # current routing
+python -m core.runtime.model_router_cli usage --period week --json
+```
+
+Also check key presence (never print values): `OPENROUTER_API_KEY` /
+`ANTHROPIC_API_KEY` in env or `~/.arkaos/keys.json`.
+
+Interpret the discovery honestly:
+- Ollama **not installed** → local lane unavailable; say what installing
+  it would unlock (free mechanical/panel calls, privacy).
+- Ollama installed but **not running** → tell the user to start it; count
+  its models as one `ollama serve` away.
+- Ollama running → classify each local model by size/family: coder models
+  (qwen-coder, deepseek-coder) suit `mechanical` + code review panels;
+  large general models (30B+, kimi cloud) qualify for panel seats;
+  sub-8B models are mechanical-only. `:cloud` models are Ollama-proxied
+  remote models — panel-grade, not privacy-local.
+
+## Phase 2 — Interview (one AskUserQuestion, then dialogue)
+
+Ask about, at most 4 questions, adapting to what discovery found:
+1. **Prioridade** — máxima qualidade custe o que custar / equilíbrio /
+   privacidade local primeiro?
+2. **Fusion** — ativar painel multi-modelo para trabalho crítico
+   (2-5× chamadas por resposta, qualidade validada acima de qualquer
+   modelo solo) ou manter single-model por agora?
+3. **OpenRouter** — se não há chave: quer criar uma? (1 chave → Kimi,
+   DeepSeek, GPT, Gemini como participantes de painel.)
+4. Qualquer ambiguidade real que a discovery levantou.
+
+## Phase 3 — Recommend (framework-backed, named tradeoffs)
+
+Produce a table: role → provider/model + ONE-line rationale each. Rules:
+- `design/review/architecture/strategy/quality_gate` → best frontier
+  model available. NEVER a local small model, even if the user leans
+  cost-sensitive — offer fusion-with-budget-panel instead (OpenRouter
+  evidence: budget panel + frontier judge beats frontier solo at ~50%
+  cost).
+- `mechanical` → cheapest competent lane: local coder model if Ollama
+  runs one, else haiku-class.
+- Fusion panel: 2-3 DIVERSE models (different families — e.g. one
+  Anthropic, one Kimi/DeepSeek, one local large) + frontier judge.
+  Homogeneous panels waste the fan-out.
+- Cite `usage` data when it argues for a change ("80% of your tokens are
+  mechanical → moving them local saves X").
+
+## Phase 4 — Apply (only after explicit approval)
+
+```bash
+npx arkaos models set <role> <provider>/<model> --effort <effort>
+npx arkaos fusion --save "<a first question>"   # persist a panel + run it
+```
+
+`npx arkaos fusion --show` prints the panel that would run (a sensible
+default is built from the machine's models when none is configured);
+`npx arkaos fusion --save "question"` writes the panel into
+`~/.arkaos/models.yaml` and runs it; `npx arkaos fusion "question"` runs
+without persisting. For fine-grained panel/judge edits, edit
+`~/.arkaos/models.yaml` directly (keep comments). Show the final
+`npx arkaos models` table as proof and remind: the dashboard Models page
+shows the same state + live usage, and the SessionStart hook now injects
+the routing so it governs agent dispatch.
+
+## Hard rules
+
+- Discovery before advice — recommending a model the machine cannot run
+  is a constitution breach (`context-verification`).
+- Never print key values. Presence only.
+- Quality roles never downgrade below frontier (`model-routing`,
+  `excellence-mandate`). Push back if asked; offer budget fusion instead.
+- Every recommendation carries a rationale the user can disagree with.

package/config/hooks/session-start.sh

@@ -105,6 +105,29 @@ MSG+="\\nFields: kb=N (Obsidian/KB notes consulted), research=X (MCPs invoked: p
 MSG+="\\nMandatory after: EFFECT tool calls, plan/recommendation outputs, QG verdicts. Optional for pure read-only status replies."
 MSG+="\\nAbsence is measured by the Stop hook (warn-only in v2.34.0) before promotion to hard enforcement."
 
+# ─── Model Fabric routing (consumption layer) ───────────────────────────
+# Feed the operator's ~/.arkaos/models.yaml back to the orchestrator so
+# dashboard/CLI model choices actually govern agent dispatch. Cheap
+# (single python read); skipped silently if the config can't be resolved.
+if [ -n "$REPO" ]; then
+  # Prefer the ArkaOS venv python (has pydantic + yaml); the ambient
+  # python3 usually lacks them and routing_directive() would return "".
+  _MF_PY="python3"
+  [ -x "$HOME/.arkaos/venv/bin/python3" ] && _MF_PY="$HOME/.arkaos/venv/bin/python3"
+  if command -v "$_MF_PY" &>/dev/null || [ -x "$_MF_PY" ]; then
+    _MF_DIRECTIVE=$(cd "$REPO" && PYTHONPATH="$REPO" "$_MF_PY" -c "
+try:
+    from core.runtime.model_routing_context import routing_directive
+    print(routing_directive())
+except Exception:
+    pass
+" 2>/dev/null)
+    if [ -n "$_MF_DIRECTIVE" ]; then
+      MSG+="\\n\\n${_MF_DIRECTIVE}"
+    fi
+  fi
+fi
+
 # ─── Stale-aware reorganizer trigger (PR24 v2.46.0) ─────────────────────
 # If today's proposal file is missing, fire the reorganizer in the
 # background with a 30s timeout. Best-effort, never blocks session

package/core/fusion/__init__.py

@@ -0,0 +1,5 @@
+"""Fusion engine — panel of models answers, a judge synthesises."""
+
+from core.fusion.engine import FusionResult, FusionUnavailable, fuse
+
+__all__ = ["FusionResult", "FusionUnavailable", "fuse"]

package/core/fusion/cli.py

@@ -0,0 +1,88 @@
+"""Fusion CLI — run the panel → judge → synthesis pipeline.
+
+Usage::
+
+    python -m core.fusion.cli "your question"
+    python -m core.fusion.cli --save "your question"   # persist the panel
+    python -m core.fusion.cli --show                   # show the panel only
+
+When ``models.yaml`` has no ``fusion.panel``, a default is built from the
+machine's models (runtime + local Ollama) so fusion works out of the box.
+``--save`` writes that panel into ``~/.arkaos/models.yaml`` so every
+fusion consumer (and the dashboard) sees it.
+"""
+
+from __future__ import annotations
+
+import sys
+
+from core.fusion.engine import FusionUnavailable, fuse
+from core.fusion.panel_builder import default_panel, describe_panel
+from core.runtime.model_router import load_config
+
+
+def _save_panel(panel, judge) -> str:
+    import yaml
+    from core.runtime.model_router import USER_CONFIG_PATH, ensure_user_config
+    path = ensure_user_config()
+    data = yaml.safe_load(path.read_text(encoding="utf-8")) or {}
+    data.setdefault("fusion", {})
+    data["fusion"]["judge"] = judge.model_dump()
+    data["fusion"]["panel"] = [c.model_dump() for c in panel]
+    path.write_text(yaml.safe_dump(data, sort_keys=False), encoding="utf-8")
+    return str(USER_CONFIG_PATH)
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = list(argv if argv is not None else sys.argv[1:])
+    save = "--save" in args
+    show = "--show" in args
+    args = [a for a in args if a not in ("--save", "--show")]
+
+    config, _ = load_config()
+    panel, judge = default_panel(config)
+
+    if show:
+        print(f"\n  Fusion panel — {describe_panel(panel, judge)}")
+        if not config.fusion.panel:
+            print("  (default built from the machine; run --save to persist)")
+        print()
+        return 0
+
+    if len(panel) < 2:
+        print("  ✗ No panel available — configure fusion.panel in "
+              "models.yaml (try /arka-fusion) or start Ollama with 2+ "
+              "models for a local panel.", file=sys.stderr)
+        return 1
+
+    if save:
+        where = _save_panel(panel, judge)
+        print(f"  ✓ Fusion panel saved to {where}")
+        config, _ = load_config()  # reload so fuse() uses the saved panel
+
+    prompt = " ".join(args).strip()
+    if not prompt:
+        print("usage: python -m core.fusion.cli [--save] \"question\"",
+              file=sys.stderr)
+        return 1
+
+    # Build an effective config carrying the (possibly default) panel.
+    config.fusion.panel = panel
+    config.fusion.judge = judge
+    try:
+        result = fuse(prompt, config=config)
+    except FusionUnavailable as exc:
+        print(f"  ✗ {exc}", file=sys.stderr)
+        return 1
+    seats = ", ".join(
+        f"{a.provider}/{a.model}" + (" (failed)" if a.failed else "")
+        for a in result.answers
+    )
+    print(f"\n  Fusion — judge {result.judge_provider}/{result.judge_model} "
+          f"| panel: {seats}\n")
+    print(result.text)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/core/fusion/engine.py

@@ -0,0 +1,153 @@
+"""Fusion engine — panel → judge → synthesis (Model Fabric PR-D).
+
+Pattern validated by OpenRouter's DRACO results: a panel of diverse
+models answers the same prompt in parallel; a judge model receives every
+answer, analyses consensus, contradictions and blind spots, and writes
+the final synthesis. A budget panel + frontier judge beats frontier solo
+at roughly half the cost; self-fusion alone gains several points.
+
+Configuration lives in ``models.yaml`` (``fusion.judge`` +
+``fusion.panel`` — see ``core/runtime/model_router.py``). An empty panel
+means fusion is disabled; callers get ``FusionUnavailable`` and fall
+back to single-model completion.
+
+Consumers: Forge complex/super tiers, QG adversarial review, and the
+``python -m core.fusion.cli`` smoke path used by ``/arka-fusion``.
+"""
+
+from __future__ import annotations
+
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass, field
+
+from core.runtime.llm_provider import LLMResponse, LLMUnavailable
+from core.runtime.model_router import ModelsConfig, RoleChoice, load_config
+
+_PANEL_MAX_TOKENS = 2000
+_JUDGE_MAX_TOKENS = 3000
+
+_JUDGE_SYSTEM = (
+    "You are the judge in a model-fusion panel. You receive one question "
+    "and several independent answers from different models. Analyse them: "
+    "consensus points, contradictions, partial coverage, unique insights, "
+    "blind spots. Then write the best possible final answer grounded in "
+    "that analysis. Output ONLY the final answer — no meta-commentary "
+    "about the panel."
+)
+
+
+class FusionUnavailable(RuntimeError):
+    """Fusion cannot run: empty panel or no reachable participant."""
+
+
+@dataclass(frozen=True)
+class PanelAnswer:
+    provider: str
+    model: str
+    text: str
+    failed: bool = False
+    error: str = ""
+
+
+@dataclass(frozen=True)
+class FusionResult:
+    text: str
+    judge_provider: str
+    judge_model: str
+    answers: list[PanelAnswer] = field(default_factory=list)
+    tokens_in: int = 0
+    tokens_out: int = 0
+
+
+def _provider_for(choice: RoleChoice, config: ModelsConfig):
+    """Instantiate the LLM provider for one panel/judge seat."""
+    from core.runtime.model_router import _resolve_alias
+    model = _resolve_alias(config, choice.provider, choice.model)
+    if choice.provider == "ollama":
+        from core.runtime.ollama_provider import OllamaProvider
+        return OllamaProvider(model=model), model
+    if choice.provider == "openrouter":
+        from core.runtime.openrouter_provider import OpenRouterProvider
+        return OpenRouterProvider(model=model), model
+    # runtime / anthropic / anything else: provider chain decides; the
+    # model override is advisory (subagent uses the session model).
+    from core.runtime.llm_provider import get_llm_provider
+    return get_llm_provider(), model
+
+
+def _ask_participant(
+    choice: RoleChoice, config: ModelsConfig, prompt: str, system: str
+) -> PanelAnswer:
+    try:
+        provider, model = _provider_for(choice, config)
+        response: LLMResponse = provider.complete(
+            prompt, max_tokens=_PANEL_MAX_TOKENS, system=system
+        )
+        if not response.text.strip():
+            return PanelAnswer(choice.provider, model, "", failed=True,
+                               error="empty response")
+        return PanelAnswer(choice.provider, model, response.text)
+    except LLMUnavailable as exc:
+        return PanelAnswer(choice.provider, choice.model, "", failed=True,
+                           error=str(exc))
+    except Exception as exc:  # noqa: BLE001 — one dead seat must not kill the panel
+        return PanelAnswer(choice.provider, choice.model, "", failed=True,
+                           error=f"unexpected: {exc}")
+
+
+def _judge_prompt(prompt: str, answers: list[PanelAnswer]) -> str:
+    blocks = []
+    for i, answer in enumerate(answers, 1):
+        blocks.append(
+            f"--- Answer {i} (model: {answer.model}) ---\n{answer.text}"
+        )
+    return (
+        f"QUESTION:\n{prompt}\n\n"
+        f"PANEL ANSWERS ({len(answers)}):\n\n" + "\n\n".join(blocks)
+    )
+
+
+def fuse(
+    prompt: str,
+    *,
+    system: str = "",
+    config: ModelsConfig | None = None,
+) -> FusionResult:
+    """Run the full panel → judge → synthesis pipeline.
+
+    Raises FusionUnavailable when the panel is empty (fusion disabled in
+    models.yaml) or when every participant fails — the caller falls back
+    to a single-model completion, never to silence.
+    """
+    if config is None:
+        config, _ = load_config()
+    panel = config.fusion.panel
+    if not panel:
+        raise FusionUnavailable(
+            "fusion panel is empty — configure fusion.panel in models.yaml "
+            "(try /arka-fusion for guided setup)"
+        )
+    with ThreadPoolExecutor(max_workers=max(len(panel), 1)) as pool:
+        answers = list(pool.map(
+            lambda choice: _ask_participant(choice, config, prompt, system),
+            panel,
+        ))
+    alive = [a for a in answers if not a.failed]
+    if not alive:
+        details = "; ".join(f"{a.provider}/{a.model}: {a.error}" for a in answers)
+        raise FusionUnavailable(f"every panel participant failed — {details}")
+
+    judge_provider, judge_model = _provider_for(config.fusion.judge, config)
+    verdict = judge_provider.complete(
+        _judge_prompt(prompt, alive),
+        max_tokens=_JUDGE_MAX_TOKENS,
+        system=_JUDGE_SYSTEM,
+    )
+    return FusionResult(
+        text=verdict.text,
+        judge_provider=config.fusion.judge.provider,
+        judge_model=judge_model or verdict.model,
+        answers=answers,
+        tokens_in=verdict.tokens_in,
+        tokens_out=verdict.tokens_out,
+    )

package/core/fusion/panel_builder.py

@@ -0,0 +1,58 @@
+"""Build a fusion panel from what the machine can actually run.
+
+Fusion needs a diverse panel + a judge. The user's ``models.yaml`` may
+have an explicit ``fusion.panel`` (configured via ``/arka-fusion``); when
+it is empty, this builds a sensible default from discovered models so
+``npx arkaos fusion "question"`` does something out of the box instead of
+failing with FusionUnavailable.
+
+Diversity is the point (OpenRouter's result: a diverse panel beats a
+single model): pair the runtime model with up to two large, distinct
+local Ollama models. The judge stays the configured frontier model.
+"""
+
+from __future__ import annotations
+
+from core.runtime.model_router import ModelsConfig, RoleChoice, load_config
+
+
+def default_panel(
+    config: ModelsConfig | None = None,
+) -> tuple[list[RoleChoice], RoleChoice]:
+    """Return (panel, judge). Respects an explicit panel; else builds one.
+
+    An empty return panel means the machine offers nothing to fuse (no
+    local models and no explicit config) — the caller reports that rather
+    than fanning out to a single seat.
+    """
+    if config is None:
+        config, _ = load_config()
+    judge = config.fusion.judge
+    if config.fusion.panel:
+        return list(config.fusion.panel), judge
+
+    panel: list[RoleChoice] = [
+        RoleChoice(provider="runtime", model="default", effort="high"),
+    ]
+    try:
+        from core.runtime.ollama_discovery import discover
+        status = discover()
+    except Exception:
+        status = None
+    if status and status.running:
+        # Panel-grade locals: >= 4GB, or cloud-proxied (size 0). Sort by
+        # size desc so the strongest come first; take two distinct ones.
+        candidates = sorted(
+            (m for m in status.models if m.size_gb >= 4 or m.size_gb == 0),
+            key=lambda m: m.size_gb,
+            reverse=True,
+        )
+        for m in candidates[:2]:
+            panel.append(RoleChoice(provider="ollama", model=m.name, effort="high"))
+    return panel, judge
+
+
+def describe_panel(panel: list[RoleChoice], judge: RoleChoice) -> str:
+    """Human summary of a panel for CLI output."""
+    seats = ", ".join(f"{c.provider}/{c.model}" for c in panel)
+    return f"judge {judge.provider}/{judge.model} | panel: {seats}"

package/core/governance/redo_counter.py

@@ -0,0 +1,81 @@
+"""Quality Gate redo-loop counter (excellence-mandate, v4.2.0).
+
+The constitution caps REJECTED redo cycles at 2 — a third REJECTED
+escalates to the operator with the full verdict instead of another
+silent retry. This module is the mechanical counter behind that rule
+(previously declarative only).
+
+State: ``~/.arkaos/quality-gate/redo-counters.json`` keyed by session id.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+
+REDO_CAP = 2
+
+_STATE_PATH = Path.home() / ".arkaos" / "quality-gate" / "redo-counters.json"
+
+
+@dataclass(frozen=True)
+class RedoState:
+    session_id: str
+    count: int
+    escalate: bool
+
+    def to_message(self) -> str:
+        if not self.escalate:
+            return (
+                f"[arka:qg] REJECTED — redo cycle {self.count}/{REDO_CAP}. "
+                f"Looping back to execution with the issue list."
+            )
+        return (
+            f"[arka:qg:escalate] REJECTED {self.count} times — cap of "
+            f"{REDO_CAP} redo cycles exceeded (excellence-mandate). "
+            f"STOP: present the full verdict to the operator and wait for "
+            f"a decision. Do not retry silently."
+        )
+
+
+def _load(path: Path) -> dict:
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def record_rejected(session_id: str, path: Path | None = None) -> RedoState:
+    """Increment the REJECTED counter; escalate above the cap."""
+    state_path = path or _STATE_PATH
+    data = _load(state_path)
+    count = int(data.get(session_id, 0) or 0) + 1
+    data[session_id] = count
+    try:
+        state_path.parent.mkdir(parents=True, exist_ok=True)
+        state_path.write_text(json.dumps(data, indent=2), encoding="utf-8")
+    except OSError:
+        pass  # counter must never block the gate itself
+    return RedoState(session_id=session_id, count=count,
+                     escalate=count > REDO_CAP)
+
+
+def reset(session_id: str, path: Path | None = None) -> None:
+    """Clear the counter — called on APPROVED."""
+    state_path = path or _STATE_PATH
+    data = _load(state_path)
+    if session_id in data:
+        del data[session_id]
+        try:
+            state_path.write_text(json.dumps(data, indent=2), encoding="utf-8")
+        except OSError:
+            pass
+
+
+def current(session_id: str, path: Path | None = None) -> RedoState:
+    """Read-only view of the counter."""
+    count = int(_load(path or _STATE_PATH).get(session_id, 0) or 0)
+    return RedoState(session_id=session_id, count=count,
+                     escalate=count > REDO_CAP)

package/core/hooks/post_tool_use.py

@@ -111,19 +111,29 @@ def _unlocked(fh) -> None:
 # ─── Section 1: flow marker cache ────────────────────────────────────────
 
 
-def _write_flow_marker(session_id: str, assistant_msg: str) -> None:
-    if not session_id or not assistant_msg:
+def _confirm_flow_authorization(session_id: str, transcript_path: str) -> None:
+    """Confirm persistent flow authorization from the transcript.
+
+    Replaces the dead ``_write_flow_marker`` that read a non-existent
+    ``assistant_message`` payload field. Reads the same transcript the
+    enforcer trusts and, when a flow marker is present, writes a confirmed
+    authorization that survives compaction and the 20-message window.
+    """
+    if not session_id:
         return
-    routing = _ROUTING_RE.search(assistant_msg)
-    if routing:
-        kind, dept, lead = "routing", routing.group(1), routing.group(2)
-    elif _TRIVIAL_RE.search(assistant_msg):
-        kind, dept, lead = "trivial", "", ""
-    else:
+    try:
+        from core.workflow.flow_authorization import confirm
+        from core.workflow.flow_enforcer import (
+            _load_last_assistant_messages,
+            _scan_markers,
+        )
+    except Exception:
         return
     try:
-        from core.workflow.marker_cache import write_marker
-        write_marker(session_id, kind, dept, lead)
+        messages = _load_last_assistant_messages(transcript_path, 20)
+        marker_found, _ = _scan_markers(messages)
+        if marker_found is not None:
+            confirm(session_id, marker_found)
     except Exception:
         pass
 
@@ -614,9 +624,13 @@ def main(stdin_json: dict | None = None) -> int:
     exit_code = get_str(stdin_json, "exit_code") or "0"
     cwd = get_str(stdin_json, "cwd")
     session_id = get_str(stdin_json, "session_id")
-    assistant_msg = get_str(stdin_json, "assistant_message")
+    transcript_path = get_str(stdin_json, "transcript_path")
 
-    _write_flow_marker(session_id, assistant_msg)
+    # Claude Code sends no `assistant_message` field (confirmed against the
+    # hook docs, 2026-07-05) — the old read was dead and the marker cache
+    # was never written. Scan the transcript (the only source hooks have)
+    # and confirm persistent authorization when a marker is present.
+    _confirm_flow_authorization(session_id, transcript_path)
 
     if tool_name in ("Task", "Agent"):
         subagent_type = get_str(stdin_json, "tool_input", "subagent_type")

package/core/hooks/pre_tool_use.py

@@ -260,6 +260,10 @@ def _flow_gate(
     except Exception:
         pass
     if decision.allow:
+        # Grace path: allow, but surface the non-blocking warning so the
+        # operator sees the routing nudge instead of a silent pass.
+        if decision.warning:
+            print(decision.warning, file=sys.stderr)
         return 0
     return _deny(decision.to_stderr_message())
 

package/core/hooks/user_prompt_submit.py

@@ -171,6 +171,13 @@ def _invalidate_turn_caches(session_id: str) -> None:
         invalidate_marker(session_id)
     except Exception:
         pass
+    try:
+        # Reset only the per-turn grace flag; confirmed authorization and
+        # the grace counter persist across turns (enforcer resilience).
+        from core.workflow.flow_authorization import reset_turn
+        reset_turn(session_id)
+    except Exception:
+        pass
     try:
         from core.synapse.kb_cache import invalidate_obsidian_query
         invalidate_obsidian_query(session_id)