@agentikos/omega-os 0.1.0

package/omega/Agentik_Engine/tests/test_audit_arsenal.py

@@ -0,0 +1,80 @@
+"""The Quality Arsenal — forensic audits wired into the OmegaOS verification gate.
+
+Standalone: python3 tests/test_audit_arsenal.py
+"""
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from omega_engine.audit_arsenal import (             # noqa: E402
+    ArsenalGate,
+    AuditRegistry,
+    run_forensic_audit,
+)
+from omega_engine.provider import MockProvider       # noqa: E402
+from omega_engine.router import ModelRouter          # noqa: E402
+
+# the audit definitions live in the SSOT block of the repo
+AUDITS_DIR = Path(__file__).resolve().parents[2] / "Agentik_SSOT" / "audits"
+
+
+def test_registry_loads_audits():
+    reg = AuditRegistry.load(AUDITS_DIR)
+    assert len(reg.all()) >= 1, "no audits loaded from the SSOT"
+    code = reg.get("codeaudit")
+    assert code is not None and code.domain == "code"
+    assert len(code.phases) >= 5, "codeaudit has too few phases"
+    assert code.gather, "codeaudit declares no deterministic gather tools"
+    print(f"        {len(reg.all())} audit(s) loaded from Agentik_SSOT/audits/")
+
+
+def test_forensic_audit_runs_and_verdicts():
+    reg = AuditRegistry.load(AUDITS_DIR)
+    code = reg.get("codeaudit")
+    ctx = {"role": "worker", "changed": ["pricing.py"], "path": ".",
+           "artifacts": {"files": ["pricing.py"], "summary": "fixed pricing"}}
+    verdict = run_forensic_audit(code, ctx, MockProvider())
+    assert verdict.audit == "codeaudit"
+    assert verdict.verified, f"score={verdict.score}"
+    assert verdict.score >= 85
+    assert verdict.confidence in ("high", "medium", "low")
+
+
+def test_arsenal_gate_selects_and_aggregates():
+    reg = AuditRegistry.load(AUDITS_DIR)
+    gate = ArsenalGate(reg, ModelRouter.single(MockProvider()))
+    ctx = {"role": "worker", "changed": ["pricing.py"], "path": ".",
+           "artifacts": {"files": ["pricing.py"], "summary": "done"},
+           "runtime_cmd": "true"}
+    verdict = gate.verify(ctx)
+    assert verdict.verified, f"gate rejected: score={verdict.score}"
+    assert gate.last_verdicts, "no forensic verdicts recorded for the report"
+    print(f"        gate ran runtime + {len(gate.last_verdicts)} forensic audit(s)")
+
+
+def test_gate_rejects_when_live_flow_fails():
+    # validate-live is non-negotiable: a broken flow can never be VERIFIED.
+    reg = AuditRegistry.load(AUDITS_DIR)
+    gate = ArsenalGate(reg, ModelRouter.single(MockProvider()))
+    ctx = {"role": "worker", "changed": ["x.py"], "path": ".",
+           "artifacts": {"files": ["x.py"]}, "runtime_cmd": "false"}
+    verdict = gate.verify(ctx)
+    assert not verdict.verified, "must reject when the live flow fails"
+    assert verdict.score == 0
+
+
+def _run_all() -> bool:
+    tests = [v for k, v in sorted(globals().items())
+             if k.startswith("test_") and callable(v)]
+    passed = 0
+    for t in tests:
+        t()
+        print(f"  PASS  {t.__name__}")
+        passed += 1
+    print(f"\n{passed}/{len(tests)} arsenal tests passed")
+    return passed == len(tests)
+
+
+if __name__ == "__main__":
+    sys.exit(0 if _run_all() else 1)

package/omega/Agentik_Engine/tests/test_executor.py

