@agentikos/omega-os 0.1.0 → 0.19.5

package/omega/Agentik_Engine/omega_engine/aisb_chat.py

@@ -0,0 +1,128 @@
+"""AISB chat-loop — talk to the AISB master agent like it was Telegram.
+
+The user often runs OmegaOS in places where Telegram isn't connected
+(fresh VPS, the operator on a different machine, etc.). The AISB chat
+loop is the fallback: spawn `tmux new-session -s AISB-chat` running
+this loop, attach, and you get a REPL-style conversation with the AISB
+master agent — same envelope, same .done.json contract, but stdin /
+stdout instead of Telegram.
+
+Conversation history is persisted in
+``Agentik_Runtime/telegram-history.db`` under topic_id = -1 (a sentinel
+"chat-loop" topic) so we share the same history layer the Telegram
+daemon already uses. The user sees prior turns at the top of each new
+session.
+"""
+from __future__ import annotations
+
+import os
+import sys
+import time
+from pathlib import Path
+
+
+CHAT_TOPIC = -1
+
+
+def _omega_home() -> Path:
+    return Path(os.environ.get("OMEGA_HOME", str(Path.home() / "Omega")))
+
+
+def _print_banner() -> None:
+    print("─" * 60)
+    print("  AISB chat — Telegram-equivalent fallback")
+    print(f"  history persisted under topic_id={CHAT_TOPIC}")
+    print("  type /quit to exit, /history to show the last 10 turns,")
+    print("       /clear to wipe this session's history")
+    print("─" * 60)
+
+
+def _print_history(home: Path, limit: int = 10) -> None:
+    from omega_engine.telegram_history import recent_messages
+    msgs = recent_messages(home, topic_id=CHAT_TOPIC, limit=limit)
+    if not msgs:
+        print("  (no history yet)")
+        return
+    for m in msgs:
+        print(f"  {m.role}: {m.text[:300]}")
+
+
+def _clear_history(home: Path) -> int:
+    from omega_engine.telegram_history import _connect
+    conn = _connect(home)
+    try:
+        cur = conn.execute(
+            "DELETE FROM messages WHERE topic_id = ?", (CHAT_TOPIC,),
+        )
+        conn.commit()
+        return int(cur.rowcount or 0)
+    finally:
+        conn.close()
+
+
+def run_chat_loop() -> int:
+    """Block until /quit. Returns 0 on clean exit."""
+    home = _omega_home()
+    from omega_engine.envelope import EnvelopeContext, build_envelope
+    from omega_engine.provider import AgentRequest
+    from omega_engine.router import ModelRouter
+    from omega_engine.telegram_history import (
+        build_context_prompt, record_inbound, record_outbound,
+    )
+
+    _print_banner()
+    router = ModelRouter.auto()
+
+    while True:
+        try:
+            line = input("\nyou > ").strip()
+        except (EOFError, KeyboardInterrupt):
+            print("\n(exit)")
+            return 0
+        if not line:
+            continue
+        if line == "/quit":
+            print("(exit)")
+            return 0
+        if line == "/history":
+            _print_history(home)
+            continue
+        if line == "/clear":
+            n = _clear_history(home)
+            print(f"(cleared {n} message(s))")
+            continue
+
+        # Record the user's turn.
+        record_inbound(home, topic_id=CHAT_TOPIC, text=line)
+
+        # Build the AISB envelope — same one the engine uses everywhere.
+        enriched = build_context_prompt(
+            home, topic_id=CHAT_TOPIC, new_intent=line, limit=10,
+        )
+        ctx = EnvelopeContext(
+            role="aisb",
+            intent=enriched,
+            task_id=f"chat-{int(time.time())}",
+        )
+        env = build_envelope(home, ctx)
+        provider = router.resolve("aisb")
+        try:
+            result = provider.run(AgentRequest(
+                role="aisb", prompt=env["user"], context={},
+                system=env["system"],
+            ))
+        except Exception as exc:  # noqa: BLE001
+            print(f"aisb (error): {exc}")
+            continue
+
+        reply = (result.text or "").strip() or "(empty reply)"
+        record_outbound(home, topic_id=CHAT_TOPIC, text=reply)
+        print(f"\naisb > {reply}")
+
+
+def main(argv: list[str] | None = None) -> int:
+    return run_chat_loop()
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/omega/Agentik_Engine/omega_engine/audit_diff.py

