krons 0.2.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

krons/work/__init__.py

@@ -32,7 +32,6 @@ Two complementary patterns at different abstraction levels:
             return await self.llm.chat(**kwargs)
 
 Core concepts:
-- Phrase: Typed operation signature (inputs -> outputs)
 - Form: Data binding + scheduling (stateful artifact)
 - Report: Multi-step workflow declaration (stateful artifact)
 - Worker: Execution capability (stateless station)
@@ -53,11 +52,6 @@ _LAZY_IMPORTS: dict[str, tuple[str, str]] = {
     "ParsedAssignment": ("krons.work.form", "ParsedAssignment"),
     "parse_assignment": ("krons.work.form", "parse_assignment"),
     "parse_full_assignment": ("krons.work.form", "parse_full_assignment"),
-    # phrase
-    "CrudOperation": ("krons.work.phrase", "CrudOperation"),
-    "CrudPattern": ("krons.work.phrase", "CrudPattern"),
-    "Phrase": ("krons.work.phrase", "Phrase"),
-    "phrase": ("krons.work.phrase", "phrase"),
     # report
     "Report": ("krons.work.report", "Report"),
     # worker
@@ -102,16 +96,12 @@ if TYPE_CHECKING:
         parse_assignment,
         parse_full_assignment,
     )