@@ -0,0 +1,96 @@
+"""End-to-end: a real mission runs through the executor and reaches VERIFIED.
+
+THE proof that OmegaOS orchestration works — verified completion, the join
+barrier, and the audit gate (which really runs a subprocess) all exercised with
+a deterministic MockProvider. Runs standalone: python3 tests/test_executor.py
+"""
+import os
+import sys
+import tempfile
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from omega_engine.audit import AuditGate                  # noqa: E402
+from omega_engine.bus import EventBus                     # noqa: E402
+from omega_engine.executor import Executor                # noqa: E402
+from omega_engine.provider import MockProvider            # noqa: E402
+from omega_engine.reducer import reduce_task              # noqa: E402
+from omega_engine.router import ModelRouter               # noqa: E402
+from omega_engine.store import SQLiteStore                # noqa: E402
+from omega_engine.task import Kind, TaskState             # noqa: E402
+
+
+def _engine(plan_size: int = 2):
+    db = tempfile.mktemp(suffix=".db")
+    store = SQLiteStore(db)
+    bus = EventBus(store)
+    router = ModelRouter.single(MockProvider(plan_size=plan_size))
+    executor = Executor(store, bus, router, AuditGate())
+    return store, executor, db
+
+
+def test_mission_runs_to_verified():
+    store, executor, db = _engine(plan_size=3)
+    result = executor.run_mission("fix the pricing bug")
+    assert result.verified, f"mission did not complete: {result.final_state}"
+    assert result.final_state is TaskState.COMPLETED
+    workers = [t for t in result.tasks.values() if t.kind is Kind.EXECUTOR]
+    assert len(workers) == 3, f"expected 3 workers, got {len(workers)}"
+    for w in workers:
+        assert reduce_task(store.events_for(w.id)) is TaskState.COMPLETED
+    store.close()
+    os.remove(db)
+
+
+def test_every_emitted_sequence_is_fsm_legal():
+    # reduce_task raises IllegalTransition on a bad sequence. If this passes,
+    # every event the executor emitted is a legal FSM transition.
+    store, executor, db = _engine()
+    executor.run_mission("ship the feature")
+    for tid in store.task_ids():
+        reduce_task(store.events_for(tid))  # raises if illegal
+    store.close()
+    os.remove(db)
+
+
+def test_worker_passes_through_the_audit_gate():
+    # completion is verified: a worker must go VERIFYING before VERIFIED.
+    store, executor, db = _engine(plan_size=1)
+    result = executor.run_mission("one task")
+    worker = next(t for t in result.tasks.values() if t.kind is Kind.EXECUTOR)
+    types = [e.type.value for e in store.events_for(worker.id)]
+    assert "task.verifying" in types
+    assert "task.verified" in types
+    assert types.index("task.verifying") < types.index("task.verified")
+    assert types[-1] == "task.completed"
+    store.close()
+    os.remove(db)
+
+
+def test_root_completes_only_after_children():
+    # the join barrier: scope.joinable is emitted on the root, and only after
+    # every worker is already terminal.
+    store, executor, db = _engine(plan_size=2)
+    result = executor.run_mission("barrier check")
+    root_events = [e.type.value for e in store.events_for(result.root.id)]
+    assert "scope.joinable" in root_events
+    assert root_events.index("scope.joinable") < root_events.index("task.completed")
+    store.close()
+    os.remove(db)
+
+
+def _run_all() -> bool:
+    tests = [v for k, v in sorted(globals().items())
+             if k.startswith("test_") and callable(v)]
+    passed = 0
+    for t in tests:
+        t()
+        print(f"  PASS  {t.__name__}")
+        passed += 1
+    print(f"\n{passed}/{len(tests)} executor tests passed")
+    return passed == len(tests)
+
+
+if __name__ == "__main__":
+    sys.exit(0 if _run_all() else 1)

package/omega/Agentik_Engine/tests/test_mission.py

