@agentikos/omega-os 0.1.0 → 0.2.0

package/omega/Agentik_Engine/omega_engine/educators/base.py

@@ -0,0 +1,327 @@
+"""The educator framework — generators that produce SSOT artifacts under a gate.
+
+Where the Quality Arsenal verifies code (`CLAIMED_DONE → VERIFIED`), the educators
+generate the genome itself: prompts, templates, skills, roles, connectors,
+automations, adapters, loops. They are the self-improving layer.
+
+Three pieces, shared by every educator:
+  - `Artifact`            — what gets produced (with where in the SSOT it lands)
+  - `EducatorProposal`    — the artifact plus the educator's self-critique
+  - `Educator` Protocol   — the contract: `generate(intent, context, provider)`
+  - `EducatorRegistry`    — discovery of every concrete educator
+  - `StagingPipeline`     — writes proposals to staging (NEVER to SSOT)
+                            — promotion is a separate step under the audit gate.
+
+The doctrine for generation mirrors the doctrine for audit, inverted: produce a
+high-quality artifact (Gestalt clarity), then self-criticize it (Popper: where
+does it lie?), then refine. The shared shell lives in `build_education_prompt`.
+"""
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Protocol, runtime_checkable
+
+from omega_engine.provider import AgentProvider, AgentRequest
+
+
+# --------------------------------------------------------------------------
+# Structured types — what an educator produces, what staging consumes.
+# --------------------------------------------------------------------------
+
+
+@dataclass
+class Artifact:
+    """One generated artifact, with the target SSOT path it should land at."""
+
+    id: str
+    kind: str               # "prompt" | "template" | "skill" | "agent" | ...
+    content: str
+    target_path: str        # POSIX path inside Agentik_SSOT/... (or Agentik_AI/...)
+
+
+@dataclass
+class EducatorProposal:
+    """An artifact plus the educator's self-critique — what staging reviews."""
+
+    educator: str
+    artifact: Artifact
+    score: int                                          # 0-100 self-critique
+    summary: str = ""
+    fix_plan: list[dict[str, Any]] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "educator": self.educator,
+            "score": self.score,
+            "summary": self.summary,
+            "fix_plan": self.fix_plan,
+            "artifact": {
+                "id": self.artifact.id,
+                "kind": self.artifact.kind,
+                "target_path": self.artifact.target_path,
+                "content": self.artifact.content,
+            },
+        }
+
+
+# --------------------------------------------------------------------------
+# The contract — every educator implements this.
+# --------------------------------------------------------------------------
+
+
+@runtime_checkable
+class Educator(Protocol):
+    """One educator: a focused generator for one domain of the SSOT."""
+
+    name: str
+    domain: str
+
+    def generate(
+        self,
+        intent: str,
+        context: dict[str, Any],
+        provider: AgentProvider,
+    ) -> EducatorProposal: ...
+
+
+# --------------------------------------------------------------------------
+# Shared generation doctrine + helpers — used by every concrete educator.
+# --------------------------------------------------------------------------
+
+_DOCTRINE = """\
+You are a senior generator, not a friendly drafter. The artifact you produce
+becomes part of the system's genome — the SSOT. Apply the Gestalt-Popper
+doctrine to GENERATION:
+- GESTALT: identify the hinge — the one element that, if vague or wrong, makes
+  the whole artifact useless. Make THAT element razor-sharp first.
+- POPPER: produce a draft, then attack it. Where does it lie, hand-wave, or
+  promise more than it delivers? List the falsifiable claims and fix them.
+- ADVERSARIAL: assume the next reader is a hostile worker who will misuse any
+  vagueness. Be specific, complete, and runnable. No prose for prose's sake.
+Banned: "should", "could", "TBD", filler. Every line must earn its place.
+"""
+
+
+def build_education_prompt(
+    educator_name: str,
+    domain: str,
+    intent: str,
+    target_kind: str,
+    target_path_hint: str,
+    domain_instructions: str,
+    context: dict[str, Any],
+) -> str:
+    """Compose the agentic generation prompt — shared shell + domain payload.
+
+    Each educator passes its own `domain_instructions` — the actual signature of
+    the educator. Everything else (doctrine, output contract) is shared.
+    """
+    ctx_brief = json.dumps(context, indent=2, default=str)[:2500]
+    return (
+        f"{_DOCTRINE}\n"
+        f"EDUCATOR: {educator_name} — domain {domain}\n"
+        f"INTENT: {intent}\n"
+        f"TARGET ARTIFACT KIND: {target_kind}\n"
+        f"TARGET SSOT PATH HINT: {target_path_hint}\n\n"
+        f"DOMAIN INSTRUCTIONS — what THIS educator must produce:\n"
+        f"{domain_instructions}\n\n"
+        f"CONTEXT:\n{ctx_brief}\n\n"
+        f"Emit ONLY a JSON proposal: "
+        f"{{\"kind\": \"{target_kind}\", \"content\": \"<the full artifact>\", "
+        f"\"score\": 0-100, \"summary\": \"<one-line self-critique>\", "
+        f"\"fix_plan\": [{{\"id\",\"issue\",\"fix\"}}]}}. "
+        f"score >= 85 means the artifact is ready for staging."
+    )
+
+
+def parse_proposal(
+    educator_name: str,
+    artifact_id: str,
+    target_path: str,
+    target_kind: str,
+    raw: dict[str, Any],
+) -> EducatorProposal:
+    """Build an `EducatorProposal` from a raw provider response dict."""
+    return EducatorProposal(
+        educator=educator_name,
+        artifact=Artifact(
+            id=artifact_id,
+            kind=raw.get("kind", target_kind),
+            content=raw.get("content", ""),
+            target_path=target_path,
+        ),
+        score=int(raw.get("score", 0)),
+        summary=raw.get("summary", ""),
+        fix_plan=list(raw.get("fix_plan", [])),
+    )
+
+
+def run_education(
+    educator_name: str,
+    domain: str,
+    intent: str,
+    target_kind: str,
+    target_path: str,
+    domain_instructions: str,
+    context: dict[str, Any],
+    provider: AgentProvider,
+    artifact_id: str | None = None,
+) -> EducatorProposal:
+    """The shared run loop: build prompt, call provider, parse proposal.
+
+    Every concrete educator reduces to one call to this. The provider role is
+    ``educator-<name>`` so the router can wire a different LLM to each educator
+    (a cheap model for templates, Claude for prompts, etc.).
+    """
+    prompt = build_education_prompt(
+        educator_name=educator_name,
+        domain=domain,
+        intent=intent,
+        target_kind=target_kind,
+        target_path_hint=target_path,
+        domain_instructions=domain_instructions,
+        context={**context, "intent": intent, "kind": target_kind},
+    )
+    result = provider.run(AgentRequest(
+        role=f"educator-{educator_name}",
+        prompt=prompt,
+        context={**context, "intent": intent, "kind": target_kind},
+    ))
+    raw = result.artifacts.get("proposal")
+    if raw is None:
+        try:
+            raw = json.loads(result.text)
+        except (json.JSONDecodeError, TypeError):
+            raw = {
+                "kind": target_kind,
+                "content": result.text or "",
+                "score": 0,
+                "summary": "educator produced no parseable proposal",
+                "fix_plan": [],
+            }
+    aid = artifact_id or f"{educator_name}-{abs(hash(intent)) % 10_000_000:07d}"
+    return parse_proposal(educator_name, aid, target_path, target_kind, raw)
+
+
+# --------------------------------------------------------------------------
+# Registry — discovery of every concrete educator.
+# --------------------------------------------------------------------------
+
+
+class EducatorRegistry:
+    """Holds every concrete educator. `get(name)` and `all()` are the API."""
+
+    def __init__(self, educators: dict[str, Educator]) -> None:
+        self._educators = dict(educators)
+
+    def register(self, educator: Educator) -> None:
+        self._educators[educator.name] = educator
+
+    def get(self, name: str) -> Educator | None:
+        return self._educators.get(name)
+
+    def all(self) -> list[Educator]:
+        return list(self._educators.values())
+
+    def names(self) -> list[str]:
+        return sorted(self._educators.keys())
+
+    @classmethod
+    def default(cls) -> "EducatorRegistry":
+        """The 8-educator default registry — imports the concrete classes."""
+        # local imports avoid a base ↔ concrete-modules import cycle
+        from omega_engine.educators.artifact import ArtifactEducator
+        from omega_engine.educators.automation import AutomationEducator
+        from omega_engine.educators.claudecode import ClaudecodeEducator
+        from omega_engine.educators.connection import ConnectionEducator
+        from omega_engine.educators.coworker import CoworkerEducator
+        from omega_engine.educators.loop import LoopEducator
+        from omega_engine.educators.prompt import PromptEducator
+        from omega_engine.educators.skill import SkillEducator
+
+        return cls({
+            e.name: e for e in (
+                PromptEducator(),
+                ArtifactEducator(),
+                SkillEducator(),
+                CoworkerEducator(),
+                ConnectionEducator(),
+                AutomationEducator(),
+                ClaudecodeEducator(),
+                LoopEducator(),
+            )
+        })
+
+
+# --------------------------------------------------------------------------
+# Staging — proposals go to staging, NEVER to the SSOT.
+# --------------------------------------------------------------------------
+
+
+@dataclass
+class StagingRecord:
+    """The on-disk handle for a proposal in staging."""
+
+    proposal_path: Path     # the .json metadata
+    artifact_path: Path     # the actual generated content
+    target_path: str        # POSIX path inside the SSOT it would promote to
+
+
+class StagingPipeline:
+    """Writes proposals to ``Agentik_Extra/staging/promotion/``.
+
+    An educator never writes to the SSOT directly. Promotion from staging into
+    the SSOT is a separate step gated by the audit arsenal + (optionally) a
+    human approval. The pipeline guarantees:
+
+      - artifacts land under one directory keyed by educator + id
+      - the original target_path is preserved as metadata
+      - the staging area is reversible (delete = no trace)
+    """
+
+    def __init__(self, staging_root: Path | str) -> None:
+        self._root = Path(staging_root)
+        self._root.mkdir(parents=True, exist_ok=True)
+
+    @property
+    def root(self) -> Path:
+        return self._root
+
+    def stage(self, proposal: EducatorProposal) -> StagingRecord:
+        """Write the proposal to staging. Returns the on-disk record.
+
+        The promotion gate (separate) reads the staging record, runs the audit
+        arsenal on the artifact, and either copies the artifact to its
+        ``target_path`` inside the SSOT or rejects it with logged findings.
+        """
+        bucket = self._root / proposal.educator
+        bucket.mkdir(parents=True, exist_ok=True)
+        # extension from the target path so e.g. .yaml stays .yaml in staging
+        suffix = Path(proposal.artifact.target_path).suffix or ".txt"
+        artifact_path = bucket / f"{proposal.artifact.id}{suffix}"
+        proposal_path = bucket / f"{proposal.artifact.id}.json"
+        artifact_path.write_text(proposal.artifact.content)
+        proposal_path.write_text(json.dumps(proposal.to_dict(), indent=2))
+        return StagingRecord(
+            proposal_path=proposal_path,
+            artifact_path=artifact_path,
+            target_path=proposal.artifact.target_path,
+        )
+
+    def list(self) -> list[Path]:
+        """All staged proposal metadata files (one per pending change)."""
+        return sorted(self._root.glob("*/*.json"))
+
+    def clear(self, educator: str | None = None) -> int:
+        """Delete every staged file (or every file for one educator). Returns count."""
+        target = self._root / educator if educator else self._root
+        if not target.exists():
+            return 0
+        removed = 0
+        for path in target.rglob("*"):
+            if path.is_file():
+                path.unlink()
+                removed += 1
+        return removed

