agent-learning 0.4.3__tar.gz → 0.5.1__tar.gz

{agent_learning-0.4.3/src/agent_learning.egg-info → agent_learning-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-learning
-Version: 0.4.3
+Version: 0.5.1
 Summary: Native, in-process reinforcement learning SDK for AI agents — in-memory and local-file storage by default.
 Author: Chris Tava
 License: MIT License
@@ -69,6 +69,10 @@ Dynamic: license-file
 
 Native reinforcement learning SDK for AI agents. An in-process Learner optimizes a small, interpretable TaskPolicy over discrete agent choices (understand intent and complete task by choosing the right outcome).
 
+TaskPolicies model reusable decisions among executable alternatives such as
+models, skills, tools, workflows, or workloads. Factual questions, ordinary
+chat, reporting, and learning automation are not policy tasks.
+
 ## How it works
 
 The SDK improves agents without LLM weight fine-tuning. There are no GPU fine-tune jobs and no opaque update cycles — just three pieces that run in your existing Python process:
@@ -79,4 +83,8 @@ The SDK improves agents without LLM weight fine-tuning. There are no GPU fine-tu
 
 3. **Learner** applies REINFORCE-with-baseline to update TaskPolicy logits directly from logged episodes. Updates are tiny gradient steps that run on local compute and persist through a pluggable store — in-memory or local files by default, with Azure Cosmos DB optional.
 
+`task-policy-decide` closes the loop at execution time by returning the selected
+action plus historical correctness, reward, result summaries, and per-metric
+quality feedback for the agent to use on its next delegated decision.
+
 Every episode, reward, run, and deployment is captured by the configured store — in-memory or local files by default, or Azure Cosmos DB — giving you a complete lineage and audit trail of how the policy evolved over time.

{agent_learning-0.4.3 → agent_learning-0.5.1}/PYPI.md

@@ -2,6 +2,10 @@
 
 Native reinforcement learning SDK for AI agents. An in-process Learner optimizes a small, interpretable TaskPolicy over discrete agent choices (understand intent and complete task by choosing the right outcome).
 
+TaskPolicies model reusable decisions among executable alternatives such as
+models, skills, tools, workflows, or workloads. Factual questions, ordinary
+chat, reporting, and learning automation are not policy tasks.
+
 ## How it works
 
 The SDK improves agents without LLM weight fine-tuning. There are no GPU fine-tune jobs and no opaque update cycles — just three pieces that run in your existing Python process:
@@ -12,4 +16,8 @@ The SDK improves agents without LLM weight fine-tuning. There are no GPU fine-tu
 
 3. **Learner** applies REINFORCE-with-baseline to update TaskPolicy logits directly from logged episodes. Updates are tiny gradient steps that run on local compute and persist through a pluggable store — in-memory or local files by default, with Azure Cosmos DB optional.
 
+`task-policy-decide` closes the loop at execution time by returning the selected
+action plus historical correctness, reward, result summaries, and per-metric
+quality feedback for the agent to use on its next delegated decision.
+
 Every episode, reward, run, and deployment is captured by the configured store — in-memory or local files by default, or Azure Cosmos DB — giving you a complete lineage and audit trail of how the policy evolved over time.

agent_learning-0.5.1/README.md

@@ -0,0 +1,188 @@
+# agent-learning
+
+Helping agents make better decisions with measurable feedback.
+
+`agent-learning` is a lightweight decision layer for an existing agent. It
+learns which option works best for a recurring task from a small, explicit set
+of executable alternatives, such as prompt variants, retrieval depths, tools,
+models, workflows, or escalation paths.
+
+The foundation model stays frozen. There are no GPU training jobs and no
+hidden prompt rewrites. The agent makes an explicit choice, records the
+user-visible outcome, scores the evidence, and applies a small CPU update to
+the next decision.
+
+<p align="center">
+   <img src="images/agent-decision-making.svg" alt="Animated agentic decision loop: choose a bounded action, execute it, score the observed outcome, and improve the next decision" width="960" style="max-width:100%; height:auto;" />
+</p>
+
+## The decision loop
+
+1. **Frame a reusable decision.** Define a stable decision context and at
+   least two actions the agent can actually execute. A TaskPolicy owns the
+   probability distribution for that `(agent_id, task_id)` pair.
+
+2. **Choose and execute.** `task-policy-decide` samples an action from the
+   active softmax policy and returns learned feedback from earlier attempts.
+   The agent uses that feedback and executes the selected action.
+
+3. **Observe and score.** A completed episode preserves the decision context,
+   selected action, output, result summary, latency, and independently
+   supported correctness evidence. Local scorers measure intent resolution,
+   task adherence, and task completion and shape them into one reward.
+
+4. **Improve the next decision.** REINFORCE-with-baseline nudges a few policy
+   logits, then persists a new policy snapshot. Better-than-usual choices gain
+   probability, worse-than-usual choices lose probability, and exploration
+   remains available.
+
+Everything runs in the existing Python process. Scoring is local by default;
+configured Azure AI evaluators remain available as an opt-in. Stores can be
+in-memory, local JSON files, or Azure Cosmos DB.
+
+## What counts as a decision
+
+A TaskPolicy is appropriate only when all of these are true:
+
+- The agent must choose among at least two explicit executable alternatives.
+- The alternatives are stable enough to reuse on future requests.
+- The choice can affect quality, correctness, latency, cost, safety, or
+  completion.
+- An observable outcome can later score whether the choice was useful.
+
+Good examples include choosing a retrieval strategy, model, tool, workflow,
+Azure workload, or escalation path for a concrete use case. Factual questions,
+ordinary chat, summaries, reporting, and the learning automation itself are not
+decision policies. Repetition without an executed outcome is not feedback.
+
+Before every eligible execution, the decision response includes the selected
+and currently recommended actions, policy version and probability, correctness
+rate, mean reward, metric scores, and recent result summaries. This makes the
+learned evidence useful during execution instead of producing a policy that is
+never consumed.
+
+## Install
+
+### Windows CLI
+
+For a Python-independent installation, download `agent-learn.exe` or the
+standalone installer from the
+[latest GitHub release](https://github.com/microsoft/agent-learning/releases/latest).
+The installer can add its installation directory to your user `PATH`, so
+`agent-learn` works from PowerShell or Command Prompt without Python or `pip`.
+
+```powershell
+agent-learn.exe --help
+```
+
+### Python SDK
+
+Released versions are published to PyPI:
+<https://pypi.org/project/agent-learning/>.
+
+```shell
+pip install agent-learning
+```
+
+## Quickstart: improve one recurring decision
+
+Use one durable store across CLI processes:
+
+```powershell
+$env:AGENT_LEARNING_STORE_BACKEND = "local"
+$env:AGENT_LEARNING_LOCAL_STORE_DIR = Join-Path $env:LOCALAPPDATA "agent-learning\store"
+```
+
+Define actions the agent can really execute in `actions.json`:
+
+```json
+[
+   {
+      "id": "use_text_search",
+      "description": "Search for exact symbols and terms",
+      "parameters": {"strategy": "text"}
+   },
+   {
+      "id": "use_semantic_search",
+      "description": "Search the repository by meaning",
+      "parameters": {"strategy": "semantic"}
+   }
+]
+```
+
+Initialize the decision once, then ask the active policy what to execute:
+
+```powershell
+agent-learn task-policy-init `
+   --agent-id code-reviewer `
+   --task-id choose-repository-search `
+   --decision-context "Choose a repository search strategy for a coding task" `
+   --actions .\actions.json
+
+agent-learn task-policy-decide `
+   --agent-id code-reviewer `
+   --task-id choose-repository-search
+```
+
+Execute the returned `selected_action`, preserve its policy fields, and record
+the independently observed outcome in `episode.json`. Then close the loop:
+
+```powershell
+agent-learn task-episode-register `
+   --agent-id code-reviewer `
+   --task-id choose-repository-search `
+   --episode .\episode.json `
+   --require-decision-policy
+
+agent-learn score --agent-id code-reviewer --task-id choose-repository-search
+agent-learn train --agent-id code-reviewer --task-id choose-repository-search --decision-only
+agent-learn task-policy-decide --agent-id code-reviewer --task-id choose-repository-search
+```
+
+The final decision consumes the updated probabilities and feedback from prior
+executions. Training defaults to a minimum of five completed episodes. See the
+[decision-making guide](docs/decision-making.md) for the episode schema,
+evidence rules, math, and deployment patterns.
+
+## Functional Testing
+
+A good way to see the SDK in action is to run the
+interactive capture scenario first, followed by the offline batch update:
+
+```powershell
+python tests/functional_cli_interactive.py
+python tests/functional_cli_batch.py
+```
+
+## Usage
+
+The `agent-learn` CLI provides the decision lifecycle and inspection
+operations:
+
+```text
+agent-learn list
+agent-learn --version
+agent-learn tasks-list <agent_id> [--decision-only]
+agent-learn task-episodes-count <agent_id> [--task-id <task_id>] [--include-incomplete] [--start-date <date>] [--end-date <date>]
+agent-learn task-episodes-list <agent_id> [--task-id <task_id>] [--limit <1-500>] [--include-incomplete] [--start-date <date>] [--end-date <date>]
+agent-learn task-policy-init --agent-id <agent_id> --task-id <task_id> --decision-context <context> --actions ./actions.json
+agent-learn task-policy-decide --agent-id <agent_id> --task-id <task_id> [--history-limit <1-500>] [--greedy] [--seed <integer>]
+agent-learn task-episode-register --agent-id <agent_id> --task-id <task_id> --episode ./episode.json [--require-decision-policy]
+agent-learn score --agent-id <agent_id> [--task-id <task_id>] [--limit <1-500>]
+agent-learn train --agent-id <agent_id> [--task-id <task_id>] [--decision-only] [--limit <1-500>] [--min-episodes <1-500>] [--start-date <date>] [--end-date <date>] [--skip-scoring]
+agent-learn task-policy --agent-id <agent_id> --task-id <task_id>
+```
+
+## Documentation
+
+- [Agentic decision making](docs/decision-making.md): concepts, evidence,
+   workflow, math, and deployment.
+- [Scout decision integration](docs/scout-agent-learn-skill.md): apply learned
+   delegated decisions during execution.
+- [Scout decision training](docs/scout-automation-agent-learning.md): train
+   eligible policies without turning automation into a policy task.
+- [The math, explained simply](docs/math-explained-simply.md) and
+   [mathematical reference](docs/math.md): softmax, rewards, baselines, and
+   REINFORCE.
+- [Tiered scoring design](docs/design.md): local and Azure-backed outcome
+   scoring.

{agent_learning-0.4.3 → agent_learning-0.5.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agent-learning"
-version = "0.4.3"
+version = "0.5.1"
 description = "Native, in-process reinforcement learning SDK for AI agents — in-memory and local-file storage by default."
 readme = "PYPI.md"
 requires-python = ">=3.10"

{agent_learning-0.4.3 → agent_learning-0.5.1}/src/agent_learning/_version.py

@@ -1,3 +1,3 @@
 """Package version."""
 
-__version__ = "0.4.3"
+__version__ = "0.5.1"

{agent_learning-0.4.3 → agent_learning-0.5.1}/src/agent_learning/cli.py

@@ -5,12 +5,15 @@ from __future__ import annotations
 import argparse
 import json
 import logging
+import math
+import random
 import sys
 import uuid
 from collections import Counter
 from datetime import datetime, timezone
 from typing import Any
 
+from ._version import __version__
 from .policy.softmax_bandit import SoftmaxPolicy
 from .storage.cosmos import get_default_store
 from .training.runner import LearningRunner
@@ -19,6 +22,7 @@ from .types import Action, Episode, MetricName, PolicySnapshot, RewardSource
 logger = logging.getLogger(__name__)
 
 _MAX_EPISODES = 500
+_DECISION_POLICY_SCOPE = "delegated_decision"
 
 
 def _episode_limit(value: str) -> int:
@@ -39,13 +43,18 @@ def _iso_date(value: str) -> str:
 
 
 def _build_arg_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(prog="agent-learn", description="Native RL CLI for AI agents.")
+    parser = argparse.ArgumentParser(
+        prog="agent-learn",
+        description=f"Native RL CLI for AI agents. SDK version {__version__}.",
+    )
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
     sub = parser.add_subparsers(dest="command", required=True)
 
     sub.add_parser("list", help="List discovered agent ids and names.")
 
     tasks = sub.add_parser("tasks-list", help="List tasks for an agent.")
     tasks.add_argument("agent_id")
+    tasks.add_argument("--decision-only", action="store_true")
 
     count = sub.add_parser(
         "task-episodes-count",
@@ -53,6 +62,11 @@ def _build_arg_parser() -> argparse.ArgumentParser:
     )
     count.add_argument("agent_id")
     count.add_argument("--task-id")
+    count.add_argument(
+        "--include-incomplete",
+        action="store_true",
+        help="Count pending and incomplete attempts as well as full learning episodes.",
+    )
     count.add_argument("--start-date", type=_iso_date)
     count.add_argument("--end-date", type=_iso_date)
 
@@ -72,6 +86,7 @@ def _build_arg_parser() -> argparse.ArgumentParser:
     train.add_argument("--task-id")
     train.add_argument("--limit", type=_episode_limit, default=200)
     train.add_argument("--min-episodes", type=_episode_limit, default=1)
+    train.add_argument("--decision-only", action="store_true")
     train.add_argument("--start-date", type=_iso_date)
     train.add_argument("--end-date", type=_iso_date)
     train.add_argument(
@@ -89,12 +104,27 @@ def _build_arg_parser() -> argparse.ArgumentParser:
     show.add_argument("--agent-id", required=True)
     show.add_argument("--task-id", required=True)
 
+    decide = sub.add_parser(
+        "task-policy-decide",
+        help="Choose a delegated decision action and return learned feedback.",
+    )
+    decide.add_argument("--agent-id", required=True)
+    decide.add_argument("--task-id", required=True)
+    decide.add_argument("--history-limit", type=_episode_limit, default=100)
+    decide.add_argument("--greedy", action="store_true")
+    decide.add_argument("--seed", type=int)
+
     init = sub.add_parser(
         "task-policy-init",
         help="Create and activate the initial policy for an agent task.",
     )
     init.add_argument("--agent-id", required=True)
     init.add_argument("--task-id", required=True)
+    init.add_argument(
+        "--decision-context",
+        required=True,
+        help="Stable description of the delegated choice this policy controls.",
+    )
     init.add_argument(
         "--actions",
         required=True,
@@ -107,6 +137,7 @@ def _build_arg_parser() -> argparse.ArgumentParser:
     )
     register.add_argument("--agent-id", required=True)
     register.add_argument("--task-id", required=True)
+    register.add_argument("--require-decision-policy", action="store_true")
     register.add_argument(
         "--episode",
         required=True,
@@ -124,7 +155,14 @@ def _cmd_agents_list(args: argparse.Namespace) -> int:
 
 
 def _cmd_agent_tasks_list(args: argparse.Namespace) -> int:
-    tasks = get_default_store().list_agent_tasks(args.agent_id)
+    store = get_default_store()
+    tasks = store.list_agent_tasks(args.agent_id)
+    if args.decision_only:
+        tasks = [
+            task
+            for task in tasks
+            if _is_decision_policy(store.get_active_policy(args.agent_id, task.id))
+        ]
     print(json.dumps([{"id": task.id, "name": task.name} for task in tasks], indent=2))
     return 0
 
@@ -133,7 +171,7 @@ def _cmd_agents_episodes_count(args: argparse.Namespace) -> int:
     count = get_default_store().count_episodes(
         args.agent_id,
         task_id=args.task_id,
-        full_only=True,
+        full_only=not args.include_incomplete,
         start_date=args.start_date,
         end_date=args.end_date,
     )
@@ -149,9 +187,8 @@ def _cmd_agents_episodes_list(args: argparse.Namespace) -> int:
         limit=_MAX_EPISODES,
         start_date=args.start_date,
         end_date=args.end_date,
+        full_only=not args.include_incomplete,
     )
-    if not args.include_incomplete:
-        episodes = [episode for episode in episodes if episode.is_full]
 
     payload = []
     for episode in episodes[: args.limit]:
@@ -190,6 +227,7 @@ def _cmd_train(args: argparse.Namespace) -> int:
         limit=args.limit,
         start_date=args.start_date,
         end_date=args.end_date,
+        full_only=True,
     )
     episode_limits = Counter(episode.task_id for episode in selected_episodes)
     runs: list[dict[str, Any]] = []
@@ -199,6 +237,9 @@ def _cmd_train(args: argparse.Namespace) -> int:
         if snapshot is None:
             skipped.append({"task_id": task_id, "reason": "no active policy"})
             continue
+        if args.decision_only and not _is_decision_policy(snapshot):
+            skipped.append({"task_id": task_id, "reason": "not a delegated decision policy"})
+            continue
         episode_limit = episode_limits.get(task_id, 0)
         if episode_limit == 0:
             skipped.append({"task_id": task_id, "reason": "no episodes in selected batch"})
@@ -244,6 +285,7 @@ def _cmd_score(args: argparse.Namespace) -> int:
         args.agent_id,
         task_id=args.task_id,
         limit=args.limit,
+        full_only=True,
     )
     scored = 0
     for episode in episodes:
@@ -266,6 +308,89 @@ def _policy_payload(snapshot: PolicySnapshot) -> dict[str, Any]:
     return payload
 
 
+def _is_decision_policy(snapshot: PolicySnapshot | None) -> bool:
+    return bool(
+        snapshot
+        and snapshot.metadata.get("policy_scope") == _DECISION_POLICY_SCOPE
+    )
+
+
+def _latest_aggregate(store: Any, episode: Episode) -> float | None:
+    rewards = [
+        reward
+        for reward in store.get_rewards_for_episode(episode.id, episode.agent_id)
+        if reward.source == RewardSource.AGGREGATE
+    ]
+    if not rewards:
+        return None
+    return max(rewards, key=lambda reward: reward.created_at).value
+
+
+def _decision_feedback(
+    store: Any, snapshot: PolicySnapshot, history_limit: int
+) -> dict[str, Any]:
+    stats = {
+        action.id: {
+            "attempts": 0,
+            "correctness_evaluated": 0,
+            "correct": 0,
+            "correctness_rate": None,
+            "rewarded_episodes": 0,
+            "mean_reward": None,
+            "recent_outcomes": [],
+        }
+        for action in snapshot.actions
+    }
+    reward_totals = {action.id: 0.0 for action in snapshot.actions}
+    episodes = store.query_episodes(
+        snapshot.agent_id,
+        task_id=snapshot.task_id,
+        limit=history_limit,
+    )
+    for episode in episodes:
+        action_id = episode.action_id
+        if action_id not in stats:
+            continue
+        action_stats = stats[action_id]
+        action_stats["attempts"] += 1
+        correct_action_id = episode.metadata.get("correct_action_id")
+        was_correct = None
+        if correct_action_id:
+            was_correct = action_id == correct_action_id
+            action_stats["correctness_evaluated"] += 1
+            action_stats["correct"] += int(was_correct)
+        reward = _latest_aggregate(store, episode)
+        if reward is not None:
+            action_stats["rewarded_episodes"] += 1
+            reward_totals[action_id] += reward
+        if len(action_stats["recent_outcomes"]) < 3:
+            score_breakdown = {}
+            for result in store.get_metric_results(episode.id, episode.agent_id):
+                score_breakdown[result.metric.value] = {
+                    "normalized": result.normalized,
+                    "status": result.status,
+                    "reason": result.reason,
+                }
+            action_stats["recent_outcomes"].append(
+                {
+                    "created_at": episode.created_at,
+                    "was_correct": was_correct,
+                    "reward": reward,
+                    "execution_status": episode.execution_status,
+                    "result_summary": episode.result_summary,
+                    "score_breakdown": score_breakdown,
+                }
+            )
+    for action_id, action_stats in stats.items():
+        evaluated = action_stats["correctness_evaluated"]
+        rewarded = action_stats["rewarded_episodes"]
+        if evaluated:
+            action_stats["correctness_rate"] = action_stats["correct"] / evaluated
+        if rewarded:
+            action_stats["mean_reward"] = reward_totals[action_id] / rewarded
+    return {"episodes_reviewed": len(episodes), "actions": stats}
+
+
 def _policy_difference(
     current: PolicySnapshot, previous: PolicySnapshot | None
 ) -> dict[str, Any] | None:
@@ -326,6 +451,78 @@ def _cmd_show_task_policy(args: argparse.Namespace) -> int:
     return 0
 
 
+def _cmd_decide_task_policy(args: argparse.Namespace) -> int:
+    store = get_default_store()
+    snapshot = store.get_active_policy(args.agent_id, args.task_id)
+    if snapshot is None:
+        print(
+            f"No active policy found for agent_id={args.agent_id!r}, "
+            f"task_id={args.task_id!r}.",
+            file=sys.stderr,
+        )
+        return 2
+    if not _is_decision_policy(snapshot):
+        print(
+            "The active policy is not marked as a delegated decision policy. "
+            "Questions, reporting tasks, and agent-learning automation are not eligible.",
+            file=sys.stderr,
+        )
+        return 2
+    rng = random.Random(args.seed) if args.seed is not None else None
+    policy = SoftmaxPolicy.from_snapshot(snapshot, rng=rng)
+    probabilities = policy.probabilities()
+    recommended_index = max(range(len(probabilities)), key=probabilities.__getitem__)
+    if args.greedy:
+        selected_index = recommended_index
+        selected_action = snapshot.actions[selected_index]
+        selected_probability = probabilities[selected_index]
+        logprob = math.log(max(selected_probability, 1e-12))
+        mode = "greedy"
+    else:
+        decision = policy.choose()
+        selected_action = decision.action
+        selected_index = next(
+            index
+            for index, action in enumerate(snapshot.actions)
+            if action.id == selected_action.id
+        )
+        selected_probability = probabilities[selected_index]
+        logprob = decision.logprob
+        mode = "sampled"
+    feedback = _decision_feedback(store, snapshot, args.history_limit)
+    selected_stats = feedback["actions"][selected_action.id]
+    recommendation = snapshot.actions[recommended_index]
+    print(
+        json.dumps(
+            {
+                "agent_id": snapshot.agent_id,
+                "task_id": snapshot.task_id,
+                "decision_context": snapshot.metadata.get("decision_context"),
+                "policy_id": snapshot.id,
+                "policy_version": snapshot.version,
+                "selection_mode": mode,
+                "selected_action": {
+                    **selected_action.to_dict(),
+                    "probability": selected_probability,
+                    "logprob": logprob,
+                },
+                "recommended_action": {
+                    **recommendation.to_dict(),
+                    "probability": probabilities[recommended_index],
+                },
+                "action_probabilities": {
+                    action.id: probability
+                    for action, probability in zip(snapshot.actions, probabilities)
+                },
+                "selected_action_feedback": selected_stats,
+                "historical_feedback": feedback,
+            },
+            indent=2,
+        )
+    )
+    return 0
+
+
 def _cmd_init_task_policy(args: argparse.Namespace) -> int:
     store = get_default_store()
     if store.get_active_policy(args.agent_id, args.task_id) is not None:
@@ -341,20 +538,35 @@ def _cmd_init_task_policy(args: argparse.Namespace) -> int:
     except (OSError, json.JSONDecodeError) as exc:
         print(f"Unable to read --actions file: {exc}", file=sys.stderr)
         return 2
-    if not isinstance(action_payloads, list) or not action_payloads:
-        print("--actions file must contain a non-empty JSON list", file=sys.stderr)
+    if not isinstance(action_payloads, list) or len(action_payloads) < 2:
+        print(
+            "--actions file must contain at least two delegated decision actions",
+            file=sys.stderr,
+        )
         return 2
     try:
         actions = [Action.from_dict(item) for item in action_payloads]
     except (KeyError, TypeError, ValueError) as exc:
         print(f"Invalid action definition: {exc}", file=sys.stderr)
         return 2
+    action_ids = [action.id for action in actions]
+    if any(not action_id.strip() for action_id in action_ids) or len(set(action_ids)) != len(
+        action_ids
+    ):
+        print("Decision action ids must be non-empty and unique", file=sys.stderr)
+        return 2
     policy = SoftmaxPolicy.from_actions(
         actions,
         agent_id=args.agent_id,
         task_id=args.task_id,
     )
     snapshot = policy.snapshot()
+    snapshot.metadata.update(
+        {
+            "policy_scope": _DECISION_POLICY_SCOPE,
+            "decision_context": args.decision_context,
+        }
+    )
     store.store_policy(snapshot)
     print(json.dumps(_policy_payload(snapshot), indent=2))
     return 0
@@ -389,6 +601,26 @@ def _cmd_register_task_episode(args: argparse.Namespace) -> int:
         print(f"Invalid episode definition: {exc}", file=sys.stderr)
         return 2
 
+    if args.require_decision_policy:
+        policy = get_default_store().get_policy(episode.policy_id or "", args.agent_id)
+        if not _is_decision_policy(policy) or policy.task_id != args.task_id:
+            print(
+                "Episode registration requires a delegated decision policy and its policy_id.",
+                file=sys.stderr,
+            )
+            return 2
+        action_ids = {action.id for action in policy.actions}
+        if episode.action_id not in action_ids:
+            print("Episode action_id is not in the delegated decision policy.", file=sys.stderr)
+            return 2
+        correct_action_id = episode.metadata.get("correct_action_id")
+        if correct_action_id is not None and correct_action_id not in action_ids:
+            print(
+                "Episode metadata.correct_action_id is not in the delegated decision policy.",
+                file=sys.stderr,
+            )
+            return 2
+
     get_default_store().store_episode(episode)
     print(json.dumps(episode.to_dict(), indent=2))
     return 0
@@ -406,6 +638,7 @@ def main(argv: list[str] | None = None) -> int:
         "train": _cmd_train,
         "score": _cmd_score,
         "task-policy": _cmd_show_task_policy,
+        "task-policy-decide": _cmd_decide_task_policy,
         "task-policy-init": _cmd_init_task_policy,
         "task-episode-register": _cmd_register_task_episode,
     }

{agent_learning-0.4.3 → agent_learning-0.5.1}/src/agent_learning/storage/base.py

@@ -56,8 +56,9 @@ class LearningStore(ABC):
         end_date: Optional[str] = None,
         policy_id: Optional[str] = None,
         task_id: Optional[str] = None,
+        full_only: bool = False,
     ) -> List[Episode]:
-        """List episodes filtered by optional time window, policy, or task."""
+        """List episodes filtered by time, policy, task, or completeness."""
 
     @abstractmethod
     def count_episodes(