@@ -0,0 +1,64 @@
+"""Mission coordinator — run_mission end to end, always with a PDF report.
+
+Standalone: python3 tests/test_mission.py
+"""
+import os
+import shutil
+import sys
+import tempfile
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+# force the deterministic provider even if ANTHROPIC_API_KEY is in the env
+os.environ["OMEGA_PROVIDER"] = "mock"
+
+from omega_engine.mission import run_mission  # noqa: E402
+
+
+def _pdfgen_bin() -> str | None:
+    env = os.environ.get("OMEGA_PDFGEN")
+    if env and Path(env).exists():
+        return env
+    fallback = Path.home() / ".claude" / "lib" / "pdfgen.sh"
+    return str(fallback) if fallback.exists() else None
+
+
+def test_run_mission_end_to_end():
+    binary = _pdfgen_bin()
+    if binary:
+        os.environ["OMEGA_PDFGEN"] = binary
+    home = Path(tempfile.mkdtemp())
+    try:
+        outcome = run_mission("add a logout button", omega_home=home)
+        assert outcome.result.verified, (
+            f"mission failed: {outcome.result.final_state}")
+        assert outcome.progress_pct == 100, f"pct={outcome.progress_pct}"
+        if binary:
+            assert outcome.report_pdf is not None, "no report produced"
+            assert outcome.report_pdf.exists(), "report PDF missing on disk"
+            assert outcome.report_pdf.stat().st_size > 5000
+            print(f"        mission verified + report: "
+                  f"{outcome.report_pdf.stat().st_size // 1024} KB PDF")
+        else:
+            print("        mission verified (pdfgen not on host — report skipped)")
+        # the event log persisted under Agentik_Runtime
+        assert (home / "Agentik_Runtime" / "eventlog" / "omega.db").exists()
+    finally:
+        shutil.rmtree(home, ignore_errors=True)
+
+
+def _run_all() -> bool:
+    tests = [v for k, v in sorted(globals().items())
+             if k.startswith("test_") and callable(v)]
+    passed = 0
+    for t in tests:
+        t()
+        print(f"  PASS  {t.__name__}")
+        passed += 1
+    print(f"\n{passed}/{len(tests)} mission tests passed")
+    return passed == len(tests)
+
+
+if __name__ == "__main__":
+    sys.exit(0 if _run_all() else 1)

package/omega/Agentik_Engine/tests/test_progress.py

@@ -0,0 +1,69 @@
+"""Progress tracking — the bus subscriber turns events into a progress bar.
+
+Standalone: python3 tests/test_progress.py
+"""
+import os
+import sys
+import tempfile
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from omega_engine.audit import AuditGate           # noqa: E402
+from omega_engine.bus import EventBus              # noqa: E402
+from omega_engine.executor import Executor         # noqa: E402
+from omega_engine.progress import ProgressTracker  # noqa: E402
+from omega_engine.provider import MockProvider     # noqa: E402
+from omega_engine.router import ModelRouter        # noqa: E402
+from omega_engine.store import SQLiteStore         # noqa: E402
+
+
+def _run(plan_size=3):
+    db = tempfile.mktemp(suffix=".db")
+    store = SQLiteStore(db)
+    bus = EventBus(store)
+    tracker = ProgressTracker()
+    bus.subscribe(tracker.on_event)          # <-- progress is a bus subscriber
+    executor = Executor(store, bus, ModelRouter.single(MockProvider(plan_size)),
+                        AuditGate())
+    result = executor.run_mission("track me")
+    store.close()
+    os.remove(db)
+    return tracker, result
+
+
+def test_progress_reaches_100():
+    tracker, result = _run(plan_size=3)
+    prog = tracker.progress(result.mission_id)
+    assert prog is not None, "no progress recorded"
+    # 1 oracle + 3 workers = 4 tasks, all verified
+    assert prog.total_tasks == 4, f"total={prog.total_tasks}"
+    assert prog.verified == 4, f"verified={prog.verified}"
+    assert prog.failed == 0
+    assert prog.pct == 100, f"pct={prog.pct}"
+
+
+def test_progress_bar_renders():
+    tracker, result = _run(plan_size=2)
+    prog = tracker.progress(result.mission_id)
+    bar = prog.bar(width=20)
+    assert len(bar) == 20
+    block = prog.render(title="Mission")
+    assert "100%" in block
+    assert "Mission" in block
+
+
+def _run_all() -> bool:
+    tests = [v for k, v in sorted(globals().items())
+             if k.startswith("test_") and callable(v)]
+    passed = 0
+    for t in tests:
+        t()
+        print(f"  PASS  {t.__name__}")
+        passed += 1
+    print(f"\n{passed}/{len(tests)} progress tests passed")
+    return passed == len(tests)
+
+
+if __name__ == "__main__":
+    sys.exit(0 if _run_all() else 1)

package/omega/Agentik_Engine/tests/test_project.py