@@ -0,0 +1,99 @@
+"""`omega audit diff <run-id-1> <run-id-2>` — compare two forensic-audit runs.
+
+Given two run ids (same audit usually, but different audits also work),
+report:
+
+  * Score delta (run1 → run2)
+  * Findings that were FIXED (in run1, gone in run2)
+  * Findings that are NEW (in run2, weren't in run1)
+  * Findings that PERSIST (in both — the operator hasn't fixed them yet)
+  * Findings that REGRESSED (severity went UP in run2)
+
+We dedupe by `(phase, location, message)` — same finding location is
+considered "the same issue" across runs. This is a heuristic; for
+findings without locations (architectural) we dedupe by phase+message.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+@dataclass(frozen=True)
+class FindingKey:
+    phase: str
+    location: str
+    message: str
+
+
+@dataclass
+class AuditDiff:
+    run1: str
+    run2: str
+    audit_id: str
+    score1: int
+    score2: int
+    fixed: list[dict[str, Any]] = field(default_factory=list)
+    new: list[dict[str, Any]] = field(default_factory=list)
+    persist: list[dict[str, Any]] = field(default_factory=list)
+    regressed: list[dict[str, Any]] = field(default_factory=list)
+
+    @property
+    def delta(self) -> int:
+        return self.score2 - self.score1
+
+
+_SEVERITY_RANK = {"low": 0, "medium": 1, "med": 1,
+                   "high": 2, "critical": 3, "crit": 3}
+
+
+def _finding_key(f: dict) -> FindingKey:
+    return FindingKey(
+        phase=str(f.get("phase", "?")),
+        location=str(f.get("location", f.get("file", "?"))),
+        message=str(f.get("message", f.get("claim", "")))[:120],
+    )
+
+
+def _by_key(findings: list[dict]) -> dict[FindingKey, dict]:
+    return {_finding_key(f): f for f in findings}
+
+
+def diff_runs(
+    omega_home: str | Path, run1: str, run2: str,
+) -> AuditDiff:
+    """Load two audit runs from history and produce a structured diff."""
+    from omega_engine.audits.history import list_runs
+
+    runs = list_runs(omega_home, audit_id=None, limit=1000)
+    by_id = {r.run_id: r for r in runs}
+    r1 = by_id.get(run1)
+    r2 = by_id.get(run2)
+    if r1 is None:
+        raise KeyError(f"run not found: {run1}")
+    if r2 is None:
+        raise KeyError(f"run not found: {run2}")
+
+    findings1 = list(r1.verdict.get("findings") or [])
+    findings2 = list(r2.verdict.get("findings") or [])
+    map1 = _by_key(findings1)
+    map2 = _by_key(findings2)
+
+    fixed = [map1[k] for k in (map1.keys() - map2.keys())]
+    new = [map2[k] for k in (map2.keys() - map1.keys())]
+    persist_keys = map1.keys() & map2.keys()
+    persist = [map2[k] for k in persist_keys]
+    regressed = []
+    for k in persist_keys:
+        s1 = _SEVERITY_RANK.get(str(map1[k].get("severity", "medium")).lower(), 1)
+        s2 = _SEVERITY_RANK.get(str(map2[k].get("severity", "medium")).lower(), 1)
+        if s2 > s1:
+            regressed.append(map2[k])
+
+    return AuditDiff(
+        run1=run1, run2=run2,
+        audit_id=str(r2.audit_id),
+        score1=int(r1.score), score2=int(r2.score),
+        fixed=fixed, new=new, persist=persist, regressed=regressed,
+    )

package/omega/Agentik_Engine/omega_engine/audit_gate.py

@@ -0,0 +1,149 @@
+"""`omega audit gate` — the Claude Code Stop-hook gatekeeper.
+
+When ``claude_code_settings.audit_gate: true`` is set in the install
+manifest, the installer writes a ``Stop`` hook into
+``~/.claude/settings.json`` that calls this command. The hook fires
+whenever Claude is about to say "I'm done" — and this command decides
+whether the audit verdicts let it.
+
+Flow:
+
+  1. Claude finishes a turn.
+  2. Claude Code triggers the ``Stop`` hook.
+  3. ``omega audit gate`` reads the hook JSON from stdin
+     (``{session_id, cwd, ...}``).
+  4. We look at the per-session ``.done.json`` and the audit history
+     for the same scope.
+  5. If the most recent ``.done.json`` has ``status == "failed"`` OR
+     the latest audit run for the cwd has ``verified=False``, we
+     emit ``permissionDecision: deny`` with a clear reason. Claude
+     must keep working.
+  6. Otherwise we exit 0 silently and the Stop proceeds.
+
+This is the killer rule that closes the "Claude says done but isn't"
+loophole — at the *editor* level, not just the engine.
+"""
+from __future__ import annotations
+
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any
+
+
+def _omega_home() -> Path:
+    return Path(os.environ.get("OMEGA_HOME", str(Path.home() / "Omega")))
+
+
+def _read_hook_input() -> dict[str, Any]:
+    """Best-effort JSON read from stdin; an empty dict on failure."""
+    try:
+        raw = sys.stdin.read()
+    except Exception:  # noqa: BLE001
+        return {}
+    if not raw.strip():
+        return {}
+    try:
+        return json.loads(raw)
+    except json.JSONDecodeError:
+        return {}
+
+
+def _latest_done(home: Path, session_id: str) -> dict[str, Any] | None:
+    """Return the latest .done.json content for the session, or None."""
+    if not session_id:
+        return None
+    sess_root = home / "Agentik_Runtime" / "sessions"
+    candidates = list(sess_root.glob(f"*{session_id}*/.done.json"))
+    if not candidates:
+        return None
+    # newest by mtime
+    latest = max(candidates, key=lambda p: p.stat().st_mtime)
+    try:
+        return json.loads(latest.read_text())
+    except (json.JSONDecodeError, OSError):
+        return None
+
+
+def _latest_audit_failed(home: Path) -> tuple[bool, str]:
+    """Return (failed, message). True if the latest audit run was not verified."""
+    try:
+        from omega_engine.audits.history import list_runs
+    except ImportError:
+        return False, ""
+    runs = list_runs(home, audit_id=None, limit=1)
+    if not runs:
+        return False, ""
+    r = runs[0]
+    if r.verified:
+        return False, ""
+    return True, (
+        f"audit '{r.audit_id}' run {r.run_id} scored {r.score} "
+        f"(threshold not met). Fix the findings before declaring done."
+    )
+
+
+def _deny(reason: str) -> None:
+    """Emit the hookSpecificOutput payload that denies the Stop."""
+    payload = {
+        "continue": False,
+        "stopReason": reason,
+        "systemMessage": f"omega audit gate: {reason}",
+        "hookSpecificOutput": {
+            "hookEventName": "Stop",
+            "permissionDecision": "deny",
+            "permissionDecisionReason": reason,
+        },
+    }
+    print(json.dumps(payload))
+
+
+def gate(input_payload: dict[str, Any] | None = None) -> int:
+    """Decide whether to allow the Stop. Returns the exit code.
+
+    Exit 0 = allow (silent). Exit 2 + JSON on stdout = deny.
+    Other failures → exit 0 (we never break the editor on our own bugs).
+    """
+    home = _omega_home()
+    data = input_payload if input_payload is not None else _read_hook_input()
+
+    session_id = str(data.get("session_id") or "")
+
+    # 1. Did the worker explicitly write status=failed?
+    done = _latest_done(home, session_id)
+    if done and done.get("status") == "failed":
+        errs = ", ".join(done.get("errors") or [])[:300] or "no detail"
+        _deny(
+            f"worker reported status=failed in .done.json ({errs}). "
+            "Resume the task or revise."
+        )
+        return 2
+
+    # 2. Did the worker leave pending actions un-actioned?
+    if done and done.get("status") == "pending":
+        pa = done.get("pending_actions") or []
+        if pa:
+            _deny(
+                f"worker reported status=pending with {len(pa)} pending "
+                f"action(s): {pa[:3]}. Resolve or hand off explicitly."
+            )
+            return 2
+
+    # 3. Is the latest forensic audit verdict still failing?
+    failed, msg = _latest_audit_failed(home)
+    if failed:
+        _deny(msg)
+        return 2
+
+    # All clear.
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Entry point for the `omega audit gate` CLI."""
+    return gate()
+
+
+if __name__ == "__main__":
+    sys.exit(main())

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