package/omega/Agentik_Engine/omega_engine/educators/claudecode.py

@@ -0,0 +1,71 @@
+"""`claudecode-educator` — tracks Claude Code changelog patterns + updates SSOT.
+
+The signature: Claude Code (the platform) keeps shipping new primitives —
+``/goal``, native compaction, agent tools, prompt caching. Each time, the SSOT
++ the claude-code adapter must catch up. This educator reads recent-change
+notes and proposes the adapter/SSOT updates that absorb the new primitive.
+
+Target SSOT path: ``Agentik_AI/adapters/claude-code/notes.md`` (the canonical
+log of what we know + what we still owe).
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from omega_engine.educators.base import EducatorProposal, run_education
+from omega_engine.provider import AgentProvider
+
+_INSTRUCTIONS = """\
+Produce ONE proposal for an update to the claude-code adapter notes. The
+proposal MUST identify exactly ONE Claude Code change and how OmegaOS absorbs
+it. The artifact MUST contain these sections, in order:
+
+  1. The change — name the new primitive (e.g. "native /goal auto-loop"),
+     when it shipped, and link the changelog entry. ONE line each.
+  2. The implication for OmegaOS — what does this primitive replace, augment,
+     or invalidate in our orchestration? Specifically:
+       - which SSOT rule(s) change
+       - which adapter(s) change
+       - which skill(s) become redundant or need to chain into the new primitive
+  3. The proposed adapter change — code-level diff intent (file + region +
+     change in one paragraph each). Do NOT write the code, write the contract.
+  4. The proposed SSOT change — list every file under Agentik_SSOT/ that the
+     promotion gate will edit + the one-line summary of each edit.
+  5. The migration plan — three numbered steps for: pilot, generalise,
+     deprecate-old-path. Each step has a verify command.
+  6. Risk — one paragraph: what could go wrong, how we detect it.
+
+The proposal MUST NOT:
+  - claim certainty about a primitive without citing the changelog.
+  - propose a change without naming the rollback path.
+  - bundle multiple primitives — one change per proposal.
+
+Format the artifact as Markdown.
+"""
+
+
+class ClaudecodeEducator:
+    """Watches the Claude Code changelog + proposes adapter/SSOT updates."""
+
+    name = "claudecode"
+    domain = "claude-code-adapter"
+
+    def generate(
+        self,
+        intent: str,
+        context: dict[str, Any],
+        provider: AgentProvider,
+    ) -> EducatorProposal:
+        change_id = str(context.get("change_id", "latest"))
+        target_path = "Agentik_AI/adapters/claude-code/notes.md"
+        return run_education(
+            educator_name=self.name,
+            domain=self.domain,
+            intent=intent,
+            target_kind="adapter-update",
+            target_path=target_path,
+            domain_instructions=_INSTRUCTIONS,
+            context={**context, "change_id": change_id},
+            provider=provider,
+            artifact_id=f"cc-{change_id}",
+        )

package/omega/Agentik_Engine/omega_engine/educators/connection.py

@@ -0,0 +1,75 @@
+"""`connection-educator` — generates MCP / API connector configs.
+
+The signature: a connector config is the canonical declaration of an external
+capability — an MCP server, an API client, a provider endpoint. The SSOT holds
+the truth; each provider adapter projects it into its own format.
+
+Target SSOT path: ``Agentik_SSOT/mcp/configs/<id>.yaml``.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from omega_engine.educators.base import EducatorProposal, run_education
+from omega_engine.provider import AgentProvider
+
+_INSTRUCTIONS = """\
+Produce ONE connector config in YAML. The config MUST contain these fields,
+in this order, with no extras (the schema is strict — adapters fail closed):
+
+  id: <stable identifier, lowercase, kebab-case>
+  kind: mcp | api | provider
+  description: <one line>
+  transport:
+    type: stdio | http | sse
+    command: <executable, only when transport=stdio>
+    url: <endpoint, only when transport in (http, sse)>
+  auth:
+    type: none | env | header | oauth
+    env_var: <NAME, only when type=env>
+    header_name: <Name, only when type=header>
+  capabilities:
+    - <verb-noun phrase describing one tool the connector exposes>
+  permissions:
+    read: [ <glob | "*"> ]
+    write: [ <glob | "*"> ]
+  rate_limit:
+    rps: <int, default 10>
+    burst: <int, default 20>
+  health_check:
+    command: <shell, returns 0 when healthy>
+
+The config MUST NOT:
+  - embed secrets — only env_var names. Secrets live in Agentik_Extra/etc/secrets/.
+  - leave `permissions` open ("*" is allowed but must be a conscious choice).
+  - declare a transport without the matching field (stdio without command, etc.).
+
+Format the artifact as valid YAML — no comments, no trailing whitespace.
+"""
+
+
+class ConnectionEducator:
+    """Generates MCP / API connector configs for the SSOT."""
+
+    name = "connection"
+    domain = "connectors"
+
+    def generate(
+        self,
+        intent: str,
+        context: dict[str, Any],
+        provider: AgentProvider,
+    ) -> EducatorProposal:
+        connector_id = str(context.get("connector_id", "new-connector"))
+        target_path = f"Agentik_SSOT/mcp/configs/{connector_id}.yaml"
+        return run_education(
+            educator_name=self.name,
+            domain=self.domain,
+            intent=intent,
+            target_kind="connector",
+            target_path=target_path,
+            domain_instructions=_INSTRUCTIONS,
+            context={**context, "connector_id": connector_id},
+            provider=provider,
+            artifact_id=connector_id,
+        )