@@ -0,0 +1,61 @@
+"""Project creation — structure + registry. Standalone: python3 tests/test_project.py"""
+import shutil
+import sys
+import tempfile
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from omega_engine.project import create_project, load_projects, slugify  # noqa: E402
+
+
+def test_slugify():
+    assert slugify("My Cool Project!") == "my-cool-project"
+    assert slugify("Causio") == "causio"
+    assert slugify("  ") == "project"
+
+
+def test_create_project_builds_structure():
+    home = Path(tempfile.mkdtemp())
+    try:
+        p = create_project("Pricing Tool", omega_home=home)  # no Telegram
+        assert p.slug == "pricing-tool"
+        assert Path(p.path).is_dir()
+        assert (Path(p.path) / "README.md").exists()
+        assert p.topic_id is None  # no Telegram bridge given
+        # registered
+        projects = load_projects(home)
+        assert len(projects) == 1
+        assert projects[0].slug == "pricing-tool"
+    finally:
+        shutil.rmtree(home, ignore_errors=True)
+
+
+def test_duplicate_project_rejected():
+    home = Path(tempfile.mkdtemp())
+    try:
+        create_project("Dup", omega_home=home)
+        raised = False
+        try:
+            create_project("Dup", omega_home=home)
+        except ValueError:
+            raised = True
+        assert raised, "duplicate project must be rejected"
+    finally:
+        shutil.rmtree(home, ignore_errors=True)
+
+
+def _run_all() -> bool:
+    tests = [v for k, v in sorted(globals().items())
+             if k.startswith("test_") and callable(v)]
+    passed = 0
+    for t in tests:
+        t()
+        print(f"  PASS  {t.__name__}")
+        passed += 1
+    print(f"\n{passed}/{len(tests)} project tests passed")
+    return passed == len(tests)
+
+
+if __name__ == "__main__":
+    sys.exit(0 if _run_all() else 1)

package/omega/Agentik_Engine/tests/test_reducer.py

@@ -0,0 +1,144 @@
+"""Tests for the reducer and the join barrier — the engine's anti-hallucination core.
+
+Runs under pytest, or standalone:  python3 tests/test_reducer.py
+"""
+import sys
+from pathlib import Path
+
+# allow `python3 tests/test_reducer.py` from anywhere
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from omega_engine.barrier import ScopeStatus, scope_status   # noqa: E402
+from omega_engine.events import Event, EventType             # noqa: E402
+from omega_engine.reducer import IllegalTransition, reduce_task  # noqa: E402
+from omega_engine.task import TaskState                      # noqa: E402
+
+
+def _ev(task_id: str, etype: EventType) -> Event:
+    return Event(task_id=task_id, type=etype)
+
+
+def test_happy_path_to_completed():
+    events = [
+        _ev("t1", EventType.CREATED),
+        _ev("t1", EventType.DISPATCHED),
+        _ev("t1", EventType.STARTED),
+        _ev("t1", EventType.CLAIMED_DONE),
+        _ev("t1", EventType.VERIFYING),
+        _ev("t1", EventType.VERIFIED),
+        _ev("t1", EventType.COMPLETED),
+    ]
+    assert reduce_task(events) is TaskState.COMPLETED
+
+
+def test_claimed_done_is_not_completion():
+    # THE crux test: a worker claiming done does NOT reach verified/terminal.
+    events = [
+        _ev("t1", EventType.CREATED),
+        _ev("t1", EventType.DISPATCHED),
+        _ev("t1", EventType.STARTED),
+        _ev("t1", EventType.CLAIMED_DONE),
+    ]
+    state = reduce_task(events)
+    assert state is TaskState.CLAIMED_DONE
+    assert state is not TaskState.VERIFIED
+    assert state is not TaskState.COMPLETED
+
+
+def test_reject_then_retry_then_pass():
+    events = [
+        _ev("t1", EventType.CREATED),
+        _ev("t1", EventType.DISPATCHED),
+        _ev("t1", EventType.STARTED),
+        _ev("t1", EventType.CLAIMED_DONE),
+        _ev("t1", EventType.VERIFYING),
+        _ev("t1", EventType.REJECTED),
+        _ev("t1", EventType.DISPATCHED),   # retry within budget
+        _ev("t1", EventType.STARTED),
+        _ev("t1", EventType.CLAIMED_DONE),
+        _ev("t1", EventType.VERIFYING),
+        _ev("t1", EventType.VERIFIED),
+        _ev("t1", EventType.COMPLETED),
+    ]
+    assert reduce_task(events) is TaskState.COMPLETED
+
+
+def test_deadman_kills_a_live_task():
+    events = [
+        _ev("t1", EventType.CREATED),
+        _ev("t1", EventType.DISPATCHED),
+        _ev("t1", EventType.STARTED),
+        _ev("t1", EventType.FAILED),       # deadman fires from RUNNING
+    ]
+    assert reduce_task(events) is TaskState.FAILED
+
+
+def test_illegal_transition_raises():
+    # cannot START a task that was never DISPATCHED
+    events = [_ev("t1", EventType.CREATED), _ev("t1", EventType.STARTED)]
+    try:
+        reduce_task(events)
+        raised = False
+    except IllegalTransition:
+        raised = True
+    assert raised, "an illegal transition must raise, not corrupt"
+
+
+def test_failed_on_terminal_is_illegal():
+    events = [
+        _ev("t1", EventType.CREATED),
+        _ev("t1", EventType.DISPATCHED),
+        _ev("t1", EventType.STARTED),
+        _ev("t1", EventType.CLAIMED_DONE),
+        _ev("t1", EventType.VERIFYING),
+        _ev("t1", EventType.VERIFIED),
+        _ev("t1", EventType.COMPLETED),
+        _ev("t1", EventType.FAILED),       # cannot fail a COMPLETED task
+    ]
+    try:
+        reduce_task(events)
+        raised = False
+    except IllegalTransition:
+        raised = True
+    assert raised
+
+
+def test_empty_stream_raises():
+    try:
+        reduce_task([])
+        raised = False
+    except IllegalTransition:
+        raised = True
+    assert raised
+
+
+def test_barrier_running_until_all_terminal():
+    assert scope_status([TaskState.RUNNING, TaskState.COMPLETED]) is ScopeStatus.RUNNING
+
+
+def test_barrier_joinable_when_all_completed():
+    assert scope_status([TaskState.COMPLETED, TaskState.COMPLETED]) is ScopeStatus.JOINABLE
+
+
+def test_barrier_partial_when_a_child_failed():
+    assert scope_status([TaskState.COMPLETED, TaskState.FAILED]) is ScopeStatus.PARTIAL
+
+
+def test_barrier_empty_scope_is_joinable():
+    assert scope_status([]) is ScopeStatus.JOINABLE
+
+
+def _run_all() -> bool:
+    tests = [v for k, v in sorted(globals().items())
+             if k.startswith("test_") and callable(v)]
+    passed = 0
+    for t in tests:
+        t()
+        print(f"  PASS  {t.__name__}")
+        passed += 1
+    print(f"\n{passed}/{len(tests)} tests passed")
+    return passed == len(tests)
+
+
+if __name__ == "__main__":
+    sys.exit(0 if _run_all() else 1)