@@ -0,0 +1,60 @@
+"""Audits package — the 100% mega powerful Quality Arsenal layer.
+
+What lives here:
+
+  * ``pipeline.AuditPipeline``   — gather + analyse + batch + dispatch +
+                                    re-audit + record, all in one call.
+  * ``batcher.batch_findings``    — cluster findings into ≤N disjoint
+                                    worker batches.
+  * ``dispatcher.dispatch_fixes`` — spawn a worker per batch via the
+                                    engine's executor.
+  * ``history.*``                 — SQLite-backed score history per audit.
+  * ``generator.write_all``       — produce ``SKILL.md`` for every audit.
+
+The existing forensic primitives (``Audit``, ``AuditRegistry``,
+``run_forensic_audit``, ``ArsenalGate``) stay in
+``omega_engine.audit_arsenal`` — this package builds the next layer on top.
+"""
+from omega_engine.audits.batcher import (
+    Batch,
+    BatchPlan,
+    Finding,
+    batch_findings,
+)
+from omega_engine.audits.dispatcher import (
+    DispatchResult,
+    dispatch_fixes,
+)
+from omega_engine.audits.generator import (
+    AuditSkillFile,
+    generate_all,
+    generate_skill,
+    write_all,
+)
+from omega_engine.audits.history import (
+    AuditRun,
+    latest_score,
+    list_runs,
+    make_run_id,
+    record_run,
+    trend,
+)
+from omega_engine.audits.pipeline import (
+    AuditOutcome,
+    AuditPipeline,
+)
+
+
+__all__ = [
+    # pipeline
+    "AuditPipeline", "AuditOutcome",
+    # batcher
+    "Finding", "Batch", "BatchPlan", "batch_findings",
+    # dispatcher
+    "DispatchResult", "dispatch_fixes",
+    # history
+    "AuditRun", "record_run", "list_runs", "latest_score", "trend",
+    "make_run_id",
+    # generator
+    "AuditSkillFile", "generate_skill", "generate_all", "write_all",
+]

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

