arkaos 4.9.0 → 4.11.0

package/VERSION

@@ -1 +1 @@
-4.9.0
+4.11.0

package/bin/arka

@@ -137,7 +137,11 @@ case "${1:-}" in
     REGISTRY="$REPO_DIR/knowledge/commands-registry.json"
     case "${1:-}" in
       rebuild)
-        bash "$REPO_DIR/bin/arka-registry-gen"
+        # Shared resolver (venv-first) with plain python3 fallback —
+        # the generator is stdlib-only.
+        _ARKA_LIB="$REPO_DIR/config/hooks/_lib/arka_python.sh"
+        if [ -f "$_ARKA_LIB" ]; then . "$_ARKA_LIB"; else ARKA_PY="python3"; fi
+        (cd "$REPO_DIR" && "$ARKA_PY" -m core.registry.generator)
         echo "Registry rebuilt: $(jq '._meta.total_commands' "$REGISTRY") commands."
         ;;
       --json)

package/bin/arkaos

@@ -65,8 +65,8 @@ case "${1:-}" in
       agents=$(jq -r '._meta.total_agents // 0' "$REPO_ROOT/knowledge/agents-registry-v2.json")
       echo "  Agents:       ${agents}"
     fi
-    if [ -n "$REPO_ROOT" ] && [ -f "$REPO_ROOT/knowledge/commands-registry-v2.json" ] && command -v jq &>/dev/null; then
-      commands=$(jq -r '._meta.total_commands // 0' "$REPO_ROOT/knowledge/commands-registry-v2.json")
+    if [ -n "$REPO_ROOT" ] && [ -f "$REPO_ROOT/knowledge/commands-registry.json" ] && command -v jq &>/dev/null; then
+      commands=$(jq -r '._meta.total_commands // 0' "$REPO_ROOT/knowledge/commands-registry.json")
       echo "  Commands:     ${commands}"
     fi
     echo ""

package/core/evals/record_cli.py

@@ -0,0 +1,63 @@
+"""Record a QGVerdict as an eval label — the QG-skill wiring point.
+
+Reads the reviewer's QGVerdict JSON from stdin (or --file) and appends
+it to the label corpus via ``record_verdict_label``. Invoked by the
+orchestrator right after a Quality Gate verdict lands (see the Quality
+Gate skill instructions), closing the "labels gratuitos" loop from the
+evals ADR.
+
+Unlike the underlying writer (telemetry contract: never raises), this
+explicit CLI fails LOUDLY on invalid verdict JSON — a malformed label
+recorded silently would poison the corpus.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from pydantic import ValidationError
+
+from core.evals.verdict_labels import record_verdict_label
+from core.governance.qg_verdict import QGVerdict
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--file", help="verdict JSON file (default: stdin)")
+    parser.add_argument("--deliverable", default="")
+    parser.add_argument("--department", default="")
+    parser.add_argument("--eval-task-id", default="")
+    parser.add_argument("--session-id", default="")
+    args = parser.parse_args(argv)
+
+    raw = (
+        Path(args.file).read_text(encoding="utf-8")
+        if args.file
+        else sys.stdin.read()
+    )
+    try:
+        verdict = QGVerdict.model_validate(json.loads(raw))
+    except (json.JSONDecodeError, ValidationError) as exc:
+        print(f"error: invalid QGVerdict JSON — {exc}", file=sys.stderr)
+        return 1
+
+    record_verdict_label(
+        verdict,
+        deliverable=args.deliverable,
+        department=args.department,
+        eval_task_id=args.eval_task_id,
+        session_id=args.session_id,
+    )
+    print(json.dumps({
+        "recorded": True,
+        "verdict": verdict.verdict,
+        "eval_task_id": args.eval_task_id,
+    }))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/core/evals/runner_cli.py

@@ -0,0 +1,102 @@
+"""Eval runner CLI — list tasks, corpus status, dispatch-ready prompts.
+
+Evals reuse the Quality Gate as the judge (ADR 2026-07-09): a run is
+the orchestrator dispatching a task prompt through the normal squad
+flow, then recording the QGVerdict with the task id via
+``core.evals.record_cli``. This CLI is the deterministic half — it
+never invokes models itself.
+
+Usage:
+    arka-py -m core.evals.runner_cli list [--department dev]
+    arka-py -m core.evals.runner_cli status
+    arka-py -m core.evals.runner_cli prompt <task-id>
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+from core.evals.schema import EvalTask, load_eval_tasks
+from core.evals.verdict_labels import load_verdict_labels
+
+DISTILLATION_LABEL_GATE = 500  # ADR 2026-07-09-evals-and-distillation
+
+
+def _cmd_list(department: str | None) -> int:
+    tasks = load_eval_tasks()
+    if department:
+        tasks = [t for t in tasks if t.department == department]
+    for task in tasks:
+        print(f"{task.id:35s} {task.department:10s} {task.prompt[:60].strip()}…")
+    print(f"\n{len(tasks)} task(s)")
+    return 0
+
+
+def _cmd_status() -> int:
+    labels = load_verdict_labels()
+    verdicts = [str(entry.get("verdict", "")) for entry in labels]
+    by_dept: dict[str, int] = {}
+    linked = 0
+    for entry in labels:
+        dept = str(entry.get("department") or "(none)")
+        by_dept[dept] = by_dept.get(dept, 0) + 1
+        if entry.get("eval_task_id"):
+            linked += 1
+    total = len(labels)
+    print(f"labels: {total} (gate: {DISTILLATION_LABEL_GATE} — "
+          f"{max(0, DISTILLATION_LABEL_GATE - total)} to go)")
+    print(f"  APPROVED: {verdicts.count('APPROVED')}  "
+          f"REJECTED: {verdicts.count('REJECTED')}")
+    print(f"  linked to eval tasks: {linked}")
+    for dept, count in sorted(by_dept.items()):
+        print(f"  {dept}: {count}")
+    print(f"eval tasks defined: {len(load_eval_tasks())}")
+    return 0
+
+
+def _dispatch_prompt(task: EvalTask) -> str:
+    properties = "\n".join(f"- {p}" for p in task.expected_properties)
+    rubric = f"\nRubrica adicional: {task.rubric}" if task.rubric else ""
+    return (
+        f"[EVAL RUN — task {task.id}]\n"
+        f"Departamento: {task.department}\n\n"
+        f"Tarefa: {task.prompt}\n\n"
+        f"O deliverable será julgado pelo Quality Gate contra estas "
+        f"propriedades verificáveis:\n{properties}{rubric}\n\n"
+        f"Após o verdict, regista o label com:\n"
+        f"  arka-py -m core.evals.record_cli --eval-task-id {task.id} "
+        f"--department {task.department} < verdict.json"
+    )
+
+
+def _cmd_prompt(task_id: str) -> int:
+    tasks = {t.id: t for t in load_eval_tasks()}
+    task = tasks.get(task_id)
+    if task is None:
+        print(f"error: unknown eval task {task_id!r}; run `list`",
+              file=sys.stderr)
+        return 1
+    print(_dispatch_prompt(task))
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    sub = parser.add_subparsers(dest="cmd", required=True)
+    p_list = sub.add_parser("list")
+    p_list.add_argument("--department")
+    sub.add_parser("status")
+    p_prompt = sub.add_parser("prompt")
+    p_prompt.add_argument("task_id")
+    args = parser.parse_args(argv)
+
+    if args.cmd == "list":
+        return _cmd_list(args.department)
+    if args.cmd == "status":
+        return _cmd_status()
+    return _cmd_prompt(args.task_id)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/core/evals/sanitizer.py