package/omega/Agentik_Engine/tests/test_report.py

@@ -0,0 +1,88 @@
+"""Mission report -> real PDF, end to end.
+
+Runs a mission, builds the whitepaper report, renders it through the pdfgen
+tool, and asserts a real PDF lands on disk. Standalone: python3 tests/test_report.py
+"""
+import os
+import sys
+import tempfile
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from omega_engine.audit import AuditGate              # noqa: E402
+from omega_engine.bus import EventBus                 # noqa: E402
+from omega_engine.executor import Executor            # noqa: E402
+from omega_engine.provider import MockProvider        # noqa: E402
+from omega_engine.report import build_report, generate_mission_report  # noqa: E402
+from omega_engine.router import ModelRouter           # noqa: E402
+from omega_engine.store import SQLiteStore            # noqa: E402
+
+
+def _pdfgen_bin() -> str | None:
+    env = os.environ.get("OMEGA_PDFGEN")
+    if env and Path(env).exists():
+        return env
+    fallback = Path.home() / ".claude" / "lib" / "pdfgen.sh"
+    return str(fallback) if fallback.exists() else None
+
+
+def _run_mission():
+    db = tempfile.mktemp(suffix=".db")
+    store = SQLiteStore(db)
+    bus = EventBus(store)
+    executor = Executor(store, bus, ModelRouter.single(MockProvider(plan_size=3)),
+                        AuditGate())
+    result = executor.run_mission("fix the checkout flow")
+    return store, result, db
+
+
+def test_build_report_shape():
+    """The report data matches the pdfgen whitepaper schema — no PDF needed."""
+    store, result, db = _run_mission()
+    data = build_report(result, store)
+    assert data["template"] == "whitepaper"
+    assert data["theme"] == "agentik"
+    assert data["abstract"] and data["title"]
+    assert len(data["sections"]) == 4
+    for s in data["sections"]:
+        assert s["index"] and s["title"] and s["body"]
+    store.close()
+    os.remove(db)
+    print("        report schema OK (4 sections, whitepaper/agentik)")
+
+
+def test_render_real_pdf():
+    """Render the report through the real pdfgen tool — a genuine PDF on disk."""
+    binary = _pdfgen_bin()
+    if not binary:
+        print("        SKIP — pdfgen tool not found on this host")
+        return
+    store, result, db = _run_mission()
+    out_dir = tempfile.mkdtemp()
+    pdf = generate_mission_report(result, store, out_dir, pdfgen_bin=binary)
+    assert pdf.exists(), "no PDF produced"
+    size = pdf.stat().st_size
+    assert size > 5000, f"PDF suspiciously small: {size} bytes"
+    head = pdf.read_bytes()[:5]
+    assert head.startswith(b"%PDF"), "output is not a PDF"
+    print(f"        real PDF rendered: {pdf} ({size // 1024} KB)")
+    pdf.unlink()
+    store.close()
+    os.remove(db)
+
+
+def _run_all() -> bool:
+    tests = [v for k, v in sorted(globals().items())
+             if k.startswith("test_") and callable(v)]
+    passed = 0
+    for t in tests:
+        t()
+        print(f"  PASS  {t.__name__}")
+        passed += 1
+    print(f"\n{passed}/{len(tests)} report tests passed")
+    return passed == len(tests)
+
+
+if __name__ == "__main__":
+    sys.exit(0 if _run_all() else 1)

