rpcs1 0.1.0__tar.gz

rpcs1-0.1.0/.gitignore

@@ -0,0 +1,16 @@
+node_modules/
+.venv/
+dist/
+.next/
+.turbo/
+*.tsbuildinfo
+.env
+.env.local
+dev-server*.log
+__pycache__/
+*.py[cod]
+*.egg-info/
+.pytest_cache/
+.ruff_cache/
+dist/
+build/

rpcs1-0.1.0/PKG-INFO

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: rpcs1
+Version: 0.1.0
+Summary: RPCS-1 Agent Tuner — configuration framework for AI agents grounded in receiver dynamics
+Project-URL: Homepage, https://rpcs1.dev
+Project-URL: Documentation, https://rpcs1.dev/docs
+Project-URL: Repository, https://github.com/travisbergen2/rpcs1-sdk
+Project-URL: Issues, https://github.com/travisbergen2/rpcs1-sdk/issues
+Author-email: Travis Bergen <travisbergen2@gmail.com>
+License: MIT
+Keywords: agents,ai,configuration,llm,rpcs1,tuning
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Requires-Dist: pydantic>=2.0
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.25; extra == 'anthropic'
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pydantic>=2.0; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Provides-Extra: openai
+Requires-Dist: openai>=1.0; extra == 'openai'
+Description-Content-Type: text/markdown
+
+# rpcs1 — AI Agent Parameter Tuner
+
+**Configure AI agents that don't oscillate, overload, or freeze.**
+
+Stop debugging agent failures case-by-case. The RPCS-1 SDK translates your agent's task and environment into specific platform parameters — grounded in receiver dynamics from cognitive systems research.
+
+Built on the matching principle: agents in fast-changing environments need short attention windows; agents in stable environments benefit from longer integration.
+
+## Installation
+
+```bash
+pip install rpcs1
+# With Anthropic integration:
+pip install rpcs1[anthropic]
+# With OpenAI integration:
+pip install rpcs1[openai]
+```
+
+## Quick Start
+
+```python
+from rpcs1 import recommend_params
+
+config = recommend_params(
+    task_description="Customer support agent handling refund requests",
+    environment_entropy="dynamic",           # stable | moderate | dynamic | chaotic
+    environment_predictability="somewhat_predictable",
+    stakes="high",                           # low | medium | high | catastrophic
+    context_relevance="medium",              # short | medium | long
+    commitment_style="cautious",             # decisive | balanced | cautious
+    target_platform="anthropic",             # anthropic | openai | open_source | generic
+    domain="customer_support",              # optional
+)
+
+print(config.platform_parameters.temperature)        # e.g. 0.52
+print(config.platform_parameters.model_recommendation)  # e.g. 'claude-sonnet-4-6'
+print(config.predicted_regime)                       # 'stable'
+print(config.reasoning)                              # cites Matching Principle (Pred-09-5)
+```
+
+## The Five Receiver Primitives
+
+Every recommendation is driven by five receiver primitives from RPCS-1:
+
+| Primitive | Name | What it controls |
+|---|---|---|
+| **TI** | Temporal Integration | How much history to integrate (context window strategy) |
+| **SG** | Signal Gain | How strongly to amplify signals (temperature) |
+| **FT** | Filtering Threshold | How conservatively to gate action (tool use strategy) |
+| **UE** | Update Elasticity | How readily to revise the model (retry strategy) |
+| **AR** | Ambiguity Resolution | How aggressively to resolve uncertainty |
+
+## Stability Regimes
+
+The SDK predicts and warns about four stability regimes:
+
+- **stable** — balanced operation, well-matched to environment
+- **near_oscillation** — high TI + high SG → agent revisits decisions, won't commit
+- **near_overload** — low TI + high SG → agent acts on insufficient information
+- **near_freeze** — low UE + high FT → agent hedges endlessly, won't act
+
+## Anthropic Integration
+
+```python
+from rpcs1 import recommend_params
+from rpcs1.integrations.anthropic import to_anthropic_params
+import anthropic
+
+rec = recommend_params(
+    task_description="Medical triage assistant",
+    environment_entropy="moderate",
+    environment_predictability="somewhat_predictable",
+    stakes="catastrophic",
+    commitment_style="cautious",
+    target_platform="anthropic",
+)
+
+params = to_anthropic_params(
+    rec,
+    system_prompt="You are a medical intake assistant.",
+    user_message="I've had chest pain for an hour.",
+)
+
+client = anthropic.Anthropic()
+message = client.messages.create(**params)
+```
+
+## Theoretical Foundation
+
+The RPCS-1 SDK implements the matching principle (Pred-09-5) from IMM Paper 9:
+
+> Stable receivers in an environment with entropy H satisfy TI ~ 1/H.
+
+This translates directly: agents in chaotic environments need short attention windows (low TI, frequent grounding); agents in stable environments benefit from long integration (high TI, large context windows).
+
+All parameter recommendations are deterministic, explainable, and traceable to specific IMM principles. No ML models, no black-box recommendations.
+
+## License
+
+MIT — see LICENSE file.
+
+Web app and full documentation: [https://rpcs1.dev](https://rpcs1.dev)

rpcs1-0.1.0/README.md

@@ -0,0 +1,102 @@
+# rpcs1 — AI Agent Parameter Tuner
+
+**Configure AI agents that don't oscillate, overload, or freeze.**
+
+Stop debugging agent failures case-by-case. The RPCS-1 SDK translates your agent's task and environment into specific platform parameters — grounded in receiver dynamics from cognitive systems research.
+
+Built on the matching principle: agents in fast-changing environments need short attention windows; agents in stable environments benefit from longer integration.
+
+## Installation
+
+```bash
+pip install rpcs1
+# With Anthropic integration:
+pip install rpcs1[anthropic]
+# With OpenAI integration:
+pip install rpcs1[openai]
+```
+
+## Quick Start
+
+```python
+from rpcs1 import recommend_params
+
+config = recommend_params(
+    task_description="Customer support agent handling refund requests",
+    environment_entropy="dynamic",           # stable | moderate | dynamic | chaotic
+    environment_predictability="somewhat_predictable",
+    stakes="high",                           # low | medium | high | catastrophic
+    context_relevance="medium",              # short | medium | long
+    commitment_style="cautious",             # decisive | balanced | cautious
+    target_platform="anthropic",             # anthropic | openai | open_source | generic
+    domain="customer_support",              # optional
+)
+
+print(config.platform_parameters.temperature)        # e.g. 0.52
+print(config.platform_parameters.model_recommendation)  # e.g. 'claude-sonnet-4-6'
+print(config.predicted_regime)                       # 'stable'
+print(config.reasoning)                              # cites Matching Principle (Pred-09-5)
+```
+
+## The Five Receiver Primitives
+
+Every recommendation is driven by five receiver primitives from RPCS-1:
+
+| Primitive | Name | What it controls |
+|---|---|---|
+| **TI** | Temporal Integration | How much history to integrate (context window strategy) |
+| **SG** | Signal Gain | How strongly to amplify signals (temperature) |
+| **FT** | Filtering Threshold | How conservatively to gate action (tool use strategy) |
+| **UE** | Update Elasticity | How readily to revise the model (retry strategy) |
+| **AR** | Ambiguity Resolution | How aggressively to resolve uncertainty |
+
+## Stability Regimes
+
+The SDK predicts and warns about four stability regimes:
+
+- **stable** — balanced operation, well-matched to environment
+- **near_oscillation** — high TI + high SG → agent revisits decisions, won't commit
+- **near_overload** — low TI + high SG → agent acts on insufficient information
+- **near_freeze** — low UE + high FT → agent hedges endlessly, won't act
+
+## Anthropic Integration
+
+```python
+from rpcs1 import recommend_params
+from rpcs1.integrations.anthropic import to_anthropic_params
+import anthropic
+
+rec = recommend_params(
+    task_description="Medical triage assistant",
+    environment_entropy="moderate",
+    environment_predictability="somewhat_predictable",
+    stakes="catastrophic",
+    commitment_style="cautious",
+    target_platform="anthropic",
+)
+
+params = to_anthropic_params(
+    rec,
+    system_prompt="You are a medical intake assistant.",
+    user_message="I've had chest pain for an hour.",
+)
+
+client = anthropic.Anthropic()
+message = client.messages.create(**params)
+```
+
+## Theoretical Foundation
+
+The RPCS-1 SDK implements the matching principle (Pred-09-5) from IMM Paper 9:
+
+> Stable receivers in an environment with entropy H satisfy TI ~ 1/H.
+
+This translates directly: agents in chaotic environments need short attention windows (low TI, frequent grounding); agents in stable environments benefit from long integration (high TI, large context windows).
+
+All parameter recommendations are deterministic, explainable, and traceable to specific IMM principles. No ML models, no black-box recommendations.
+
+## License
+
+MIT — see LICENSE file.
+
+Web app and full documentation: [https://rpcs1.dev](https://rpcs1.dev)

rpcs1-0.1.0/examples/anthropic_integration.py

@@ -0,0 +1,44 @@
+"""
+RPCS-1 + Anthropic integration example.
+
+Install: pip install rpcs1[anthropic]
+"""
+from rpcs1 import recommend_params
+from rpcs1.integrations.anthropic import to_anthropic_params
+
+# Get RPCS-1 recommendations for a medical triage agent
+rec = recommend_params(
+    task_description="Medical intake assistant that triages patient symptoms and recommends urgency level",
+    environment_entropy="moderate",
+    environment_predictability="somewhat_predictable",
+    stakes="catastrophic",
+    context_relevance="medium",
+    commitment_style="cautious",
+    target_platform="anthropic",
+    domain="healthcare",
+)
+
+# Convert to Anthropic API parameters
+system_prompt = "You are a medical intake assistant. You help patients describe their symptoms."
+user_message = "I've had a headache and fever for two days."
+
+params = to_anthropic_params(
+    rec,
+    system_prompt=system_prompt,
+    user_message=user_message,
+)
+
+print("=== Anthropic API Parameters from RPCS-1 ===")
+print(f"Model:       {params['model']}")
+print(f"Temperature: {params['temperature']}")
+print(f"Max tokens:  {params['max_tokens']}")
+print(f"\nSystem prompt (first 100 chars):")
+print(f"  {params['system'][:100]}...")
+print(f"\nRegime: {rec.predicted_regime}")
+print(f"Confidence: {rec.confidence}")
+
+# To actually call the API:
+# import anthropic
+# client = anthropic.Anthropic()
+# message = client.messages.create(**params)
+# print(message.content[0].text)

rpcs1-0.1.0/examples/basic_usage.py

@@ -0,0 +1,63 @@
+"""
+RPCS-1 Python SDK — basic usage example.
+
+Install: pip install rpcs1
+"""
+from rpcs1 import recommend_params
+
+# -------------------------------------------------------------------
+# Example 1: Customer support agent (high entropy, high stakes)
+# -------------------------------------------------------------------
+rec = recommend_params(
+    task_description="Customer support agent handling refund requests and billing disputes",
+    environment_entropy="dynamic",
+    environment_predictability="somewhat_predictable",
+    stakes="high",
+    context_relevance="medium",
+    commitment_style="cautious",
+    target_platform="anthropic",
+    domain="customer_support",
+)
+
+print("=== Example 1: Customer Support Agent ===")
+print(f"Predicted regime: {rec.predicted_regime}")
+print(f"\nReceiver profile:")
+print(f"  TI (Temporal Integration): {rec.receiver_profile.TI}")
+print(f"  SG (Signal Gain):          {rec.receiver_profile.SG}")
+print(f"  FT (Filtering Threshold):  {rec.receiver_profile.FT}")
+print(f"  UE (Update Elasticity):    {rec.receiver_profile.UE}")
+print(f"  AR (Ambiguity Resolution): {rec.receiver_profile.AR}")
+print(f"\nPlatform parameters:")
+print(f"  temperature:        {rec.platform_parameters.temperature}")
+print(f"  max_tokens:         {rec.platform_parameters.max_tokens}")
+print(f"  model:              {rec.platform_parameters.model_recommendation}")
+print(f"  tool_use_strategy:  {rec.platform_parameters.tool_use_strategy}")
+print(f"  context_strategy:   {rec.platform_parameters.context_strategy}")
+print(f"\nReasoning:\n  {rec.reasoning}")
+if rec.warnings:
+    print(f"\nWarnings:")
+    for w in rec.warnings:
+        print(f"  ⚠ {w}")
+print(f"\nIMM principles applied:")
+for p in rec.imm_principles_applied:
+    print(f"  • {p}")
+
+# -------------------------------------------------------------------
+# Example 2: CI/CD automation agent (low entropy, low stakes)
+# -------------------------------------------------------------------
+print("\n\n=== Example 2: CI/CD Automation Agent ===")
+rec2 = recommend_params(
+    task_description="Automated CI pipeline agent that runs tests and deploys on green",
+    environment_entropy="stable",
+    environment_predictability="highly_predictable",
+    stakes="low",
+    context_relevance="short",
+    commitment_style="decisive",
+    target_platform="openai",
+    domain="devops",
+)
+print(f"Predicted regime: {rec2.predicted_regime}")
+print(f"temperature:      {rec2.platform_parameters.temperature}")
+print(f"tool strategy:    {rec2.platform_parameters.tool_use_strategy}")
+print(f"TI:               {rec2.receiver_profile.TI}")
+print(f"AR:               {rec2.receiver_profile.AR}")

rpcs1-0.1.0/examples/trading_ea_bridge.py

@@ -0,0 +1,36 @@
+from rpcs1 import recommend_params, to_runtime_config
+
+
+def recommend_for_market(coherence: float, momentum: float) -> dict:
+    entropy = "dynamic"
+    commitment = "cautious"
+
+    if coherence < 0.50:
+        entropy = "chaotic"
+        commitment = "cautious"
+    elif abs(momentum) > 0.01:
+        entropy = "moderate"
+        commitment = "balanced"
+
+    rec = recommend_params(
+        task_description="Adaptive trading expert advisor",
+        environment_entropy=entropy,
+        environment_predictability="somewhat_predictable",
+        stakes="high",
+        context_relevance="short",
+        commitment_style=commitment,
+        target_platform="generic",
+        domain="trading",
+    )
+
+    return to_runtime_config(rec)
+
+
+if __name__ == "__main__":
+    config = recommend_for_market(coherence=0.471, momentum=0.00283)
+    print(
+        "[RPCS-1 SDK] Regime: {regime} | Temp: {temperature:.2f} | "
+        "TI: {TI:.0f} | SG: {SG:.0f} | FT: {FT:.0f} | Confidence: {confidence}".format(
+            **config
+        )
+    )

rpcs1-0.1.0/pyproject.toml

@@ -0,0 +1,56 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "rpcs1"
+version = "0.1.0"
+description = "RPCS-1 Agent Tuner — configuration framework for AI agents grounded in receiver dynamics"
+readme = "README.md"
+license = { text = "MIT" }
+authors = [{ name = "Travis Bergen", email = "travisbergen2@gmail.com" }]
+requires-python = ">=3.10"
+dependencies = [
+    "pydantic>=2.0",
+]
+keywords = ["ai", "agents", "llm", "configuration", "tuning", "rpcs1"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+
+[project.urls]
+Homepage = "https://rpcs1.dev"
+Documentation = "https://rpcs1.dev/docs"
+Repository = "https://github.com/travisbergen2/rpcs1-sdk"
+Issues = "https://github.com/travisbergen2/rpcs1-sdk/issues"
+
+[project.optional-dependencies]
+anthropic = ["anthropic>=0.25"]
+openai    = ["openai>=1.0"]
+dev = [
+    "pytest>=8.0",
+    "pytest-cov>=5.0",
+    "ruff>=0.4",
+    "mypy>=1.10",
+    "pydantic>=2.0",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/rpcs1"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.mypy]
+python_version = "3.10"
+strict = true

rpcs1-0.1.0/src/rpcs1/__init__.py

@@ -0,0 +1,42 @@
+"""
+RPCS-1 Agent Tuner — Python SDK.
+
+Quick start:
+    from rpcs1 import recommend_params
+
+    config = recommend_params(
+        task_description="Customer support agent",
+        environment_entropy="dynamic",
+        environment_predictability="somewhat_predictable",
+        stakes="high",
+        target_platform="anthropic",
+    )
+    print(config.platform_parameters.temperature)
+    print(config.predicted_regime)
+    print(config.reasoning)
+"""
+
+from .recommend import recommend_params, recommend_from_input
+from .adapters import to_runtime_config
+from .types import (
+    AgentEnvironment,
+    TaskDescriptor,
+    RecommendInput,
+    ReceiverProfile,
+    PlatformParameters,
+    Recommendation,
+)
+
+__all__ = [
+    "recommend_params",
+    "recommend_from_input",
+    "to_runtime_config",
+    "AgentEnvironment",
+    "TaskDescriptor",
+    "RecommendInput",
+    "ReceiverProfile",
+    "PlatformParameters",
+    "Recommendation",
+]
+
+__version__ = "0.1.0"

rpcs1-0.1.0/src/rpcs1/adapters.py

@@ -0,0 +1,38 @@
+"""
+Adapters for turning RPCS-1 recommendations into integration-friendly payloads.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from .types import Recommendation
+
+
+def to_runtime_config(recommendation: Recommendation) -> dict[str, Any]:
+    """
+    Flatten a Recommendation into a simple runtime payload.
+
+    This is useful for EA bridges, dashboards, web APIs, and logging code that
+    should not need to know the nested Pydantic model structure.
+    """
+    profile = recommendation.receiver_profile
+    params = recommendation.platform_parameters
+
+    return {
+        "regime": recommendation.predicted_regime,
+        "confidence": recommendation.confidence,
+        "reasoning": recommendation.reasoning,
+        "warnings": recommendation.warnings,
+        "TI": profile.TI,
+        "SG": profile.SG,
+        "FT": profile.FT,
+        "UE": profile.UE,
+        "AR": profile.AR,
+        "temperature": params.temperature,
+        "top_p": params.top_p,
+        "max_tokens": params.max_tokens,
+        "model_recommendation": params.model_recommendation,
+        "tool_use_strategy": params.tool_use_strategy,
+        "retry_strategy": params.retry_strategy,
+        "context_strategy": params.context_strategy,
+    }

rpcs1-0.1.0/src/rpcs1/analysis.py

@@ -0,0 +1,147 @@
+"""
+Regime evaluation, reasoning, and warning generation.
+
+Mirrors TypeScript analysis.ts exactly.
+"""
+from __future__ import annotations
+
+from .types import (
+    ReceiverProfile,
+    PlatformParameters,
+    RecommendInput,
+    PredictedRegime,
+    Confidence,
+)
+from .matching import OSCILLATION_THRESHOLD
+
+
+# ─── Regime evaluation ────────────────────────────────────────────────────────
+
+def evaluate_regime(profile: ReceiverProfile) -> PredictedRegime:
+    """
+    Evaluate predicted stability regime.
+
+    Boundary conditions from neurotypes.json:
+      - near_oscillation: TI >= 65 AND SG >= 55
+      - near_overload:    TI <= 35 AND SG >= 65
+      - near_freeze:      UE <= 35 AND FT >= 65
+      - stable:           none of the above
+    """
+    if profile.TI >= 65 and profile.SG >= 55:
+        return "near_oscillation"
+    if profile.TI <= 35 and profile.SG >= 65:
+        return "near_overload"
+    if profile.UE <= 35 and profile.FT >= 65:
+        return "near_freeze"
+    return "stable"
+
+
+# ─── Warning detection ────────────────────────────────────────────────────────
+
+def generate_warnings(profile: ReceiverProfile, input_data: RecommendInput) -> list[str]:
+    warnings: list[str] = []
+    TI, SG, FT, UE, AR = profile.TI, profile.SG, profile.FT, profile.UE, profile.AR
+
+    sg_ti_product = SG * TI
+    if sg_ti_product > OSCILLATION_THRESHOLD:
+        warnings.append(
+            f"Oscillation risk: SG ({SG}) × TI ({TI}) = {sg_ti_product} exceeds the RPCS-1 "
+            f"oscillation threshold ({OSCILLATION_THRESHOLD}). Consider reducing SG or TI."
+        )
+
+    if SG >= 60 and FT <= 30 and TI <= 30:
+        warnings.append(
+            f"Overload risk: High SG ({SG}) + low FT ({FT}) + low TI ({TI}) — "
+            "agent may act on insufficient information. Raise FT or lower SG."
+        )
+
+    if UE <= 30 and FT >= 70:
+        warnings.append(
+            f"Freeze risk: Low UE ({UE}) + high FT ({FT}) — "
+            "agent may hedge endlessly without acting. Lower FT or raise UE."
+        )
+
+    env = input_data.environment
+    if env.stakes in ("high", "catastrophic") and AR >= 65:
+        warnings.append(
+            f"High stakes ({env.stakes}) + high AR ({AR}) — "
+            "aggressive ambiguity resolution in a high-stakes environment increases error risk."
+        )
+
+    if env.entropy == "chaotic" and env.context_relevance == "long":
+        warnings.append(
+            "Environment-context mismatch: chaotic entropy calls for short TI (Matching Principle), "
+            "but long context_relevance requests long integration. "
+            "This configuration is structurally near the oscillation boundary."
+        )
+
+    return warnings
+
+
+# ─── Reasoning string ─────────────────────────────────────────────────────────
+
+def _describe_level(value: float) -> str:
+    if value >= 70:
+        return "high"
+    if value >= 40:
+        return "moderate"
+    return "low"
+
+
+def generate_reasoning(
+    input_data: RecommendInput,
+    profile: ReceiverProfile,
+    params: PlatformParameters,
+) -> str:
+    TI, SG, FT, UE, AR = profile.TI, profile.SG, profile.FT, profile.UE, profile.AR
+    env = input_data.environment
+
+    return (
+        f"Environment analysis: {env.entropy} entropy → Matching Principle (Pred-09-5: TI ~ 1/H) "
+        f"yields TI = {TI} ({_describe_level(TI)} temporal integration window). "
+        f"{env.stakes} stakes drive SG = {SG} ({_describe_level(SG)} signal gain) and "
+        f"FT = {FT} ({_describe_level(FT)} filtering threshold) for basin stability. "
+        f"{env.commitment_style} commitment style sets AR = {AR}; "
+        f"{env.context_relevance} context relevance + entropy set UE = {UE}. "
+        f"Platform mapping: temperature = {params.temperature} (from SG via 1/SG relationship), "
+        f"max_tokens = {params.max_tokens} (from TI), "
+        f"context_strategy = {params.context_strategy}."
+    )
+
+
+# ─── Principles applied ───────────────────────────────────────────────────────
+
+def list_principles_applied(
+    input_data: RecommendInput, profile: ReceiverProfile
+) -> list[str]:
+    principles = [
+        "Matching Principle (Pred-09-5): TI ~ 1/H",
+        "Basin Stability: minimize V(R,E) subject to task constraints",
+        "Boundary Avoidance: stay away from oscillation/overload/freeze regimes",
+    ]
+    if profile.SG * profile.TI > OSCILLATION_THRESHOLD * 0.8:
+        principles.append(
+            "Oscillation Threshold (Paper 9 §oscillatory threshold): SG × TI < Δ_R"
+        )
+    if input_data.environment.stakes in ("high", "catastrophic"):
+        principles.append(
+            "Conservative Gating (high-stakes): raise FT, lower SG to prevent overload"
+        )
+    return principles
+
+
+# ─── Confidence ───────────────────────────────────────────────────────────────
+
+def assess_confidence(input_data: RecommendInput) -> Confidence:
+    score = 0
+    if input_data.task.domain:
+        score += 1
+    if input_data.task.expected_duration_per_call:
+        score += 1
+    score += 3  # all environment fields required
+
+    if score >= 4:
+        return "high"
+    if score >= 3:
+        return "medium"
+    return "low"