@@ -0,0 +1,97 @@
+"""Client-identifier sanitizer — distillation prerequisite (evals ADR).
+
+Redacts every client identifier from transcript text BEFORE it can feed
+a LoRA training run. Confidentiality is NON-NEGOTIABLE (v2.18.0 npm
+leak precedent), so this module fails CLOSED: with no redaction config
+on disk there is nothing to prove the text is clean, and sanitize()
+refuses to run rather than pass text through unredacted.
+
+The identifier list is the same one the release leak-scanner uses
+(``~/.arkaos/redaction-clients.json`` via
+``core.governance.leak_scanner.load_redaction_patterns``) — one source
+of truth, never hardcoded in the repo.
+
+Replacement is deterministic: the Nth pattern in the config maps to
+``[CLIENT-N]`` in every run. Corpora stay diffable under the APPEND-ONLY
+invariant — new clients go at the END of the config list; reordering or
+deleting entries remaps the placeholders of everything sanitized before.
+"""
+
+from __future__ import annotations
+
+import re
+import sys
+from pathlib import Path
+
+from core.governance.leak_scanner import load_redaction_patterns
+
+
+class SanitizerConfigMissing(RuntimeError):
+    """No redaction config — sanitization cannot be proven, so it refuses."""
+
+
+def sanitize_text(
+    text: str, config_path: Path | None = None
+) -> tuple[str, dict[str, int]]:
+    """Redact client identifiers; return (clean_text, per-placeholder counts).
+
+    Raises SanitizerConfigMissing when the redaction config is absent or
+    empty — fail closed, never pass text through unproven.
+    """
+    patterns = load_redaction_patterns(config_path)
+    if not patterns:
+        raise SanitizerConfigMissing(
+            "redaction config missing or empty (~/.arkaos/redaction-"
+            "clients.json) — refusing to sanitize without an identifier "
+            "list; a silent pass-through would poison the training corpus"
+        )
+    # SINGLE pass over ONE longest-first alternation (QG blocker,
+    # 2026-07-09): a positional per-pattern loop leaked the suffix of a
+    # longer identifier whenever a shorter prefix pattern came first in
+    # the config ("data" before "data dynamics corp"), and replacement
+    # text could itself be re-matched. Placeholder numbers stay keyed to
+    # CONFIG position, so appends never remap an existing corpus.
+    index_by_pattern = {p: i for i, p in enumerate(patterns, start=1)}
+    alternation = "|".join(
+        re.escape(p) for p in sorted(patterns, key=len, reverse=True)
+    )
+    regex = re.compile(
+        r"(?<![a-z0-9])(" + alternation + r")(?![a-z0-9])", re.IGNORECASE
+    )
+    counts: dict[str, int] = {}
+
+    def _redact(match: re.Match[str]) -> str:
+        placeholder = f"[CLIENT-{index_by_pattern[match.group(1).lower()]}]"
+        counts[placeholder] = counts.get(placeholder, 0) + 1
+        return placeholder
+
+    return regex.sub(_redact, text), counts
+
+
+def sanitize_file(
+    path: Path, config_path: Path | None = None
+) -> tuple[str, dict[str, int]]:
+    return sanitize_text(
+        path.read_text(encoding="utf-8"), config_path=config_path
+    )
+
+
+def main(argv: list[str] | None = None) -> int:
+    """CLI: sanitize a file (or stdin) to stdout; counts on stderr."""
+    args = argv if argv is not None else sys.argv[1:]
+    try:
+        if args:
+            clean, counts = sanitize_file(Path(args[0]))
+        else:
+            clean, counts = sanitize_text(sys.stdin.read())
+    except SanitizerConfigMissing as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 2
+    sys.stdout.write(clean)
+    total = sum(counts.values())
+    print(f"sanitized: {total} redaction(s) {counts}", file=sys.stderr)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/core/governance/leak_scanner.py