-    from krons.work.phrase import CrudOperation, CrudPattern, Phrase, phrase
     from krons.work.report import Report
     from krons.work.worker import WorkConfig, Worker, WorkLink, work, worklink
 
 __all__ = (
-    "CrudOperation",
-    "CrudPattern",
     "Form",
     "ParsedAssignment",
-    "Phrase",
     "Report",
     "WorkConfig",
     "WorkLink",
@@ -120,7 +110,6 @@ __all__ = (
     "WorkerTask",
     "parse_assignment",
     "parse_full_assignment",
-    "phrase",
     "work",
     "worklink",
 )

krons/work/form.py

@@ -6,23 +6,19 @@
 A Form represents an instantiated work unit with:
 - Data binding (input values)
 - Execution state tracking (filled, workable)
-- Optional Phrase reference for typed I/O
 
-Forms are the stateful layer between Phrase (definition) and Operation (execution).
+Forms are the stateful scheduling layer for Operations.
 """
 
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any
+from typing import Any
 
 from pydantic import Field
 
 from krons.core import Element
 
-if TYPE_CHECKING:
-    from .phrase import Phrase
-
 __all__ = ("Form", "ParsedAssignment", "parse_assignment", "parse_full_assignment")
 
 
@@ -123,9 +119,7 @@ def parse_full_assignment(assignment: str) -> ParsedAssignment:
 class Form(Element):
     """Data binding container for work units.
 
-    A Form binds input data and tracks execution state. It can be created:
-    1. From a Phrase (typed I/O)
-    2. From an assignment string (dynamic fields)
+    A Form binds input data and tracks execution state.
 
     Assignment DSL supports full format:
         "branch: inputs -> outputs | resource"
@@ -144,7 +138,6 @@ class Form(Element):
         available_data: Current data values
         output: Execution result
         filled: Whether form has been executed
-        phrase: Optional Phrase reference for typed execution
     """
 
     assignment: str = Field(
@@ -165,9 +158,6 @@ class Form(Element):
     output: Any = Field(default=None)
     filled: bool = Field(default=False)
 
-    # Optional phrase reference (set via from_phrase())
-    _phrase: "Phrase | None" = None
-
     def model_post_init(self, _: Any) -> None:
         """Parse assignment to derive fields if not already set."""
         if self.assignment and not self.input_fields and not self.output_fields:
@@ -179,35 +169,6 @@ class Form(Element):
             if parsed.resource and self.resource is None:
                 self.resource = parsed.resource
 
-    @classmethod
-    def from_phrase(
-        cls,
-        phrase: "Phrase",
-        **initial_data: Any,
-    ) -> "Form":
-        """Create Form from a Phrase with optional initial data.
-
-        Args:
-            phrase: Phrase defining typed I/O
-            **initial_data: Initial input values
-
-        Returns:
-            Form bound to the phrase
-        """
-        form = cls(
-            assignment=f"{', '.join(phrase.inputs)} -> {', '.join(phrase.outputs)}",
-            input_fields=list(phrase.inputs),
-            output_fields=list(phrase.outputs),
-            available_data=dict(initial_data),
-        )
-        form._phrase = phrase
-        return form
-
-    @property
-    def phrase(self) -> "Phrase | None":
-        """Get bound phrase if any."""
-        return self._phrase
-
     def is_workable(self) -> bool:
         """Check if form is ready for execution.
 
@@ -274,32 +235,8 @@ class Form(Element):
                 result[field] = self.available_data[field]
         return result
 
-    async def execute(self, ctx: Any = None) -> Any:
-        """Execute the form if it has a bound phrase.
-
-        Args:
-            ctx: Execution context
-
-        Returns:
-            Execution result
-
-        Raises:
-            RuntimeError: If no phrase bound or form not workable
-        """
-        if self._phrase is None:
-            raise RuntimeError("Form has no bound phrase - cannot execute")
-
-        if not self.is_workable():
-            missing = [f for f in self.input_fields if f not in self.available_data]
-            raise RuntimeError(f"Form not workable - missing inputs: {missing}")
-
-        result = await self._phrase(self.get_inputs(), ctx)
-        self.set_output(result)
-        return result
-
     def __repr__(self) -> str:
         status = (
             "filled" if self.filled else ("ready" if self.is_workable() else "pending")
         )
-        phrase_info = f", phrase={self._phrase.name}" if self._phrase else ""
-        return f"Form('{self.assignment}', {status}{phrase_info})"
+        return f"Form('{self.assignment}', {status})"

{krons-0.2.0.dist-info → krons-0.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: krons
-Version: 0.2.0
+Version: 0.2.1
 Summary: Spec-based composable framework for building type-safe systems
 Project-URL: Homepage, https://github.com/khive-ai/krons
 Project-URL: Repository, https://github.com/khive-ai/krons

{krons-0.2.0.dist-info → krons-0.2.1.dist-info}/RECORD

@@ -123,13 +123,10 @@ krons/utils/sql/__init__.py,sha256=yNjm9Dr-ZjrZSD3Lext7fPR80qX5svGT2PnXqlb5qXs,2
 krons/utils/sql/_sql_validation.py,sha256=smxNU3HjPhQuRK5ehG9Fl4DeljKK9tqUQIvRUopgvc8,4229
 krons/utils/validators/__init__.py,sha256=qmCYoL6fQL1O6-GcfcUARii_fjXYNed6rKZWOp3skj8,87
 krons/utils/validators/_validate_image_url.py,sha256=WAffNY3WpPFe_lqFLHumJS0_hm92NwIOmDOK1GR61ew,1858
-krons/work/__init__.py,sha256=L7PoU-Y_RFQCiw8HqC7KSp4KkgyardWbB5mmnNu0cjs,3967
+krons/work/__init__.py,sha256=8C3ypK0FInl6YSos-F_MkuDhu_Vb_uN8HEegFq8pvwc,3541
 krons/work/engine.py,sha256=ZHZzzRqedpLEkcX5eQ6zZQMXYfgmLMRN2JOwkLajND4,10924
-krons/work/form.py,sha256=wxfjwCe8JglpeoRcflWquMSSldCCU4kOL26Q_r47GGE,9268
-krons/work/phrase.py,sha256=7PYPcprA_p7_eZx32EzHd6d7Nc2zLjiIyYTJmqwRUNo,18949
-krons/work/policy.py,sha256=3fp8L0R2lxJ6w5YkgWF_0B1gkXyPx1nCjSwu0_3mmcY,2146
+krons/work/form.py,sha256=QwXYclRR-MxneNLF0CKbMvk_K-piZBmMXyCd_Y3XOeE,7264
 krons/work/report.py,sha256=wxjMGnUc8b2Jn26l0t0k0cWetZFDyvyqBz0ldae4BD0,9027
-krons/work/service.py,sha256=yayqnZHb14rhJoXfj_70Xh0WqdAkgwtTvw7OLzBlCY8,12103
 krons/work/worker.py,sha256=hK7t5ztG_5wKPScwjtsctP4-ob6bHw9WKRJTw_gw_Fc,8494
 krons/work/operations/__init__.py,sha256=vU-jy0Xy25W4vj98wV3sk3c8x6hKc5sf4nW3U_FQGdY,999
 krons/work/operations/builder.py,sha256=_OGvooSl8s3Pmx8En15SX4XxQ12wF2ZszwVb5Hqzdpc,7779
@@ -148,7 +145,7 @@ krons/work/rules/common/mapping.py,sha256=Loq54MNEtwpnHN0aypTjFOqwoOKLEysddHh-JE
 krons/work/rules/common/model.py,sha256=xmM6coEThf_fgIiqJiyDgvdfib_FpVeY6LgWPVcWSwU,3026
 krons/work/rules/common/number.py,sha256=cCukgMSpQu5RdYK5rXAUyop9qXgDRfLCioMvE8kIzHg,3162
 krons/work/rules/common/string.py,sha256=zHp_OLh0FL4PvmSlyDTEzb2I97-DBSEyI2zcMo10voA,5090
-krons-0.2.0.dist-info/METADATA,sha256=BibIkvS6d8-3CoLW3Toj0hCpeQiWdv9PgGmk17CUx3g,2527
-krons-0.2.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-krons-0.2.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-krons-0.2.0.dist-info/RECORD,,
+krons-0.2.1.dist-info/METADATA,sha256=O9pmDvpEfTq1HydsJRGUwTA6IPn_veB57Em2udfOO9g,2527
+krons-0.2.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+krons-0.2.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+krons-0.2.1.dist-info/RECORD,,

krons/work/phrase.py

@@ -1,522 +0,0 @@
-"""Phrase - typed operation template with auto-generated Options/Result types.
-
-A Phrase wraps an async handler with:
-- Typed inputs (auto-generates FrozenOptions dataclass)
-- Typed outputs (auto-generates FrozenResult dataclass)
-- Validation via Operable
-
-Usage with decorator (custom handler):
-    from krons.core.specs import Operable, phrase
-
-    consent_operable = Operable([
-        Spec("subject_id", UUID),
-        Spec("scope", str),
-        Spec("has_consent", bool),
-        Spec("token_id", UUID | None),
-    ])
-
-    @phrase(consent_operable, inputs={"subject_id", "scope"}, outputs={"has_consent", "token_id"})
-    async def verify_consent(options, ctx):
-        # options is VerifyConsentOptions (frozen dataclass)
-        # return dict with output fields
-        return {"has_consent": True, "token_id": some_id}
-
-    # Call it
-    result = await verify_consent({"subject_id": id, "scope": "background"}, ctx)
-
-Usage with CrudPattern (declarative):
-    from krons.core.specs import Operable, phrase, CrudPattern
-
-    def check_has_consent(row):
-        return {"has_consent": row["status"] in {"active"} if row else False}
-
-    verify_consent = phrase(
-        consent_operable,
-        inputs={"subject_id", "scope"},
-        outputs={"has_consent", "token_id"},
-        crud=CrudPattern(
-            table="consent_tokens",
-            operation="read",
-            lookup={"subject_id", "scope"},
-        ),
-        result_parser=check_has_consent,
-        name="verify_consent",
-    )
-"""
-
-from collections.abc import Awaitable, Callable, Mapping
-from dataclasses import dataclass
-from enum import Enum
-from types import MappingProxyType
-from typing import TYPE_CHECKING, Any
-
-from krons.core.specs.operable import Operable
-from krons.core.types import Unset, is_unset
-from krons.utils.sql import validate_identifier
-
-if TYPE_CHECKING:
-    from krons.work.operations.node import Operation
-
-__all__ = ("CrudPattern", "CrudOperation", "Phrase", "phrase")
-
-
-class CrudOperation(str, Enum):
-    """CRUD operation types for declarative phrases."""
-
-    READ = "read"
-    INSERT = "insert"
-    UPDATE = "update"
-    SOFT_DELETE = "soft_delete"
-
-
-_EMPTY_MAP: MappingProxyType = MappingProxyType({})
-
-
-@dataclass(frozen=True, slots=True)
-class CrudPattern:
-    """Declarative CRUD pattern for auto-generating phrase handlers.
-
-    Attributes:
-        table: Validated database table name (alphanumeric + underscores).
-        operation: CRUD operation type (read, insert, update, soft_delete).
-        lookup: Fields from options used in WHERE clause (for read/update/delete).
-        filters: Static key-value pairs added to WHERE clause. Use for
-            hardcoded filters like {"status": "active"}.
-        set_fields: Explicit field mappings for update. Values can be:
-            - Field name (str): copy from options
-            - "ctx.{attr}": read from context (e.g., "ctx.now", "ctx.user_id")
-            - Literal value: use directly
-        defaults: Static default values for insert.
-
-    The auto-handler resolves output fields in order:
-        1. ctx metadata attribute (e.g., tenant_id — only if explicitly set)
-        2. options pass-through (if field in inputs)
-        3. row column (direct from query result)
-        4. result_parser (for computed fields)
-    """
-
-    table: str
-    operation: CrudOperation | str = CrudOperation.READ
-    lookup: frozenset[str] = frozenset()
-    filters: Mapping[str, Any] = None  # type: ignore[assignment]
-    set_fields: Mapping[str, Any] = None  # type: ignore[assignment]
-    defaults: Mapping[str, Any] = None  # type: ignore[assignment]
-
-    def __post_init__(self):
-        # Validate table name against SQL injection
-        validate_identifier(self.table, "table")
-        # Normalize operation to enum
-        if isinstance(self.operation, str):
-            object.__setattr__(self, "operation", CrudOperation(self.operation))
-        # Normalize lookup to frozenset
-        if not isinstance(self.lookup, frozenset):
-            object.__setattr__(self, "lookup", frozenset(self.lookup))
-        # Normalize None mappings to immutable empty maps; freeze mutable dicts
-        object.__setattr__(
-            self,
-            "filters",
-            (
-                _EMPTY_MAP
-                if self.filters is None
-                else MappingProxyType(dict(self.filters))
-            ),
-        )
-        object.__setattr__(
-            self,
-            "set_fields",
-            (
-                _EMPTY_MAP
-                if self.set_fields is None
-                else MappingProxyType(dict(self.set_fields))
-            ),
-        )
-        object.__setattr__(
-            self,
-            "defaults",
-            (
-                _EMPTY_MAP
-                if self.defaults is None
-                else MappingProxyType(dict(self.defaults))
-            ),
-        )
-
-
-class Phrase:
-    """A typed operation template with auto-generated Options/Result types.
-
-    Phrases can be created two ways:
-    1. With a custom handler (decorator pattern)
-    2. With a CrudPattern (declarative pattern, auto-generates handler)
-    """
-
-    def __init__(
-        self,
-        name: str,
-        operable: Operable,
-        inputs: set[str],
-        outputs: set[str],
-        handler: Callable[..., Awaitable] | None = None,
-        crud: CrudPattern | None = None,
-        result_parser: Callable[[dict | None], dict] | None = None,
-    ):
-        """
-        Args:
-            name: Snake_case phrase name.
-            operable: Operable defining field specs for inputs/outputs.
-            inputs: Set of field names that form the options type.
-            outputs: Set of field names that form the result type.
-            handler: Async function (options, ctx) -> result dict. Required if no crud.
-            crud: CrudPattern for declarative CRUD operations. If provided, handler
-                is auto-generated.
-            result_parser: Function (row) -> dict for computed output fields.
-                Only used with crud pattern. Row may be None if not found.
-        """
-        if handler is None and crud is None:
-            raise ValueError("Either handler or crud must be provided")
-
-        self.name = name
-        self.operable = Operable(operable.get_specs(), adapter="dataclass")
-        self.inputs = tuple(inputs)
-        self.outputs = tuple(outputs)
-        self.crud = crud
-        self.result_parser = result_parser
-        self._options_type: Any = Unset
-        self._result_type: Any = Unset
-
-        # Use provided handler or generate from crud
-        if handler is not None:
-            self.handler = handler
-        else:
-            self.handler = self._make_crud_handler()
-
-    def _make_crud_handler(self) -> Callable[..., Awaitable]:
-        """Generate handler from CrudPattern."""
-        crud = self.crud
-        inputs = set(self.inputs)
-        outputs = set(self.outputs)
-        result_parser = self.result_parser
-
-        async def _crud_handler(options: Any, ctx: Any) -> dict:
-            # Get the query backend from context
-            query_fn = getattr(ctx, "query_fn", None)
-            if query_fn is None:
-                raise RuntimeError(
-                    "Context must provide query_fn for crud patterns. "
-                    "Ensure ctx.query_fn is set."
-                )
-
-            # Helper: check ctx metadata for a key
-            _meta = getattr(ctx, "metadata", {})
-
-            row = None
-
-            if crud.operation == CrudOperation.READ:
-                # Build WHERE from lookup fields + filters + tenant_id
-                where = {field: getattr(options, field) for field in crud.lookup}
-                where.update(crud.filters)
-                if "tenant_id" in _meta:
-                    where["tenant_id"] = _meta["tenant_id"]
-                row = await query_fn(crud.table, "select_one", where, None, ctx)
-
-            elif crud.operation == CrudOperation.INSERT:
-                # Build data from input fields + defaults
-                data = {}
-                for field in inputs:
-                    if hasattr(options, field):
-                        data[field] = getattr(options, field)
-                # Add defaults
-                for key, value in crud.defaults.items():
-                    if key not in data:
-                        data[key] = value
-                # Add tenant_id
-                if "tenant_id" in _meta:
-                    data["tenant_id"] = _meta["tenant_id"]
-                row = await query_fn(crud.table, "insert", None, data, ctx)
-
-            elif crud.operation == CrudOperation.UPDATE:
-                # Build WHERE from lookup fields
-                where = {field: getattr(options, field) for field in crud.lookup}
-                if "tenant_id" in _meta:
-                    where["tenant_id"] = _meta["tenant_id"]
-                # Build SET data
-                data = {}
-                for key, value in crud.set_fields.items():
-                    if isinstance(value, str) and value.startswith("ctx."):
-                        attr_name = value[4:]
-                        if attr_name in _meta:
-                            data[key] = _meta[attr_name]
-                        else:
-                            data[key] = getattr(ctx, attr_name)
-                    elif isinstance(value, str) and hasattr(options, value):
-                        data[key] = getattr(options, value)
-                    else:
-                        data[key] = value
-                row = await query_fn(crud.table, "update", where, data, ctx)
-
-            elif crud.operation == CrudOperation.SOFT_DELETE:
-                # Build WHERE from lookup fields
-                where = {field: getattr(options, field) for field in crud.lookup}
-                if "tenant_id" in _meta:
-                    where["tenant_id"] = _meta["tenant_id"]
-                # Soft delete sets is_deleted=True, deleted_at=now
-                data = {"is_deleted": True}
-                if ctx.now is not None:
-                    data["deleted_at"] = ctx.now
-                row = await query_fn(crud.table, "update", where, data, ctx)
-
-            # Build result from auto-mapping + result_parser
-            result = {}
-
-            for field in outputs:
-                # Priority 1: ctx metadata attribute (only if explicitly set)
-                if field in _meta:
-                    result[field] = _meta[field]
-                # Priority 2: pass-through from options
-                elif field in inputs and hasattr(options, field):
-                    result[field] = getattr(options, field)
-                # Priority 3: direct from row
-                elif row and field in row:
-                    result[field] = row[field]
-
-            # Priority 4: computed fields from result_parser
-            if result_parser is not None:
-                computed = result_parser(row)
-                if computed:
-                    result.update(computed)
-
-            return result
-
-        return _crud_handler
-
-    async def __call__(self, options: Any, ctx: Any) -> Any:
-        # If options is already the correct type, use it directly
-        # Otherwise validate/construct from dict
-        if not isinstance(options, self.options_type):
-            options = self.operable.validate_instance(self.options_type, options)
-        result = await self.handler(options, ctx)
-        return self.operable.validate_instance(self.result_type, result)
-
-    @property
-    def options_type(self) -> Any:
-        if not is_unset(self._options_type):
-            return self._options_type
-
-        _opt_type_name = _to_pascal(self.name) + "Options"
-        self._options_type = self.operable.compose_structure(
-            _opt_type_name,
-            include=set(self.inputs),
-            frozen=True,
-        )
-        return self._options_type
-
-    @property
-    def result_type(self) -> Any:
-        if not is_unset(self._result_type):
-            return self._result_type
-
-        _res_type_name = _to_pascal(self.name) + "Result"
-        self._result_type = self.operable.compose_structure(
-            _res_type_name,
-            include=set(self.outputs),
-            frozen=True,
-        )
-        return self._result_type
-
-    # --- Form-like interface ---
-
-    @property
-    def input_fields(self) -> list[str]:
-        """Input field names (Form-compatible interface)."""
-        return list(self.inputs)
-
-    @property
-    def output_fields(self) -> list[str]:
-        """Output field names (Form-compatible interface)."""
-        return list(self.outputs)
-
-    def is_workable(self, available_data: dict[str, Any]) -> bool:
-        """Check if all inputs are available in data dict.
-
-        Enables Form/Report-style scheduling based on data availability.
-        """
-        return all(field in available_data for field in self.inputs)
-
-    def extract_inputs(self, available_data: dict[str, Any]) -> dict[str, Any]:
-        """Extract input values from available data.
-
-        Returns:
-            Dict with only the fields declared as inputs.
-
-        Raises:
-            KeyError: If any required input is missing.
-        """
-        return {field: available_data[field] for field in self.inputs}
-
-    # --- Operation bridge ---
-
-    def as_operation(
-        self,
-        options: dict[str, Any] | None = None,
-        *,
-        available_data: dict[str, Any] | None = None,
-        ctx: Any = None,
-        **metadata,
-    ) -> "Operation":
-        """Create an Operation that invokes this phrase.
-
-        The Operation can participate in DAG flow while preserving
-        the phrase's typed I/O semantics.
-
-        Args:
-            options: Direct input values (takes precedence)
-            available_data: Data dict to extract inputs from (if options not given)
-            ctx: Execution context passed to phrase handler
-            **metadata: Additional metadata for Operation
-
-        Returns:
-            PhraseOperation instance ready for DAG execution.
-
-        Example:
-            # Direct options
-            op = phrase.as_operation({"subject_id": id, "scope": "read"})
-
-            # From available data (Form/Report pattern)
-            op = phrase.as_operation(available_data=report.available_data)
-
-            # Build DAG
-            graph = Graph()
-            graph.add_node(phrase1.as_operation({"input": "x"}))
-            await flow(session, graph)
-        """
-        from krons.work.operations.node import Operation
-
-        # Resolve options
-        if options is not None:
-            resolved_options = dict(options)
-        elif available_data is not None:
-            if not self.is_workable(available_data):
-                missing = [f for f in self.inputs if f not in available_data]
-                raise ValueError(f"Missing required inputs: {missing}")
-            resolved_options = self.extract_inputs(available_data)
-        else:
-            raise ValueError("Either options or available_data must be provided")
-
-        # Create closure-based operation that bypasses registry
-        phrase = self
-        bound_ctx = ctx
-
-        class PhraseOperation(Operation):
-            """Operation wrapping a Phrase for direct invocation."""
-
-            async def _invoke(self) -> Any:
-                # Direct phrase invocation - no registry lookup
-                return await phrase(self.parameters, bound_ctx)
-
-        return PhraseOperation(
-            operation_type=self.name,
-            parameters=resolved_options,
-            metadata={
-                "name": self.name,
-                "phrase": True,
-                "input_fields": self.input_fields,
-                "output_fields": self.output_fields,
-                **metadata,
-            },
-        )
-
-
-def _to_pascal(snake_name: str) -> str:
-    """Convert snake_case name to PascalCase.
-
-    Examples:
-        require_monitoring_active -> RequireMonitoringActive
-        verify_consent_token -> VerifyConsentToken
-    """
-    return "".join(word.capitalize() for word in snake_name.split("_"))
-
-
-def phrase(
-    operable: Operable,
-    *,
-    inputs: set[str],
-    outputs: set[str],
-    name: str | None = None,
-    crud: CrudPattern | None = None,
-    result_parser: Callable[[dict | None], dict] | None = None,
-) -> Phrase | Callable[[Callable[..., Awaitable]], Phrase]:
-    """Create a Phrase, either as decorator or directly with CrudPattern.
-
-    Two usage modes:
-
-    1. Decorator mode (custom handler):
-        @phrase(operable, inputs={...}, outputs={...})
-        async def my_phrase(options, ctx):
-            return {...}
-
-    2. Direct mode (declarative crud):
-        my_phrase = phrase(
-            operable,
-            inputs={...},
-            outputs={...},
-            crud=CrudPattern(table="...", operation="read", lookup={...}),
-            result_parser=lambda row: {...},
-            name="my_phrase",
-        )
-
-    Args:
-        operable: Operable defining the field specs for inputs/outputs.
-        inputs: Set of field names that form the options type.
-        outputs: Set of field names that form the result type.
-        name: Phrase name. Required for direct mode, optional for decorator mode.
-        crud: CrudPattern for declarative CRUD. If provided, returns Phrase directly.
-        result_parser: Function (row) -> dict for computed fields. Only with crud.
-
-    Returns:
-        - If crud provided: Phrase instance directly
-        - If no crud: Decorator that wraps async function into Phrase
-
-    Examples:
-        # Decorator mode
-        @phrase(my_operable, inputs={"subject_id", "scope"}, outputs={"valid", "reason"})
-        async def verify_consent(options, ctx):
-            return {"valid": True, "reason": None}
-
-        # Direct mode with CrudPattern
-        verify_consent = phrase(
-            my_operable,
-            inputs={"subject_id", "scope"},
-            outputs={"has_consent", "token_id"},
-            crud=CrudPattern(
-                table="consent_tokens",
-                operation="read",
-                lookup={"subject_id", "scope"},
-            ),
-            result_parser=lambda row: {"has_consent": row["status"] == "active" if row else False},
-            name="verify_consent",
-        )
-    """
-    # Direct mode: crud provided, return Phrase immediately
-    if crud is not None:
-        if name is None:
-            raise ValueError("name is required when using crud pattern")
-        return Phrase(
-            name=name,
-            operable=operable,
-            inputs=inputs,
-            outputs=outputs,
-            crud=crud,
-            result_parser=result_parser,
-        )
-
-    # Decorator mode: return decorator function
-    def decorator(func: Callable[..., Awaitable]) -> Phrase:
-        phrase_name = name or func.__name__
-        return Phrase(
-            name=phrase_name,
-            operable=operable,
-            inputs=inputs,
-            outputs=outputs,
-            handler=func,
-        )
-
-    return decorator

krons/work/policy.py

@@ -1,80 +0,0 @@
-# Copyright (c) 2025 - 2026, HaiyangLi <quantocean.li at gmail dot com>
-# SPDX-License-Identifier: Apache-2.0
-
-"""Policy protocols and types.
-
-Defines contracts for policy resolution and evaluation.
-Implementations provided by domain libs (e.g., canon-core).
-"""
-
-from __future__ import annotations
-
-from collections.abc import Sequence
-from dataclasses import dataclass, field
-from typing import Any, Protocol, runtime_checkable
-
-from krons.core.specs.catalog._enforcement import EnforcementLevel
-from krons.core.types.base import DataClass
-from krons.work.operations.context import RequestContext
-
-__all__ = (
-    "EnforcementLevel",
-    "PolicyEngine",
-    "PolicyResolver",
-    "ResolvedPolicy",
-)
-
-
-@dataclass(slots=True)
-class ResolvedPolicy(DataClass):
-    """A policy resolved for evaluation.
-
-    Returned by PolicyResolver.resolve(). Contains policy ID and
-    any resolution metadata needed by the engine.
-    """
-
-    policy_id: str
-    enforcement: str = EnforcementLevel.HARD_MANDATORY.value
-    metadata: dict[str, Any] = field(default_factory=dict)
-
-
-@runtime_checkable
-class PolicyEngine(Protocol):
-    """Abstract policy evaluation engine.
-
-    kron defines the contract. Implementations:
-    - canon-core: OPAEngine (Rego/Regorus evaluation)
-    - Testing: MockPolicyEngine
-    """
-
-    async def evaluate(
-        self,
-        policy_id: str,
-        input_data: dict[str, Any],
-        **options: Any,
-    ) -> Any:
-        """Evaluate a single policy against input."""
-        ...
-
-    async def evaluate_batch(
-        self,
-        policy_ids: Sequence[str],
-        input_data: dict[str, Any],
-        **options: Any,
-    ) -> list[Any]:
-        """Evaluate multiple policies."""
-        ...
-
-
-@runtime_checkable
-class PolicyResolver(Protocol):
-    """Resolves which policies apply to a given context.
-
-    kron defines the contract. Implementations:
-    - canon-core: CharteredResolver (charter-based resolution)
-    - Testing: MockPolicyResolver, StaticPolicyResolver
-    """
-
-    def resolve(self, ctx: RequestContext) -> Sequence[ResolvedPolicy]:
-        """Determine applicable policies for context."""
-        ...

krons/work/service.py

@@ -1,379 +0,0 @@
-# Copyright (c) 2025 - 2026, HaiyangLi <quantocean.li at gmail dot com>
-# SPDX-License-Identifier: Apache-2.0
-
-"""KronService - typed action handlers with policy evaluation."""
-
-from __future__ import annotations
-
-import logging
-from collections.abc import Awaitable, Callable
-from dataclasses import dataclass
-from typing import Any
-
-from pydantic import Field, PrivateAttr
-
-from krons.resource import ResourceBackend, ResourceConfig
-from krons.work.operations.context import RequestContext
-
-from .policy import EnforcementLevel, PolicyEngine, PolicyResolver
-
-logger = logging.getLogger(__name__)
-
-__all__ = (
-    "ActionMeta",
-    "KronConfig",
-    "KronService",
-    "action",
-    "get_action_meta",
-)
-
-
-class KronConfig(ResourceConfig):
-    """Configuration for KronService.
-
-    Attributes:
-        operable: Canonical Operable containing all field specs for this service.
-        action_timeout: Timeout for action execution (None = no timeout).
-        use_policies: Enable policy evaluation.
-        policy_timeout: Timeout for policy evaluation.
-        fail_open_on_engine_error: Allow action if engine fails (DANGEROUS).
-        hooks: Available hooks {name: callable}.
-    """
-
-    operable: Any = None
-    """Canonical Operable for the service's field namespace."""
-
-    action_timeout: float | None = None
-    """Timeout for action execution in seconds. None means no timeout."""
-
-    use_policies: bool = True
-    """Enable policy evaluation."""
-
-    policy_timeout: float = 10.0
-    """Timeout for policy evaluation in seconds."""
-
-    fail_open_on_engine_error: bool = False
-    """If True, allow action when engine fails. DANGEROUS for production."""
-
-    hooks: dict[str, Callable[..., Awaitable[Any]]] = Field(default_factory=dict)
-    """Available hooks {name: hook_function}."""
-
-
-_ACTION_ATTR = "_kron_action"
-
-
-@dataclass(frozen=True, slots=True)
-class ActionMeta:
-    """Metadata for an action handler.
-
-    Attributes:
-        name: Action identifier (e.g., "consent.grant").
-        inputs: Field names from service operable used as inputs.
-        outputs: Field names from service operable used as outputs.
-        pre_hooks: Hook names to run before action.
-        post_hooks: Hook names to run after action.
-    """
-
-    name: str
-    inputs: frozenset[str] = frozenset()
-    outputs: frozenset[str] = frozenset()
-    pre_hooks: tuple[str, ...] = ()
-    post_hooks: tuple[str, ...] = ()
-
-    # Lazily computed types (set by service at registration)
-    _options_type: Any = None
-    _result_type: Any = None
-
-
-def action(
-    name: str,
-    inputs: set[str] | None = None,
-    outputs: set[str] | None = None,
-    pre_hooks: list[str] | None = None,
-    post_hooks: list[str] | None = None,
-) -> Callable[[Callable], Callable]:
-    """Decorator to declare action handler metadata.
-
-    Args:
-        name: Action identifier (e.g., "consent.grant").
-        inputs: Field names from service operable used as inputs.
-        outputs: Field names from service operable used as outputs.
-        pre_hooks: Hook names to run before action.
-        post_hooks: Hook names to run after action.
-
-    Usage:
-        @action(
-            name="consent.grant",
-            inputs={"permissions", "subject_id"},
-            outputs={"consent_id", "granted_at"},
-        )
-        async def _handle_grant(self, options, ctx):
-            ...
-    """
-
-    def decorator(func: Callable) -> Callable:
-        meta = ActionMeta(
-            name=name,
-            inputs=frozenset(inputs or set()),
-            outputs=frozenset(outputs or set()),
-            pre_hooks=tuple(pre_hooks or []),
-            post_hooks=tuple(post_hooks or []),
-        )
-        setattr(func, _ACTION_ATTR, meta)
-        return func
-
-    return decorator
-
-
-def get_action_meta(handler: Callable) -> ActionMeta | None:
-    """Get action metadata from a handler method."""
-    return getattr(handler, _ACTION_ATTR, None)
-
-
-# =============================================================================
-# KronService
-# =============================================================================
-
-
-class KronService(ResourceBackend):
-    """Service backend with typed actions.
-
-    Subclasses implement action handlers with @action decorator.
-    Actions derive typed I/O from service's canonical operable.
-
-    Example:
-        class ConsentService(KronService):
-            config = KronConfig(
-                name="consent",
-                operable=Operable([
-                    Spec("permissions", list[str]),
-                    Spec("consent_id", UUID),
-                    Spec("granted_at", datetime),
-                    Spec("subject_id", FK[Subject]),
-                ]),
-            )
-
-            @action(
-                name="consent.grant",
-                inputs={"permissions", "subject_id"},
-                outputs={"consent_id", "granted_at"},
-            )
-            async def _handle_grant(self, options, ctx):
-                ...
-
-        service = ConsentService()
-        result = await service.call("consent.grant", options, ctx)
-    """
-
-    config: KronConfig = Field(default_factory=KronConfig)
-    _policy_engine: PolicyEngine | None = PrivateAttr(default=None)
-    _policy_resolver: PolicyResolver | None = PrivateAttr(default=None)
-    _action_registry: dict[str, tuple[Callable, ActionMeta]] = PrivateAttr(
-        default_factory=dict
-    )
-
-    def __init__(
-        self,
-        config: KronConfig | None = None,
-        policy_engine: PolicyEngine | None = None,
-        policy_resolver: PolicyResolver | None = None,
-        **kwargs: Any,
-    ) -> None:
-        """Initialize service with optional policy engine and resolver.
-
-        Args:
-            config: Service configuration.
-            policy_engine: PolicyEngine for policy evaluation.
-            policy_resolver: PolicyResolver for determining applicable policies.
-        """
-        super().__init__(config=config, **kwargs)
-        self._policy_engine = policy_engine
-        self._policy_resolver = policy_resolver
-        self._action_registry = {}
-        self._register_actions()
-
-    def _register_actions(self) -> None:
-        """Scan for @action decorated methods and register them."""
-        for name in dir(self):
-            # Skip dunder attributes to avoid Pydantic deprecation warnings
-            if name.startswith("__"):
-                continue
-            if name.startswith("_"):
-                method = getattr(self, name, None)
-                if method and callable(method):
-                    meta = get_action_meta(method)
-                    if meta:
-                        self._action_registry[meta.name] = (method, meta)
-                        self._build_action_types(meta)
-
-    def _build_action_types(self, meta: ActionMeta) -> None:
-        """Build options_type and result_type for an action from service operable."""
-        if not self.config.operable:
-            return
-
-        operable = self.config.operable
-
-        # Validate inputs/outputs exist in operable
-        allowed = operable.allowed()
-        invalid_inputs = meta.inputs - allowed
-        invalid_outputs = meta.outputs - allowed
-
-        if invalid_inputs:
-            logger.warning(
-                "Action '%s' has inputs not in operable: %s",
-                meta.name,
-                invalid_inputs,
-            )
-        if invalid_outputs:
-            logger.warning(
-                "Action '%s' has outputs not in operable: %s",
-                meta.name,
-                invalid_outputs,
-            )
-
-        # Build typed structures (frozen dataclasses)
-        if meta.inputs:
-            options_type = operable.compose_structure(
-                _to_pascal(meta.name) + "Options",
-                include=set(meta.inputs),
-                frozen=True,
-            )
-            object.__setattr__(meta, "_options_type", options_type)
-
-        if meta.outputs:
-            result_type = operable.compose_structure(
-                _to_pascal(meta.name) + "Result",
-                include=set(meta.outputs),
-                frozen=True,
-            )
-            object.__setattr__(meta, "_result_type", result_type)
-
-    @property
-    def has_engine(self) -> bool:
-        """True if policy engine is configured."""
-        return self._policy_engine is not None
-
-    @property
-    def has_resolver(self) -> bool:
-        """True if policy resolver is configured."""
-        return self._policy_resolver is not None
-
-    async def call(
-        self,
-        name: str,
-        options: Any,
-        ctx: RequestContext,
-    ) -> Any:
-        """Call an action by name.
-
-        Args:
-            name: Action name (e.g., "consent.grant").
-            options: Input data (dict or typed dataclass).
-            ctx: Request context.
-
-        Returns:
-            Action result.
-
-        Raises:
-            ValueError: If action not found.
-            PermissionError: If policy blocks action.
-        """
-        handler, meta = self._fetch_handler(name)
-
-        # Update context
-        ctx.name = name
-
-        # Run pre-hooks
-        await self._run_hooks(meta.pre_hooks, options, ctx)
-
-        # Evaluate policies
-        if self.config.use_policies and self._policy_engine:
-            await self._evaluate_policies(ctx)
-
-        # Validate options if we have typed options_type
-        if meta._options_type and self.config.operable:
-            options = self.config.operable.validate_instance(
-                meta._options_type, options
-            )
-
-        # Execute handler
-        result = await handler(options, ctx)
-
-        # Run post-hooks
-        await self._run_hooks(meta.post_hooks, options, ctx, result=result)
-
-        return result
-
-    def _fetch_handler(self, name: str) -> tuple[Callable, ActionMeta]:
-        """Fetch handler and metadata by action name.
-
-        Args:
-            name: Action name.
-
-        Returns:
-            Tuple of (handler, ActionMeta).
-
-        Raises:
-            ValueError: If action not found.
-        """
-        if name not in self._action_registry:
-            raise ValueError(f"Unknown action: {name}")
-        return self._action_registry[name]
-
-    async def _run_hooks(
-        self,
-        hook_names: tuple[str, ...],
-        options: Any,
-        ctx: RequestContext,
-        result: Any = None,
-    ) -> None:
-        """Run named hooks from config.hooks."""
-        for hook_name in hook_names:
-            hook_fn = self.config.hooks.get(hook_name)
-            if hook_fn:
-                try:
-                    await hook_fn(self, options, ctx, result)
-                except Exception as e:
-                    logger.error("Hook '%s' failed: %s", hook_name, e)
-            else:
-                logger.warning("Hook '%s' not found in config.hooks", hook_name)
-
-    async def _evaluate_policies(self, ctx: RequestContext) -> None:
-        """Evaluate policies via engine."""
-        if not self._policy_engine or not self._policy_resolver:
-            return
-
-        try:
-            resolved = self._policy_resolver.resolve(ctx)
-
-            if not resolved:
-                return
-
-            policy_ids = [p.policy_id for p in resolved]
-            input_data = ctx.to_dict()
-
-            results = await self._policy_engine.evaluate_batch(policy_ids, input_data)
-
-            for result in results:
-                if EnforcementLevel.is_blocking(result):
-                    raise PermissionError(
-                        f"Policy {result.policy_id} blocked: {result.message}"
-                    )
-
-        except PermissionError:
-            raise
-        except Exception as e:
-            logger.error("Policy evaluation failed: %s", e)
-            if not self.config.fail_open_on_engine_error:
-                raise PermissionError(f"Policy engine error: {e}")
-
-
-def _to_pascal(name: str) -> str:
-    """Convert action name to PascalCase.
-
-    consent.grant -> ConsentGrant
-    consent_grant -> ConsentGrant
-    """
-    # Replace dots and underscores, capitalize each part
-    parts = name.replace(".", "_").split("_")
-    return "".join(part.capitalize() for part in parts)