package/omega/Agentik_Extra/README.md

@@ -0,0 +1,37 @@
+# Agentik_Extra — ephemeral + config + secrets
+
+> **Nature:** periphery · **Lifecycle:** disposable / sensitive · **Git:** not versioned
+
+The eighth block absorbs everything that would otherwise clutter the master
+folder, so `~/Omega/` stays at exactly eight clean entries.
+
+```
+Agentik_Extra/
+├── var/
+│   ├── cache/           XDG_CACHE_HOME points here
+│   ├── tmp/             TMPDIR points here
+│   ├── logs/            rotated automatically
+│   └── .install-state  the installer's resume marker
+├── staging/
+│   └── promotion/       the educators' pipeline: staged → audited → promoted to SSOT
+└── etc/
+    ├── agentik.env      the environment that forces the tidy layout
+    ├── structure.yaml   the arborescence manifest — checked hourly for drift
+    └── secrets/         the encrypted vault — API keys, tokens (chmod 700)
+```
+
+## Three regimes, one block
+
+- **`var/`** — pure ephemeral. Safe to wipe at any time. All cache and temp files
+  point here, so nothing scatters across the home directory or `/tmp`.
+- **`staging/`** — the educators' workspace. An educator writes a proposed change
+  to `promotion/`; the audit gate validates it; only then is it promoted into
+  `Agentik_SSOT/`. Never silent self-modification.
+- **`etc/`** — configuration and secrets.
+
+## Secrets — a vault, not a folder
+
+`etc/secrets/` is `chmod 700` and holds an **encrypted** vault (age/sops or the
+OS keyring). The installer never writes a plaintext secret into the tree;
+config files store a *reference* (`secret_ref: COMPOSIO_API_KEY`), resolved at
+use time. `secrets/` is git-ignored without exception.

package/omega/Agentik_Extra/etc/agentik.env.example

@@ -0,0 +1,19 @@
+# Omega OS — environment.
+# The installer copies this to agentik.env and sources it from the shell rc.
+# These variables FORCE every tool to range its files inside the rack.
+
+# --- the master folder ---
+export OMEGA_HOME="$HOME/Omega"
+
+# --- the only directory added to PATH (symlinks to installed tools) ---
+export PATH="$OMEGA_HOME/Agentik_Tools/bin:$PATH"
+
+# --- redirect all cache + temp into the Extra block ---
+export XDG_CACHE_HOME="$OMEGA_HOME/Agentik_Extra/var/cache"
+export TMPDIR="$OMEGA_HOME/Agentik_Extra/var/tmp"
+
+# --- the runtime event log (the source of truth) ---
+export OMEGA_EVENTLOG="$OMEGA_HOME/Agentik_Runtime/eventlog/omega.db"
+
+# --- secrets are loaded from the encrypted vault, never set here ---
+# export COMPOSIO_API_KEY=...   # NO — use Agentik_Extra/etc/secrets/