@@ -93,6 +93,16 @@ def scan_text(
     return [m.group(1).lower() for m in regex.finditer(text)]
 
 
+def load_redaction_patterns(config_path: Path | None = None) -> tuple[str, ...]:
+    """Public accessor for the redaction client list.
+
+    Consumed by core.evals.sanitizer (distillation prerequisite) so the
+    scanner and the sanitizer can never disagree on what a client
+    identifier is. Returns () when the config is missing or empty.
+    """
+    return _load_patterns(config_path or _DEFAULT_CONFIG_PATH)
+
+
 def _load_patterns(config_path: Path) -> tuple[str, ...]:
     try:
         data = json.loads(config_path.read_text(encoding="utf-8"))

package/core/governance/phantom_action_check.py

@@ -45,7 +45,12 @@ _ANALYTIC_NOUN = (
     r"|takeaways?|impressions?|sense|grasp|view|idea|picture"
     r"|mental\s+model|contexto|resumo|notas?|entendimento"
     r"|perce[çc][ãa]o|an[áa]lise|analysis|ideia|vis[ãa]o|imagem"
-    r"|no[çc][ãa]o|perspe[ct]?tiva|opini[ãa]o|conhecimento|knowledge)\b"
+    r"|no[çc][ãa]o|perspe[ct]?tiva|opini[ãa]o|conhecimento|knowledge"
+    # Synonym tail (ADR 2026-07-09-phantom M3): noun-reads anchored by
+    # the preposition — plurals included — so verb uses ("read the
+    # file") stay untouched.
+    r"|read(?:ing)?s?(?=\s+(?:on|of)\b)|takes?(?=\s+on\b)"
+    r"|interpretations?|assessments?|interpreta[çc][õã][eo]s?|leituras?)\b"
 )
 _GAP = r"(?:(?!" + _ANALYTIC_NOUN + r")[^.\n!?]){0,60}?"
 
@@ -67,7 +72,17 @@ _BOUND_PT = (
     r"|movi|apliquei|corri|executei)\b" + _GAP + _EFFECT_OBJECT
 )
 _BOUND_EN = (
-    r"\bI(?:'ve| have)?\s+(?:just\s+)?(created|wrote|updated|deleted"
+    # Optional coordinated clause after the I-subject (ADR 2026-07-09-
+    # phantom M2): "I ran through the plan, then ran the tests" — the
+    # second bare verb shares the subject. The chunk must START with the
+    # I-clause's own idiom verb (ran into/through/over/across), so an
+    # embedded clause with a third-party subject ("I confirmed the hook
+    # ran and created…") can never bridge the I anchor to a foreign
+    # effect verb (QG blocker, 2026-07-09 re-review).
+    r"\bI(?:'ve| have)?\s+(?:just\s+)?"
+    r"(?:ran\s+(?:into|through|over|across)\b"
+    r"[^.\n!?]{0,40}?[,;]?\s*\b(?:then|and)\s+)?"
+    r"(created|wrote|updated|deleted"
     r"|added|moved|applied|renamed|ran(?!\s+(?:into|through|over|across))"
     r"|executed)\b" + _GAP + _EFFECT_OBJECT
 )