package/omega/Agentik_Engine/omega_engine/educators/coworker.py

@@ -0,0 +1,68 @@
+"""`coworker-educator` — generates worker/agent role definitions.
+
+The signature: a role definition is what the engine uses to instantiate a
+worker — its mandate, its tool set, its boundaries, the audits its work is
+gated by. Roles are what makes the orchestration graph readable: "send this to
+a `react-specialist`" only works if `react-specialist` is a defined SSOT role.
+
+Target SSOT path: ``Agentik_SSOT/agents/<role>.md``.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from omega_engine.educators.base import EducatorProposal, run_education
+from omega_engine.provider import AgentProvider
+
+_INSTRUCTIONS = """\
+Produce ONE worker/agent role definition. The role MUST declare, in order:
+
+  1. Role name + one-line mandate ("A <role> does X to deliver Y.").
+  2. Scope — what kinds of tasks this role accepts AND a hard list of what it
+     refuses (with a one-line reason for each refusal).
+  3. Tools — the exact engine tools / MCP servers / skills this role uses
+     (file edits, browser, build, deploy). One tool per line, with the
+     condition under which it is invoked.
+  4. Files it may touch — glob patterns. Roles enforce file ownership; the
+     engine rejects writes outside this set.
+  5. Audits gating its output — list the audit IDs (codeaudit, secaudit, ...)
+     that run on its work. Minimum score per audit.
+  6. Done criteria — the measurable condition the role uses to claim done.
+     MUST be a runnable command or a precise structural check, never a feeling.
+  7. Escalation — when the role gives up (budget exceeded, repeated failure)
+     and to whom it escalates.
+
+The role MUST NOT:
+  - overlap silently with another role — state the boundary if it is close.
+  - leave the tool list open-ended ("any tool needed" is a refusal-worthy bug).
+  - use vague mandates like "help with X".
+
+Format the artifact as Markdown.
+"""
+
+
+class CoworkerEducator:
+    """Generates worker/agent role definitions for the SSOT roster."""
+
+    name = "coworker"
+    domain = "agent-roles"
+
+    def generate(
+        self,
+        intent: str,
+        context: dict[str, Any],
+        provider: AgentProvider,
+    ) -> EducatorProposal:
+        role = str(context.get("role_name", "worker"))
+        target_path = f"Agentik_SSOT/agents/{role}.md"
+        return run_education(
+            educator_name=self.name,
+            domain=self.domain,
+            intent=intent,
+            target_kind="agent",
+            target_path=target_path,
+            domain_instructions=_INSTRUCTIONS,
+            context={**context, "role_name": role},
+            provider=provider,
+            artifact_id=role,
+        )

package/omega/Agentik_Engine/omega_engine/educators/loop.py

@@ -0,0 +1,82 @@
+"""`loop-educator` — defines and tunes the goal-loop / verification patterns.
+
+The signature: a loop spec tells the executor HOW MANY iterations a given task
+type gets, WHICH audits run between iterations, and the EXIT condition. It is
+how the engine decides "keep going" vs "this is hopeless, abort". Tuning the
+loop is the most direct lever on cost and quality.
+
+Target SSOT path: ``Agentik_SSOT/loops/<name>.yaml`` (or a patch to
+``Agentik_SSOT/audits/<auditid>.yaml`` when the change is to an audit's
+threshold/weight).
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from omega_engine.educators.base import EducatorProposal, run_education
+from omega_engine.provider import AgentProvider
+
+_INSTRUCTIONS = """\
+Produce ONE loop spec in YAML. The spec MUST contain these fields:
+
+  id: <stable identifier, lowercase, kebab-case>
+  applies_to:
+    task_kinds: [ executor | verifier | dispatcher | "*" ]
+    intent_match: <regex against the mission intent | "*">
+  iteration:
+    max: <int>                         # hard cap, never exceeded
+    soft_target: <int>                 # where we expect convergence
+    cost_cap_usd: <number | null>
+  exit_condition:
+    type: score | command | both
+    score:
+      audit: <audit id from the Quality Arsenal>
+      threshold: <int 0-100>
+    command:
+      cmd: <shell, exit 0 = converged>
+      timeout_sec: <int>
+  step:                                # what runs each iteration
+    audits: [ <audit id>, ... ]
+    fix_action: dispatch | direct_edit | skip
+  on_no_progress:                      # detect plateaus
+    same_findings_iterations: <int>    # if this many in a row repeat -> abort
+    action: abort | switch_strategy
+  observability:
+    log_each_iteration: true | false
+    emit: [ loop.iteration, loop.converged, loop.aborted ]
+
+The loop MUST NOT:
+  - set `max` higher than 12 unless `cost_cap_usd` is set (runaway prevention).
+  - declare exit_condition.type=score without a valid audit id.
+  - allow `same_findings_iterations` >= max (that defeats plateau detection).
+  - skip `on_no_progress` — every loop must know when to give up.
+
+Format the artifact as valid YAML — strict.
+"""
+
+
+class LoopEducator:
+    """Defines and tunes goal-loop / verification patterns for the executor."""
+
+    name = "loop"
+    domain = "loops"
+
+    def generate(
+        self,
+        intent: str,
+        context: dict[str, Any],
+        provider: AgentProvider,
+    ) -> EducatorProposal:
+        loop_id = str(context.get("loop_id", "default-loop"))
+        target_path = f"Agentik_SSOT/loops/{loop_id}.yaml"
+        return run_education(
+            educator_name=self.name,
+            domain=self.domain,
+            intent=intent,
+            target_kind="loop",
+            target_path=target_path,
+            domain_instructions=_INSTRUCTIONS,
+            context={**context, "loop_id": loop_id},
+            provider=provider,
+            artifact_id=loop_id,
+        )

