geny-executor 2.1.3__tar.gz → 2.2.0__tar.gz

{geny_executor-2.1.3 → geny_executor-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geny-executor
-Version: 2.1.3
+Version: 2.2.0
 Summary: Harness-engineered agent pipeline library with 21-stage dual-abstraction architecture, built on the Anthropic API
 Project-URL: Homepage, https://github.com/CocoRoF/geny-executor
 Project-URL: Repository, https://github.com/CocoRoF/geny-executor
@@ -36,6 +36,7 @@ Requires-Dist: psycopg[binary]>=3.1
 Requires-Dist: pydantic>=2.0
 Requires-Dist: pyyaml>=6.0
 Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
 Requires-Dist: pytest-cov>=5.0; extra == 'dev'
 Requires-Dist: pytest>=8.0; extra == 'dev'

geny_executor-2.2.0/docs/ci/README.md

@@ -0,0 +1,18 @@
+# Pending CI workflow updates (2.2.0)
+
+`2.2.0-workflow-updates.patch` carries the wave-3 CI changes that could not be
+pushed from the automation environment: the GitHub OAuth token used by the
+release tooling has `repo` scope but not `workflow` scope, and GitHub rejects
+any push that modifies `.github/workflows/*` without it.
+
+Contents of the patch:
+- `ci.yml`: ruff now genuinely lints `tests/` (the old config silently
+  force-excluded it), a mypy job over `core` + `llm_client`, and an
+  events-docs `--check` step (`scripts/gen_event_docs.py`).
+- `publish.yml`: a release gate asserting the pyproject version has a
+  matching `## [<version>]` CHANGELOG header before publishing.
+
+Apply from a checkout with workflow-scoped credentials:
+
+    git apply docs/ci/2.2.0-workflow-updates.patch
+    git add .github && git commit -m "ci: apply 2.2.0 workflow updates"

{geny_executor-2.1.3 → geny_executor-2.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "geny-executor"
-version = "2.1.3"
+version = "2.2.0"
 description = "Harness-engineered agent pipeline library with 21-stage dual-abstraction architecture, built on the Anthropic API"
 readme = "README.md"
 license = "MIT"
@@ -79,6 +79,7 @@ dev = [
     "pytest-asyncio>=0.24",
     "pytest-cov>=5.0",
     "ruff>=0.4.0",
+    "mypy>=1.10",
 ]
 
 [project.urls]
@@ -120,5 +121,44 @@ markers = [
 [tool.ruff]
 target-version = "py311"
 line-length = 100
-extend-exclude = ["tests"]
+# tests/ is deliberately NOT excluded — CI runs `ruff check src/ tests/`
+# and the config must not silently veto half of that command line.
+# (Pre-2.2.0 `extend-exclude = ["tests"]` + `force-exclude = true` made
+# the tests/ half of the CI invocation a no-op — audit 2026-06-09 §3.7.)
 force-exclude = true
+
+[tool.ruff.format]
+# Formatter-only carve-out: tests/ predates formatter enforcement and a
+# blanket reformat would churn ~130 files. *Lint* rules apply to tests/
+# (see above); format normalization of tests/ is tracked separately.
+exclude = ["tests/**"]
+
+# ── mypy — typed-surface beachhead ─────────────────────────────────
+# The package ships `py.typed` but had no type-checking CI (audit
+# 2026-06-09 §3.7). Start permissive and on a beachhead: CI runs mypy
+# over core/ and llm_client/ only (the surfaces hosts import against).
+# Tighten incrementally — flip `check_untyped_defs`, then widen the
+# package list — rather than gating the world at once.
+[tool.mypy]
+python_version = "3.11"
+ignore_missing_imports = true
+check_untyped_defs = false
+# Annotation-bearing defs only; untyped bodies are skipped for now.
+follow_imports = "silent"
+no_error_summary = false
+
+# Modules with known non-trivial findings (dynamic attributes, conditional
+# function variants, config-object reuse). Each needs a real refactor, not
+# an annotation — parked here so the beachhead gate stays green while the
+# fixes land one module at a time. Findings on file (2026-06-10):
+#   core.pipeline         — Stage has no `_context` attr (set dynamically)
+#   core.mutation         — conditional `wrapper` variants differ in arity;
+#                           `cfg` rebound across ModelConfig/PipelineConfig
+#   core.manifest_factory — Optional flows into dict(...) for chain_order
+[[tool.mypy.overrides]]
+module = [
+    "geny_executor.core.pipeline",
+    "geny_executor.core.mutation",
+    "geny_executor.core.manifest_factory",
+]
+ignore_errors = true

{geny_executor-2.1.3 → geny_executor-2.2.0}/src/geny_executor/__init__.py

@@ -17,7 +17,7 @@ Usage:
 """
 
 from geny_executor.core.pipeline import Pipeline
-from geny_executor.core.config import PipelineConfig, ModelConfig
+from geny_executor.core.config import PipelineConfig, ModelConfig, ModelOverrides
 from geny_executor.core.state import PipelineState, TokenUsage, CacheMetrics
 from geny_executor.core.result import PipelineResult
 from geny_executor.core.stage import Stage, Strategy, StageDescription, StrategyInfo
@@ -59,9 +59,12 @@ from geny_executor.core.environment import (
     EnvironmentSanitizer,
     EnvironmentSummary,
     HostSelections,
+    ManifestIssue,
     StageManifestEntry,
     ToolsSnapshot,
+    validate_manifest,
 )
+from geny_executor.core.manifest_factory import build_manifest, known_manifest_presets
 from geny_executor.core.artifact import (
     ArtifactInfo,
     create_stage,
@@ -78,7 +81,13 @@ from geny_executor.core.introspection import (
     introspect_all,
     introspect_stage,
 )
-from geny_executor.events import EventBus, PipelineEvent
+from geny_executor.events import (
+    EVENT_CATALOG_VERSION,
+    EventBus,
+    EventTypes,
+    PipelineEvent,
+    known_event_types,
+)
 from geny_executor.llm_client import (
     APIRequest,
     APIResponse,
@@ -93,10 +102,21 @@ from geny_executor.llm_client import (
 from geny_executor.memory import (
     GenyPresets,
     MemoryAwareRetriever,
+    MemoryProviderFactory,
     ProviderDrivenStrategy,
 )
+from geny_executor.memory.factory import provider_from_manifest_memory
+from geny_executor.stages.s12_agent.subagent_type import (
+    ManifestSubagentPipelineFactory,
+    SubAgentBuildContext,
+    SubagentTypeDescriptor,
+    SubagentTypeOrchestrator,
+    SubagentTypeRegistry,
+    compile_subagent_descriptors,
+    resolve_subagent_provider,
+)
 
-__version__ = "2.1.3"
+__version__ = "2.2.0"
 
 __all__ = [
     # Core
@@ -105,6 +125,7 @@ __all__ = [
     "PipelineState",
     "PipelineResult",
     "ModelConfig",
+    "ModelOverrides",
     "TokenUsage",
     "CacheMetrics",
     # Abstractions
@@ -127,8 +148,12 @@ __all__ = [
     "EnvironmentSanitizer",
     "EnvironmentSummary",
     "HostSelections",
+    "ManifestIssue",
     "StageManifestEntry",
     "ToolsSnapshot",
+    "validate_manifest",
+    "build_manifest",
+    "known_manifest_presets",
     "DiffEntry",
     "EnvironmentDiff",
     # Artifact system
@@ -146,8 +171,11 @@ __all__ = [
     "introspect_all",
     "introspect_stage",
     # Events
+    "EVENT_CATALOG_VERSION",
     "EventBus",
+    "EventTypes",
     "PipelineEvent",
+    "known_event_types",
     # LLM clients (unified)
     "APIRequest",
     "APIResponse",
@@ -182,6 +210,16 @@ __all__ = [
     "MutationResult",
     # Memory plumbing (provider-driven)
     "MemoryAwareRetriever",
+    "MemoryProviderFactory",
     "ProviderDrivenStrategy",
     "GenyPresets",
+    "provider_from_manifest_memory",
+    # Sub-agent types (manifest-expressible since 2.2.0 Wave 3)
+    "ManifestSubagentPipelineFactory",
+    "SubAgentBuildContext",
+    "SubagentTypeDescriptor",
+    "SubagentTypeOrchestrator",
+    "SubagentTypeRegistry",
+    "compile_subagent_descriptors",
+    "resolve_subagent_provider",
 ]

{geny_executor-2.1.3 → geny_executor-2.2.0}/src/geny_executor/core/config.py

@@ -80,6 +80,77 @@ class ModelConfig:
         return cls(**kwargs)
 
 
+@dataclass(frozen=True)
+class ModelOverrides:
+    """One-run model overrides for ``Pipeline.run`` / ``run_stream``.
+
+    Why (2.2.0, audit 2026-06-09 §3.1): there was no sanctioned way to
+    say "this run only, use opus / a bigger budget". GAPT compensated
+    by mutating ``pipeline._config.model.*`` directly with a hand-built
+    baseline/revert dance — a private-attribute hack that leaked
+    overrides into later runs whenever the revert path was skipped.
+    This dataclass is the public funnel for that need.
+
+    Semantics:
+      - Every field is ``Optional``; only non-``None`` fields are
+        applied. They are written onto the :class:`PipelineState`
+        AFTER ``PipelineConfig.apply_to_state`` at run start, so they
+        win over manifest/config values **for that run only**.
+      - Lifetime is exactly one run: the next run's
+        ``apply_to_state`` stomps the state fields back to config
+        values (that stomp is the documented semantic, not an
+        accident). No revert bookkeeping is needed.
+      - Each applied field emits a ``config.override_applied`` event
+        (``{"field", "value", "source": "per_run"}``) into the run's
+        event stream so hosts can render *why* this run used a
+        different model (audit §3.1's "config.resolved" reporting,
+        scoped to the override layer).
+
+    Frozen: an overrides object is a value, not a channel — build a
+    new one per run rather than mutating a shared instance.
+
+    This is the HIGHEST-precedence configuration channel (per-run
+    overrides > mutator/refresh > attach_runtime > manifest >
+    defaults); see docs/architecture.md#configuration-precedence.
+    """
+
+    model: Optional[str] = None
+    max_tokens: Optional[int] = None
+    temperature: Optional[float] = None
+    top_p: Optional[float] = None
+    thinking_enabled: Optional[bool] = None
+    thinking_budget_tokens: Optional[int] = None
+
+    def non_none_fields(self) -> Dict[str, Any]:
+        """Return ``{field: value}`` for every field that is set.
+
+        Field names intentionally match the :class:`PipelineState`
+        attribute names 1:1 so application is a plain ``setattr`` walk
+        — adding a field here requires only the dataclass line plus
+        the matching state attribute.
+        """
+        out: Dict[str, Any] = {}
+        for key in (
+            "model",
+            "max_tokens",
+            "temperature",
+            "top_p",
+            "thinking_enabled",
+            "thinking_budget_tokens",
+        ):
+            value = getattr(self, key)
+            if value is not None:
+                out[key] = value
+        return out
+
+    def apply_to_state(self, state: "PipelineState") -> Dict[str, Any]:
+        """Write the non-``None`` fields onto *state*; return what was applied."""
+        applied = self.non_none_fields()
+        for key, value in applied.items():
+            setattr(state, key, value)
+        return applied
+
+
 @dataclass
 class PipelineConfig:
     """Top-level pipeline configuration."""

{geny_executor-2.1.3 → geny_executor-2.2.0}/src/geny_executor/core/diff.py

@@ -6,6 +6,32 @@ from dataclasses import dataclass, field
 from typing import Any, ClassVar, Dict, List, Optional, Set
 
 
+def _order_keyed(items: List[Any]) -> Optional[Dict[int, Dict[str, Any]]]:
+    """Return ``order → entry`` when *items* is an order-keyed entity list.
+
+    A list qualifies when it is non-empty, every element is a dict
+    carrying an int-able ``order`` key, and the orders are unique.
+    Stage manifest entries are the canonical case; the shape test is
+    structural so any future order-keyed list (and hosts' own payloads)
+    benefits without a schema registry.
+
+    Returns ``None`` when the list does not qualify — callers fall back
+    to the positional strategies.
+    """
+    if not items or not all(isinstance(x, dict) and "order" in x for x in items):
+        return None
+    keyed: Dict[int, Dict[str, Any]] = {}
+    for entry in items:
+        try:
+            order = int(entry["order"])
+        except (TypeError, ValueError):
+            return None
+        if order in keyed:
+            return None  # duplicate orders — positional fallback is honest
+        keyed[order] = entry
+    return keyed
+
+
 @dataclass
 class DiffEntry:
     """A single difference between two environment configs."""
@@ -115,8 +141,36 @@ class EnvironmentDiff:
                 entries.extend(sub.entries)
             elif isinstance(a[key], list) and isinstance(b[key], list):
                 if a[key] != b[key]:
-                    # For lists, compare element-by-element if same length and dicts
-                    if (
+                    # Order-keyed entity lists (stage manifest entries)
+                    # diff per-order rather than positionally. Before
+                    # 2.2.0 (audit §3.1), two stage lists of unequal
+                    # length collapsed into ONE opaque "changed" blob —
+                    # a 16-stage stored manifest diffed against the
+                    # 21-stage canonical layout reported nothing usable.
+                    # Keying by ``order`` makes added / removed /
+                    # changed stages individually addressable
+                    # (``stages[order=N].…`` paths), and stays correct
+                    # when one side reordered its array.
+                    a_keyed = _order_keyed(a[key])
+                    b_keyed = _order_keyed(b[key])
+                    if a_keyed is not None and b_keyed is not None:
+                        for order in sorted(set(a_keyed) | set(b_keyed)):
+                            entry_path = f"{path}[order={order}]"
+                            if order not in a_keyed:
+                                entries.append(
+                                    DiffEntry(entry_path, "added", new_value=b_keyed[order])
+                                )
+                            elif order not in b_keyed:
+                                entries.append(
+                                    DiffEntry(entry_path, "removed", old_value=a_keyed[order])
+                                )
+                            else:
+                                sub = cls.compute(
+                                    a_keyed[order], b_keyed[order], entry_path, ignore_keys
+                                )
+                                entries.extend(sub.entries)
+                    # Positional fallback: same length + all dicts.
+                    elif (
                         len(a[key]) == len(b[key])
                         and all(isinstance(x, dict) for x in a[key])
                         and all(isinstance(x, dict) for x in b[key])