@@ -0,0 +1,218 @@
+"""Smart finding batcher — cluster audit findings into ≤N worker batches.
+
+The user's hard constraint: fix the issues found, but DO NOT spawn one
+worker per finding (that would explode parallelism and overwhelm the
+system). Instead:
+
+  * Group findings by their file footprint.
+  * Pack groups into a small number of batches (default 3).
+  * Two batches MUST have disjoint file sets — never let two workers race
+    on the same file.
+  * Findings with no file location ("architectural") get their own batch.
+  * If total batches would exceed the cap, prefer the highest-severity
+    ones and emit a ``deferred`` list for the rest.
+
+This module is pure logic — no I/O, no subprocess. The dispatcher
+(``omega_engine.audits.dispatcher``) consumes the result and actually
+spawns workers.
+"""
+from __future__ import annotations
+
+from collections import defaultdict
+from dataclasses import dataclass, field
+from typing import Any, Iterable
+
+
+SEVERITY_WEIGHT = {
+    "critical": 100, "crit": 100,
+    "high": 30,
+    "medium": 10, "med": 10,
+    "low": 3,
+}
+
+
+def _severity_weight(severity: str) -> int:
+    return SEVERITY_WEIGHT.get(severity.lower().strip(), 5)
+
+
+@dataclass(frozen=True)
+class Finding:
+    """A normalised finding used by the batcher.
+
+    Constructed from either an ``ArsenalFinding`` (the structured form
+    emitted by the forensic gate) or a raw dict.
+    """
+    audit: str
+    phase: str
+    severity: str
+    file: str | None
+    line: int | None
+    message: str
+    fix_hint: str = ""
+
+    @staticmethod
+    def from_arsenal(f: Any) -> "Finding":
+        """Build from an `ArsenalFinding` (duck-typed for testability)."""
+        loc = getattr(f, "location", "?") or "?"
+        file, line = _parse_location(loc)
+        return Finding(
+            audit=getattr(f, "audit", "?"),
+            phase=getattr(f, "phase", "?"),
+            severity=getattr(f, "severity", "medium"),
+            file=file, line=line,
+            message=(
+                f"{getattr(f, 'claim', '')} → {getattr(f, 'reality', '')}".strip(" →")
+                or getattr(f, "message", "")
+            ),
+        )
+
+    @staticmethod
+    def from_dict(d: dict[str, Any]) -> "Finding":
+        loc = d.get("location") or d.get("file") or "?"
+        if isinstance(loc, str):
+            file, line = _parse_location(loc)
+        else:
+            file, line = None, None
+        return Finding(
+            audit=str(d.get("audit", "?")),
+            phase=str(d.get("phase", "?")),
+            severity=str(d.get("severity", "medium")),
+            file=file, line=line,
+            message=str(d.get("message", d.get("claim", "")))[:500],
+            fix_hint=str(d.get("fix", d.get("fix_hint", "")))[:500],
+        )
+
+
+def _parse_location(loc: str) -> tuple[str | None, int | None]:
+    """Parse 'path/to/file.py:42' → ('path/to/file.py', 42). None if no file."""
+    if not loc or loc == "?":
+        return None, None
+    # Strip leading "./" and the like
+    s = loc.strip()
+    if ":" in s:
+        path, _, rest = s.partition(":")
+        try:
+            line = int(rest.partition(":")[0])
+        except ValueError:
+            line = None
+        return (path or None), line
+    return s, None
+
+
+@dataclass
+class Batch:
+    """A fixable batch — a set of findings sharing a disjoint file footprint.
+
+    The dispatcher turns each Batch into one worker dispatch.
+    """
+    id: str
+    findings: list[Finding] = field(default_factory=list)
+    files: list[str] = field(default_factory=list)
+    score: int = 0       # higher = more severe — used to prioritise
+
+    def to_intent(self, audit_id: str) -> str:
+        """Render as a natural-language worker task description."""
+        bullets = []
+        for f in self.findings:
+            loc = f.file or "(global)"
+            if f.line:
+                loc = f"{loc}:{f.line}"
+            bullets.append(f"- [{f.severity}] {loc} — {f.message}")
+        return (
+            f"Fix the following {audit_id} findings:\n"
+            + "\n".join(bullets)
+            + ("\n\nFiles you may edit: " + ", ".join(self.files)
+               if self.files else "")
+        )
+
+
+@dataclass
+class BatchPlan:
+    """Output of ``batch_findings`` — ready-to-dispatch batches + deferred."""
+    batches: list[Batch]
+    deferred: list[Finding] = field(default_factory=list)
+    audit_id: str = ""
+
+
+def batch_findings(
+    findings: Iterable[Finding | Any],
+    *,
+    audit_id: str = "",
+    max_batches: int = 3,
+    max_files_per_batch: int = 10,
+    min_severity: str | None = None,
+) -> BatchPlan:
+    """Cluster findings into ≤``max_batches`` disjoint-file batches.
+
+    Algorithm:
+      1. Normalise the iterable to ``Finding`` objects.
+      2. Filter by ``min_severity`` if given (low|medium|high|critical).
+      3. Group by file (no file → goes in the "(global)" bucket).
+      4. Sort groups by aggregate severity (worst first).
+      5. Greedily pack the top groups into ``max_batches`` batches,
+         each carrying up to ``max_files_per_batch`` files, never
+         overlapping files between batches (impossible by construction
+         here, since each file lands in exactly one batch).
+      6. If we'd need more than ``max_batches`` batches, defer the
+         leftover groups and return them in ``deferred``.
+    """
+    norm: list[Finding] = []
+    for raw in findings:
+        if isinstance(raw, Finding):
+            norm.append(raw)
+        elif isinstance(raw, dict):
+            norm.append(Finding.from_dict(raw))
+        else:
+            norm.append(Finding.from_arsenal(raw))
+
+    if min_severity:
+        threshold = _severity_weight(min_severity)
+        norm = [f for f in norm if _severity_weight(f.severity) >= threshold]
+
+    by_file: dict[str, list[Finding]] = defaultdict(list)
+    for f in norm:
+        key = f.file or "(global)"
+        by_file[key].append(f)
+
+    # Sort files by aggregate severity weight, worst first.
+    file_score = {
+        key: sum(_severity_weight(f.severity) for f in fs)
+        for key, fs in by_file.items()
+    }
+    files_ranked = sorted(by_file.keys(), key=lambda k: -file_score[k])
+
+    # Greedy pack into max_batches: pick the batch with the smallest
+    # current finding count (tie-broken by lowest aggregate score).
+    batches: list[Batch] = [
+        Batch(id=f"b{i + 1}") for i in range(max(1, max_batches))
+    ]
+
+    deferred: list[Finding] = []
+    for file_key in files_ranked:
+        if file_key == "(global)":
+            # Global findings get their own slot — the LAST batch.
+            target_batch = batches[-1]
+        else:
+            # Smallest batch that still has file capacity.
+            candidates = [
+                b for b in batches
+                if len(b.files) < max_files_per_batch
+                and file_key not in b.files
+            ]
+            if not candidates:
+                deferred.extend(by_file[file_key])
+                continue
+            target_batch = min(
+                candidates, key=lambda b: (len(b.findings), b.score)
+            )
+        target_batch.findings.extend(by_file[file_key])
+        if file_key != "(global)":
+            target_batch.files.append(file_key)
+        target_batch.score += file_score[file_key]
+
+    # Drop empty batches.
+    batches = [b for b in batches if b.findings]
+    # Re-id sequentially.
+    for i, b in enumerate(batches, start=1):
+        b.id = f"b{i}"
+    return BatchPlan(batches=batches, deferred=deferred, audit_id=audit_id)