package/omega/Agentik_Engine/omega_engine/educators/prompt.py

@@ -0,0 +1,68 @@
+"""`prompt-educator` — generates the prompts passed between levels.
+
+The signature: produces a prompt template for ONE source → target hand-off
+(AISB → Oracle, Oracle → Manager, Manager → Worker, ...). The template must
+embed the orchestration contract: mission, context, files in scope, done
+criteria, verify command. It is the canonical prompt the engine injects into
+provider calls at that level.
+
+Target SSOT path: ``Agentik_SSOT/prompts/<source>-to-<target>.md``.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from omega_engine.educators.base import EducatorProposal, run_education
+from omega_engine.provider import AgentProvider
+
+_INSTRUCTIONS = """\
+Produce ONE prompt template the engine will inject at the
+<source-role> -> <target-role> hand-off. The template MUST:
+
+  1. State the role of the target agent in ONE sentence ("You are <target>.").
+  2. Include the mission summary (one paragraph, no padding).
+  3. Embed the orchestration contract — these MUST appear, exactly:
+       - Mission / Purpose / Context (project, stack, dev URL)
+       - Files in Scope (ownership boundaries)
+       - Done Criteria (a measurable condition, e.g. "exit 0", "0 console errors")
+       - Verify Command (the exact command the target runs before reporting done)
+  4. State the legal stop signal (e.g. ".done.json with status=done_clean").
+  5. End with the response format the engine will parse.
+
+Anti-patterns the artifact MUST NOT contain:
+  - "should", "could", "maybe", "TBD"
+  - vague verbs ("handle", "ensure" without a verb saying HOW)
+  - escape hatches that let the target pause and ask the user
+    (we are autonomous — Third Law)
+
+Format the artifact as Markdown with placeholders in ALL_CAPS_SNAKE_CASE
+(MISSION_SUMMARY, PROJECT_DIR, FILES_IN_SCOPE, etc.) so the engine can fill them.
+"""
+
+
+class PromptEducator:
+    """Generates inter-level prompts for the orchestration graph."""
+
+    name = "prompt"
+    domain = "orchestration-prompts"
+
+    def generate(
+        self,
+        intent: str,
+        context: dict[str, Any],
+        provider: AgentProvider,
+    ) -> EducatorProposal:
+        source = str(context.get("source", "oracle"))
+        target = str(context.get("target", "worker"))
+        target_path = f"Agentik_SSOT/prompts/{source}-to-{target}.md"
+        return run_education(
+            educator_name=self.name,
+            domain=self.domain,
+            intent=intent,
+            target_kind="prompt",
+            target_path=target_path,
+            domain_instructions=_INSTRUCTIONS,
+            context={**context, "source": source, "target": target},
+            provider=provider,
+            artifact_id=f"{source}-to-{target}",
+        )