@agentikos/omega-os 0.1.0 → 0.19.5

package/omega/Agentik_Engine/omega_engine/audits/dispatcher.py

@@ -0,0 +1,92 @@
+"""Audit fix-dispatcher — turn batches into worker missions, capped.
+
+The pipeline calls ``dispatch_fixes(batches, ...)`` after the audit has
+produced ``fix_plan`` items. We hand each batch to the OmegaOS engine via
+``run_mission`` (the same path ``omega run`` uses), but with a constructed
+intent that lists every finding the worker must fix.
+
+Hard guards:
+
+  * Caller already capped ``max_batches`` (default 3) via the batcher.
+  * We add a wall-clock + budget timeout per worker (default 600s).
+  * If too many workers are already running for the same audit on the
+    same project, we refuse — operator must reduce parallelism.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from omega_engine.audits.batcher import Batch, BatchPlan
+
+
+@dataclass
+class DispatchResult:
+    batch_id: str
+    mission_id: str | None
+    status: str                   # "dispatched" | "skipped" | "failed"
+    reason: str = ""
+    summary: str = ""
+    intent: str = ""
+    files: list[str] = field(default_factory=list)
+
+
+def dispatch_fixes(
+    plan: BatchPlan,
+    *,
+    omega_home: str | Path | None = None,
+    audit_id: str | None = None,
+    project: str | None = None,
+    dry_run: bool = False,
+    executor: Any = None,
+) -> list[DispatchResult]:
+    """Send every batch in ``plan`` to its own worker mission.
+
+    Args:
+        plan: the output of ``batch_findings``.
+        omega_home: ``$OMEGA_HOME`` (env or default).
+        audit_id: which audit produced these findings — only used to
+            label the worker intent. Falls back to ``plan.audit_id``.
+        project: optional project slug — the mission inherits it via
+            the envelope (per-project context).
+        dry_run: when True, build intents but do NOT dispatch — return
+            ``status='skipped'`` for each batch.
+        executor: optional ``omega_engine.executor.Executor`` instance.
+            If None, we don't dispatch — we return the intent text only.
+            This keeps the dispatcher pure-data when called from the CLI
+            in inspect mode.
+
+    Returns: one ``DispatchResult`` per batch.
+    """
+    aid = audit_id or plan.audit_id or "audit"
+    results: list[DispatchResult] = []
+    for batch in plan.batches:
+        intent = batch.to_intent(aid)
+        if dry_run or executor is None:
+            results.append(DispatchResult(
+                batch_id=batch.id, mission_id=None,
+                status="skipped" if dry_run else "no_executor",
+                reason=("dry-run" if dry_run else "no executor provided"),
+                summary=f"{len(batch.findings)} finding(s) across {len(batch.files)} file(s)",
+                intent=intent, files=list(batch.files),
+            ))
+            continue
+        try:
+            outcome = executor.run_mission(intent, root_role="worker")
+            results.append(DispatchResult(
+                batch_id=batch.id, mission_id=outcome.mission_id,
+                status="dispatched" if outcome.verified else "failed",
+                reason="" if outcome.verified else (
+                    f"mission terminated {outcome.final_state.value}"
+                ),
+                summary=f"{len(batch.findings)} finding(s) → mission {outcome.mission_id}",
+                intent=intent, files=list(batch.files),
+            ))
+        except Exception as exc:  # noqa: BLE001
+            results.append(DispatchResult(
+                batch_id=batch.id, mission_id=None,
+                status="failed", reason=f"executor raised: {exc}"[:300],
+                summary="", intent=intent, files=list(batch.files),
+            ))
+    return results

package/omega/Agentik_Engine/omega_engine/audits/generator.py

@@ -0,0 +1,234 @@
+"""SKILL.md generator — turn each audit.yaml into a Claude Code skill.
+
+The user wants every audit invocable as a first-class Claude Code skill
+(``/codeaudit``, ``/flowaudit``, ...). This generator reads each
+``Agentik_SSOT/audits/<id>.yaml`` and writes the matching
+``Agentik_SSOT/skills/<id>/SKILL.md`` so ``omega sync`` then projects it
+into Claude Code's native skills tree.
+
+The generated SKILL.md follows the Agent Skills open standard:
+
+  * **frontmatter** — name, description (built from the audit's question),
+    when_to_use, argument-hint, allowed-tools, hooks (optional).
+  * **body** — doctrine + per-phase checks + the exact commands to call
+    (``omega audit run``, ``omega audit gather``, ``omega audit reaudit``),
+    plus the structured ``.done.json`` contract.
+
+The generator is idempotent — re-running it overwrites in place. It
+preserves operator-edited supporting files in the same directory
+(scripts/, examples/, etc.).
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+
+SKILL_TEMPLATE = """\
+---
+name: {name}
+description: {description}
+when_to_use: {when_to_use}
+argument-hint: "[--scope <path>] [--fix] [--max-workers N]"
+arguments: [args]
+allowed-tools: Bash Read Edit Grep Glob Write
+---
+
+# {name} — forensic audit (Agentik OS Quality Arsenal)
+
+> {question}
+
+You are running the {name} forensic audit. Apply the **Gestalt-Popper
+doctrine**: identify the hinge point, scrutinise it 10x, then assume
+every name is a CLAIM and look for the divergence between the claim and
+the reality. Bias toward FAIL. A perfect score is earned by finding zero
+falsifiable claims, never by absence of effort.
+
+## Run
+
+The audit is one engine call — gather (deterministic) + falsify (agentic)
++ optional fix-dispatch (capped) + re-audit. Invoke the unified pipeline:
+
+```bash
+omega audit run {name} $args
+```
+
+Common options:
+
+| Flag | Effect |
+|---|---|
+| `--scope <path>` | scope the audit (file or directory) |
+| `--fix` | after analysing, batch findings + dispatch up to N workers + re-audit |
+| `--max-workers N` | cap parallel fix workers (default 3) |
+| `--min-severity high` | only batch + fix findings at or above this severity |
+
+Read-only by default. Add `--fix` to enable the dispatch + re-audit loop.
+
+## Phases under investigation
+
+The agentic pass walks each phase below and emits structured findings
+(claim vs. reality). Every PASS must cite ≥3 concrete checks.
+
+{phases_block}
+
+## Falsification rules
+
+{falsification}
+
+## After the run
+
+The pipeline writes one structured verdict to:
+
+```
+Agentik_Runtime/audits.db    (history — `omega audit history {name}`)
+Agentik_Runtime/sessions/${{CLAUDE_SESSION_ID}}/.done.json   (this turn)
+```
+
+The `.done.json` schema:
+
+```json
+{{
+  "status": "done_clean" | "pending" | "failed",
+  "summary": "<one-paragraph verdict>",
+  "artifacts": {{
+    "audit": "{name}",
+    "score": 0-100,
+    "verified": bool,
+    "findings": [...],
+    "fix_plan": [...],
+    "dispatches": [...],
+    "reaudit_score": 0-100  // only when --fix was used
+  }}
+}}
+```
+
+## Hard rules (don't break these)
+
+1. **No fake "done".** First Law: only runtime tells the truth. If the
+   gather phase fails or the agentic verdict scores below the threshold,
+   you have NOT verified — set status to `pending` or `failed`.
+2. **Cap parallelism.** ≤ {default_max_batches} fix workers at a time. The
+   batcher enforces this; do not call out to other dispatch mechanisms.
+3. **No worker per finding.** Findings are clustered by file footprint and
+   severity. One worker handles one disjoint batch.
+4. **Re-audit confirms.** After fixes land, the pipeline re-runs the same
+   gather + agentic phases. If the score did not improve, escalate honestly.
+5. **History is the trend.** `omega audit history {name}` shows whether the
+   codebase is improving over time on this dimension. Use it to decide
+   whether to push for `--fix` again.
+
+## Why this audit exists
+
+The 18 forensic audits are the OmegaOS verification layer. Claude's
+"I'm done" claims used to be unverified. With these audits running as
+the gate, completion is **derived from observable facts**, not declared
+by the worker. Run this audit any time someone (human or agent) claims
+the {domain} dimension is healthy. Insist on the score before you
+accept.
+
+## Reference
+
+Audit definition: `Agentik_SSOT/audits/{name}.yaml`
+Engine pipeline:  `omega_engine.audits.pipeline.AuditPipeline`
+Batcher:          `omega_engine.audits.batcher.batch_findings`
+History:          `omega_engine.audits.history`
+"""
+
+
+@dataclass
+class AuditSkillFile:
+    """A single generated SKILL.md path + content tuple."""
+    audit_id: str
+    skill_path: Path
+    body: str
+
+
+def _short_description(audit: dict[str, Any]) -> str:
+    """Build a one-line description for the skill listing."""
+    question = (audit.get("question") or "").strip().rstrip(".")
+    domain = audit.get("domain", "")
+    return (
+        f"Forensic {domain} audit — {question}. Runs the gather "
+        f"(deterministic) + falsify (agentic) pipeline, batches fixes, "
+        f"dispatches capped workers, re-audits, and persists scores. "
+        f"Use when the user says \"/{audit['id']}\", \"audit {domain}\", "
+        f"or asks to verify the {domain} health of the project."
+    )[:1500]
+
+
+def _when_to_use(audit: dict[str, Any]) -> str:
+    """Trigger phrases for Claude's auto-routing."""
+    aid = audit["id"]
+    domain = audit.get("domain", "")
+    return (
+        f"User says /{aid}, audit {domain}, check {domain}, "
+        f"verify {domain}, is {domain} healthy."
+    )
+
+
+def _phases_block(audit: dict[str, Any]) -> str:
+    phases = audit.get("phases") or []
+    if not phases:
+        return "_(no phases declared — the agentic pass falls back to "
+        "domain-agnostic falsification)_"
+    parts = []
+    for i, p in enumerate(phases, start=1):
+        pid = p.get("id", f"phase-{i}")
+        checks = p.get("checks", "").strip()
+        parts.append(f"### {i}. {pid}\n\n{checks}")
+    return "\n\n".join(parts)
+
+
+def generate_skill(audit_yaml_path: str | Path) -> AuditSkillFile:
+    """Read an audit YAML and produce the matching SKILL.md content."""
+    src = Path(audit_yaml_path)
+    data = yaml.safe_load(src.read_text()) or {}
+    if not data.get("id"):
+        raise ValueError(f"{src}: missing `id` — not a valid audit")
+    aid = data["id"]
+
+    skill_dir = src.parent.parent / "skills" / aid
+    skill_path = skill_dir / "SKILL.md"
+
+    body = SKILL_TEMPLATE.format(
+        name=aid,
+        domain=data.get("domain", "general"),
+        question=data.get("question", "").strip(),
+        description=_short_description(data),
+        when_to_use=_when_to_use(data),
+        phases_block=_phases_block(data),
+        falsification=(data.get("falsification") or "Bias toward FAIL. "
+                       "Cite three concrete checks for every PASS.").strip(),
+        default_max_batches=3,
+    )
+    return AuditSkillFile(audit_id=aid, skill_path=skill_path, body=body)
+
+
+def generate_all(audits_dir: str | Path) -> list[AuditSkillFile]:
+    """Generate SKILL.md for every audit YAML under ``audits_dir``."""
+    audits_dir = Path(audits_dir)
+    out: list[AuditSkillFile] = []
+    for path in sorted(audits_dir.glob("*.yaml")):
+        try:
+            out.append(generate_skill(path))
+        except ValueError:
+            continue
+    return out
+
+
+def write_all(audits_dir: str | Path) -> dict[str, int]:
+    """Generate AND write every SKILL.md. Returns counts for the CLI to print."""
+    written = 0
+    skipped = 0
+    for sf in generate_all(audits_dir):
+        sf.skill_path.parent.mkdir(parents=True, exist_ok=True)
+        # Preserve existing content if it's identical — saves doctor noise.
+        if sf.skill_path.exists() and sf.skill_path.read_text() == sf.body:
+            skipped += 1
+            continue
+        sf.skill_path.write_text(sf.body)
+        written += 1
+    return {"written": written, "skipped": skipped}

package/omega/Agentik_Engine/omega_engine/audits/history.py

@@ -0,0 +1,168 @@
+"""Audit run history — score per audit per run, persisted to SQLite.
+
+Every ``omega audit <id>`` invocation writes a row. The CLI's ``omega audit
+history <id>`` reads it back. The doctor surfaces a one-line trend.
+
+Storage: ``$OMEGA_HOME/Agentik_Runtime/audits.db``. Same WAL mode as the
+event store. Survives reinstalls (it's under Agentik_Runtime).
+"""
+from __future__ import annotations
+
+import json
+import os
+import sqlite3
+import time
+import uuid
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+@dataclass
+class AuditRun:
+    run_id: str
+    audit_id: str
+    scope: str
+    timestamp: int
+    score: int
+    verified: bool
+    finding_count: int
+    fix_workers_dispatched: int = 0
+    reaudit_score: int | None = None
+    verdict: dict[str, Any] = field(default_factory=dict)
+
+
+def _db_path(omega_home: str | Path) -> Path:
+    home = Path(omega_home)
+    (home / "Agentik_Runtime").mkdir(parents=True, exist_ok=True)
+    return home / "Agentik_Runtime" / "audits.db"
+
+
+def _connect(omega_home: str | Path) -> sqlite3.Connection:
+    conn = sqlite3.connect(str(_db_path(omega_home)))
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA journal_mode=WAL")
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS audit_runs (
+            run_id TEXT PRIMARY KEY,
+            audit_id TEXT NOT NULL,
+            scope TEXT NOT NULL,
+            timestamp INTEGER NOT NULL,
+            score INTEGER NOT NULL,
+            verified INTEGER NOT NULL,
+            finding_count INTEGER NOT NULL,
+            fix_workers_dispatched INTEGER NOT NULL DEFAULT 0,
+            reaudit_score INTEGER,
+            verdict_json TEXT NOT NULL
+        )
+    """)
+    conn.execute("""
+        CREATE INDEX IF NOT EXISTS idx_audit_runs_audit_id
+            ON audit_runs(audit_id, timestamp DESC)
+    """)
+    return conn
+
+
+def record_run(omega_home: str | Path, run: AuditRun) -> None:
+    """Insert (or replace) one row."""
+    conn = _connect(omega_home)
+    try:
+        conn.execute(
+            """
+            INSERT OR REPLACE INTO audit_runs
+            (run_id, audit_id, scope, timestamp, score, verified,
+             finding_count, fix_workers_dispatched, reaudit_score, verdict_json)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                run.run_id, run.audit_id, run.scope, run.timestamp,
+                int(run.score), 1 if run.verified else 0,
+                int(run.finding_count),
+                int(run.fix_workers_dispatched),
+                run.reaudit_score if run.reaudit_score is not None else None,
+                json.dumps(run.verdict),
+            ),
+        )
+        conn.commit()
+    finally:
+        conn.close()
+
+
+def list_runs(omega_home: str | Path, *,
+              audit_id: str | None = None,
+              limit: int = 50) -> list[AuditRun]:
+    """Last N runs for an audit (or all audits if ``audit_id`` is None)."""
+    conn = _connect(omega_home)
+    try:
+        if audit_id:
+            cur = conn.execute(
+                """SELECT * FROM audit_runs WHERE audit_id = ?
+                   ORDER BY timestamp DESC LIMIT ?""",
+                (audit_id, int(limit)),
+            )
+        else:
+            cur = conn.execute(
+                "SELECT * FROM audit_runs ORDER BY timestamp DESC LIMIT ?",
+                (int(limit),),
+            )
+        rows = cur.fetchall()
+    finally:
+        conn.close()
+    return [_row_to_run(r) for r in rows]
+
+
+def latest_score(omega_home: str | Path, audit_id: str) -> int | None:
+    """The score of the most recent run, or None if no run yet."""
+    conn = _connect(omega_home)
+    try:
+        cur = conn.execute(
+            """SELECT score FROM audit_runs WHERE audit_id = ?
+               ORDER BY timestamp DESC LIMIT 1""",
+            (audit_id,),
+        )
+        row = cur.fetchone()
+    finally:
+        conn.close()
+    return int(row["score"]) if row else None
+
+
+def trend(omega_home: str | Path, audit_id: str, *, window: int = 5) -> str:
+    """One-character trend symbol: ↑ (improved), → (stable), ↓ (degraded)."""
+    runs = list_runs(omega_home, audit_id=audit_id, limit=window)
+    if len(runs) < 2:
+        return "→"
+    # Compare oldest vs newest within window.
+    oldest = runs[-1].score
+    newest = runs[0].score
+    diff = newest - oldest
+    if diff > 3:
+        return "↑"
+    if diff < -3:
+        return "↓"
+    return "→"
+
+
+def _row_to_run(row: sqlite3.Row) -> AuditRun:
+    return AuditRun(
+        run_id=row["run_id"],
+        audit_id=row["audit_id"],
+        scope=row["scope"],
+        timestamp=int(row["timestamp"]),
+        score=int(row["score"]),
+        verified=bool(row["verified"]),
+        finding_count=int(row["finding_count"]),
+        fix_workers_dispatched=int(row["fix_workers_dispatched"]),
+        reaudit_score=(
+            int(row["reaudit_score"])
+            if row["reaudit_score"] is not None else None
+        ),
+        verdict=json.loads(row["verdict_json"]),
+    )
+
+
+def make_run_id() -> str:
+    return "ar-" + uuid.uuid4().hex[:10]
+
+
+def now() -> int:
+    return int(time.time())

package/omega/Agentik_Engine/omega_engine/audits/pipeline.py

@@ -0,0 +1,198 @@
+"""AuditPipeline — gather → analyse → batch → dispatch → reaudit → record.
+
+Wraps the existing ``audit_arsenal.run_forensic_audit`` (gather + agentic
+analysis) with the new layers the user asked for:
+
+  * **Batching** — cluster findings, never more than ``max_batches``
+    parallel workers.
+  * **Dispatching** — turn each batch into one worker mission via the
+    engine's executor (the same path ``omega run`` uses).
+  * **Re-audit** — after fixes land, run the same audit again and
+    compare scores.
+  * **History** — persist every run to ``Agentik_Runtime/audits.db``
+    so we can show trend and diff in the CLI / doctor.
+
+Two operating modes:
+
+  1. ``read_only=True`` (default for ``omega audit <id>``) —
+     gather + analyse + persist + return verdict. No fixes.
+  2. ``read_only=False`` (``omega audit <id> --fix``) —
+     above + batch + dispatch up to N workers + re-audit + persist again.
+
+All side-effecting steps are guarded by ``read_only`` so this pipeline
+can be used inside a tight verification loop (the ArsenalGate keeps the
+read-only path; ``--fix`` is opt-in for the CLI / autonomous charters).
+"""
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from omega_engine.audit_arsenal import (
+    Audit,
+    ArsenalVerdict,
+    AuditRegistry,
+    run_forensic_audit,
+)
+from omega_engine.audits.batcher import (
+    BatchPlan,
+    Finding,
+    batch_findings,
+)
+from omega_engine.audits.dispatcher import (
+    DispatchResult,
+    dispatch_fixes,
+)
+from omega_engine.audits.history import (
+    AuditRun,
+    make_run_id,
+    now,
+    record_run,
+)
+
+
+@dataclass
+class AuditOutcome:
+    """End-to-end result of an audit pipeline run."""
+    run_id: str
+    audit_id: str
+    verdict: ArsenalVerdict
+    scope: str
+    plan: BatchPlan | None = None
+    dispatches: list[DispatchResult] = field(default_factory=list)
+    reaudit: ArsenalVerdict | None = None
+    improved: bool = False             # reaudit.score > verdict.score
+    elapsed_s: float = 0.0
+
+
+class AuditPipeline:
+    """Run one audit end-to-end. Use one instance per audit + scope.
+
+    The constructor takes everything dependency-injected so the pipeline
+    is testable without a full OmegaOS install:
+
+      * ``registry``: ``AuditRegistry`` (load from
+        ``Agentik_SSOT/audits/`` for production).
+      * ``router``: an ``omega_engine.router.ModelRouter`` (single
+        provider OK for tests / Mock).
+      * ``omega_home``: the live tree; the history DB lives under it.
+      * ``executor`` (optional): used in ``fix`` mode to dispatch fix
+        workers. Pass ``None`` for read-only runs.
+    """
+
+    def __init__(
+        self,
+        registry: AuditRegistry,
+        router: Any,
+        *,
+        omega_home: str | Path | None = None,
+        executor: Any = None,
+    ) -> None:
+        self._registry = registry
+        self._router = router
+        self._home = Path(omega_home or os.environ.get("OMEGA_HOME")
+                          or Path.home() / "Omega")
+        self._executor = executor
+
+    def run(
+        self,
+        audit_id: str,
+        *,
+        scope: str = ".",
+        changed: list[str] | None = None,
+        role: str = "worker",
+        read_only: bool = True,
+        max_batches: int = 3,
+        max_files_per_batch: int = 10,
+        min_severity: str | None = None,
+        project: str | None = None,
+        record: bool = True,
+    ) -> AuditOutcome:
+        import time
+        audit = self._registry.get(audit_id)
+        if audit is None:
+            raise KeyError(f"unknown audit: {audit_id}")
+
+        ctx: dict[str, Any] = {
+            "path": scope, "changed": changed or [],
+            "role": role, "artifacts": {"path": scope},
+        }
+        if project:
+            ctx["project"] = {"slug": project,
+                              "path": str(self._home / "Agentik_Coding"
+                                          / "projects" / project)}
+
+        start = time.time()
+        provider = self._router.resolve("audit")
+        verdict = run_forensic_audit(audit, ctx, provider)
+        elapsed = time.time() - start
+
+        plan: BatchPlan | None = None
+        dispatches: list[DispatchResult] = []
+        reaudit_verdict: ArsenalVerdict | None = None
+        improved = False
+
+        if not read_only and verdict.fix_plan:
+            # The forensic verdict produced fix tasks — batch and dispatch.
+            findings = [Finding.from_arsenal(f) for f in verdict.findings]
+            plan = batch_findings(
+                findings, audit_id=audit_id,
+                max_batches=max_batches,
+                max_files_per_batch=max_files_per_batch,
+                min_severity=min_severity,
+            )
+            dispatches = dispatch_fixes(
+                plan, omega_home=self._home, audit_id=audit_id,
+                project=project, executor=self._executor,
+            )
+            # Re-audit after the fix workers finished.
+            reaudit_verdict = run_forensic_audit(audit, ctx, provider)
+            improved = reaudit_verdict.score > verdict.score
+
+        outcome = AuditOutcome(
+            run_id=make_run_id(),
+            audit_id=audit_id,
+            verdict=verdict,
+            scope=scope,
+            plan=plan,
+            dispatches=dispatches,
+            reaudit=reaudit_verdict,
+            improved=improved,
+            elapsed_s=round(elapsed, 2),
+        )
+
+        if record:
+            record_run(self._home, AuditRun(
+                run_id=outcome.run_id,
+                audit_id=audit_id,
+                scope=scope,
+                timestamp=now(),
+                score=int(verdict.score),
+                verified=bool(verdict.verified),
+                finding_count=len(verdict.findings),
+                fix_workers_dispatched=len(dispatches),
+                reaudit_score=(
+                    int(reaudit_verdict.score) if reaudit_verdict else None
+                ),
+                verdict=verdict.to_dict(),
+            ))
+
+        return outcome
+
+    def run_all_applicable(
+        self,
+        *,
+        scope: str = ".",
+        changed: list[str] | None = None,
+        role: str = "worker",
+        read_only: bool = True,
+    ) -> list[AuditOutcome]:
+        """Run every audit whose ``applies_to`` matches the context."""
+        applicable = self._registry.select(role=role, changed=changed or [])
+        return [
+            self.run(a.id, scope=scope, changed=changed, role=role,
+                     read_only=read_only)
+            for a in applicable
+        ]