context-driven-llm-scheduler 1.0.0__tar.gz

context_driven_llm_scheduler-1.0.0/.gitignore

@@ -0,0 +1,44 @@
+# Miscellaneous
+*.log
+*.swp
+.DS_Store
+.history
+
+# IntelliJ related
+*.iml
+*.ipr
+*.iws
+.idea/
+
+# The .vscode folder contains launch configuration and tasks you configure in
+# VS Code which you may wish to be included in version control, so this line
+# is commented out by default.
+.vscode/
+
+# Python
+.venv/
+venv/
+dist/
+build/
+*.egg-info/
+.ruff_cache/
+.pytest_cache/
+__pycache__/
+*.py[cod]
+
+#don't commit uv.lock for libraries:
+uv.lock
+.uv/
+
+# Test / coverage artifacts
+.coverage
+htmlcov/
+
+# Secrets and local env
+*.env
+!.env.example
+*-gcp-service-account-key.json
+
+# AI-assisted development tools
+.continue
+.claude/*.local.*

context_driven_llm_scheduler-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 CodifyIQ
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

context_driven_llm_scheduler-1.0.0/PKG-INFO

@@ -0,0 +1,140 @@
+Metadata-Version: 2.4
+Name: context-driven-llm-scheduler
+Version: 1.0.0
+Summary: Context-driven scheduled tasks for LLMs with persistent memory — inspired by OpenClaw's Heartbeat.
+Project-URL: Homepage, https://github.com/codifyiq/context-driven-llm-scheduler
+Author: CodifyIQ
+License: MIT
+License-File: LICENSE
+Keywords: context,cron,heartbeat,pulse,scheduler,state
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.10
+Requires-Dist: portalocker>=2.8
+Provides-Extra: dev
+Requires-Dist: apscheduler>=3.10; extra == 'dev'
+Requires-Dist: behave>=1.2.6; extra == 'dev'
+Requires-Dist: litellm>=1.0; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: sqlalchemy>=2.0; extra == 'dev'
+Provides-Extra: litellm
+Requires-Dist: litellm>=1.0; extra == 'litellm'
+Provides-Extra: scheduler
+Requires-Dist: apscheduler>=3.10; extra == 'scheduler'
+Provides-Extra: sqlite
+Requires-Dist: sqlalchemy>=2.0; extra == 'sqlite'
+Description-Content-Type: text/markdown
+
+# 🧠 context-driven-llm-scheduler
+
+**Context-driven scheduled tasks for LLMs with persistent memory.**
+
+[![PyPI version](https://img.shields.io/pypi/v/context-driven-llm-scheduler.svg)](https://pypi.org/project/context-driven-llm-scheduler/)
+[![Python versions](https://img.shields.io/pypi/pyversions/context-driven-llm-scheduler.svg)](https://pypi.org/project/context-driven-llm-scheduler/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+---
+
+Most scheduled tasks and cron jobs are stateless — they wake up with no memory of prior runs.
+
+**context-driven-llm-scheduler** solves this by giving LLM-powered recurring tasks **persistent context and memory** across executions.
+
+It lets you build reliable, intelligent scheduled agents that remember what they've seen, what they've done, and what still needs attention.
+
+Inspired by the [Heartbeat pattern](https://docs.openclaw.ai/gateway/heartbeat) from OpenClaw.
+
+## What is context-driven-llm-scheduler?
+
+`context-driven-llm-scheduler` is a lightweight Python library for defining and running **memoryful LLM scheduled tasks** (called **pulses**).
+
+You define each pulse in a markdown file (schedule, memory rules, model, and instructions). The library handles the complex parts:
+
+- Recalling relevant memory and context from previous runs
+- Assembling token-efficient prompts (with transparent trimming)
+- Atomic persistence of the LLM's decisions
+- Built-in deduplication (`seen`) and rate-limiting (`throttle`)
+
+You bring your own scheduler, LLM adapter, and storage backend (or use some default options we provide).
+
+## Features
+
+- **Markdown-first configuration** — prompts, schedules, and rules are easy to edit
+- **True persistent memory** — notes, seen items, key-value facts, throttles
+- **No lock-in** — compatible with cron, APScheduler, Lambda, Airflow, etc.
+- **Production-ready** — concurrency-safe, atomic transactions, honest token budgeting
+- **Minimal dependencies**
+
+## Quickstart
+
+**1. Create a pulse definition** at `pulses/inbox-triage.md`:
+
+```markdown
+---
+id: inbox-triage
+schedule: "*/15 * * * *"
+throttle: { notify: 1h }
+keep: { notes: 20, seen: 500 }
+model: anthropic/claude-sonnet-4-6
+---
+
+You are my inbox triage assistant.
+
+For each new urgent email:
+- Decide if it genuinely needs my attention.
+- If yes and the `notify` throttle allows, alert me and record the throttle.
+- Always mark the email as `seen`.
+
+Be conservative. Never notify about the same thing twice.
+```
+
+**2. Wire it up in Python:**
+```python
+from context_driven_llm_scheduler import PulseManager, FileStore, LiteLLMAdapter
+
+manager = PulseManager.from_dir("pulses", FileStore("./state"))
+adapter = LiteLLMAdapter("anthropic/claude-sonnet-4-6")
+
+@manager.pulse("inbox-triage")
+def triage(pulse, extra=None):
+    prompt = pulse.recall(extra={"emails": fetch_urgent_emails()})
+    ops = adapter.propose_memory_ops(prompt)
+    return pulse.persist(ops)
+```
+
+**3. Trigger the pulse:**
+```python
+manager.trigger("inbox-triage")   # Call from cron, scheduler, Lambda, etc.
+```
+
+## Core Concepts
+### The Pulse Interface
+
+#### Pull Data into the LLM Context Before the Scheduled Job
+`pulse.recall(...)` — assembles instructions + historical memory + fresh input data
+
+#### Store Data After the Scheduled Job
+`pulse.persist(ops)` — atomically applies the LLM's structured memory operations
+
+### Supported Memory Operations
+The LLM outputs operations via tool calling:
+
+`note` — free-text observation
+`seen` — mark item as handled (deduplication)
+`throttle` — record action for rate limiting
+`set` / `forget` — key/value persistent facts
+
+## Installation
+```bash
+pip install context-driven-llm-scheduler
+```
+
+### Optional extras:
+```bash
+pip install "context-driven-llm-scheduler[litellm,sqlite,scheduler]"
+```
+
+## Examples
+See the `examples/` directory.

context_driven_llm_scheduler-1.0.0/README.md

@@ -0,0 +1,110 @@
+# 🧠 context-driven-llm-scheduler
+
+**Context-driven scheduled tasks for LLMs with persistent memory.**
+
+[![PyPI version](https://img.shields.io/pypi/v/context-driven-llm-scheduler.svg)](https://pypi.org/project/context-driven-llm-scheduler/)
+[![Python versions](https://img.shields.io/pypi/pyversions/context-driven-llm-scheduler.svg)](https://pypi.org/project/context-driven-llm-scheduler/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+---
+
+Most scheduled tasks and cron jobs are stateless — they wake up with no memory of prior runs.
+
+**context-driven-llm-scheduler** solves this by giving LLM-powered recurring tasks **persistent context and memory** across executions.
+
+It lets you build reliable, intelligent scheduled agents that remember what they've seen, what they've done, and what still needs attention.
+
+Inspired by the [Heartbeat pattern](https://docs.openclaw.ai/gateway/heartbeat) from OpenClaw.
+
+## What is context-driven-llm-scheduler?
+
+`context-driven-llm-scheduler` is a lightweight Python library for defining and running **memoryful LLM scheduled tasks** (called **pulses**).
+
+You define each pulse in a markdown file (schedule, memory rules, model, and instructions). The library handles the complex parts:
+
+- Recalling relevant memory and context from previous runs
+- Assembling token-efficient prompts (with transparent trimming)
+- Atomic persistence of the LLM's decisions
+- Built-in deduplication (`seen`) and rate-limiting (`throttle`)
+
+You bring your own scheduler, LLM adapter, and storage backend (or use some default options we provide).
+
+## Features
+
+- **Markdown-first configuration** — prompts, schedules, and rules are easy to edit
+- **True persistent memory** — notes, seen items, key-value facts, throttles
+- **No lock-in** — compatible with cron, APScheduler, Lambda, Airflow, etc.
+- **Production-ready** — concurrency-safe, atomic transactions, honest token budgeting
+- **Minimal dependencies**
+
+## Quickstart
+
+**1. Create a pulse definition** at `pulses/inbox-triage.md`:
+
+```markdown
+---
+id: inbox-triage
+schedule: "*/15 * * * *"
+throttle: { notify: 1h }
+keep: { notes: 20, seen: 500 }
+model: anthropic/claude-sonnet-4-6
+---
+
+You are my inbox triage assistant.
+
+For each new urgent email:
+- Decide if it genuinely needs my attention.
+- If yes and the `notify` throttle allows, alert me and record the throttle.
+- Always mark the email as `seen`.
+
+Be conservative. Never notify about the same thing twice.
+```
+
+**2. Wire it up in Python:**
+```python
+from context_driven_llm_scheduler import PulseManager, FileStore, LiteLLMAdapter
+
+manager = PulseManager.from_dir("pulses", FileStore("./state"))
+adapter = LiteLLMAdapter("anthropic/claude-sonnet-4-6")
+
+@manager.pulse("inbox-triage")
+def triage(pulse, extra=None):
+    prompt = pulse.recall(extra={"emails": fetch_urgent_emails()})
+    ops = adapter.propose_memory_ops(prompt)
+    return pulse.persist(ops)
+```
+
+**3. Trigger the pulse:**
+```python
+manager.trigger("inbox-triage")   # Call from cron, scheduler, Lambda, etc.
+```
+
+## Core Concepts
+### The Pulse Interface
+
+#### Pull Data into the LLM Context Before the Scheduled Job
+`pulse.recall(...)` — assembles instructions + historical memory + fresh input data
+
+#### Store Data After the Scheduled Job
+`pulse.persist(ops)` — atomically applies the LLM's structured memory operations
+
+### Supported Memory Operations
+The LLM outputs operations via tool calling:
+
+`note` — free-text observation
+`seen` — mark item as handled (deduplication)
+`throttle` — record action for rate limiting
+`set` / `forget` — key/value persistent facts
+
+## Installation
+```bash
+pip install context-driven-llm-scheduler
+```
+
+### Optional extras:
+```bash
+pip install "context-driven-llm-scheduler[litellm,sqlite,scheduler]"
+```
+
+## Examples
+See the `examples/` directory.

context_driven_llm_scheduler-1.0.0/behave.ini

@@ -0,0 +1,3 @@
+[behave]
+paths = tests/features
+show_timings = false

context_driven_llm_scheduler-1.0.0/examples/ai_agent_pulse.py

@@ -0,0 +1,59 @@
+"""AI-agent pulse: a tiny state machine with cheap-checks-first.
+
+Demonstrates how a handler advances a persisted state machine
+(idle → working → escalate) across wake-ups, doing the cheapest check first
+and only "escalating" after repeated stalls. No real LLM/agent calls — the
+library deliberately ships no agent logic. State lives in the pulse's memory
+facts, so it carries across wake-ups with no external bookkeeping.
+"""
+
+import tempfile
+from pathlib import Path
+
+from context_driven_llm_scheduler import (
+    FileStore,
+    Pulse,
+    PulseDefinition,
+    PulseManager,
+)
+
+STORE_DIR = Path(tempfile.gettempdir()) / "context_driven_llm_scheduler-ai-agent"
+manager = PulseManager(FileStore(STORE_DIR))
+
+
+def job_is_done() -> bool:
+    """Cheap stand-in health check. Pretend the job is still running."""
+    return False
+
+
+@manager.pulse(
+    PulseDefinition(id="agent-heartbeat", instructions="Watch the job.")
+)
+def handle(pulse: Pulse, extra: dict | None = None) -> None:
+    """Advance the agent state machine, escalating after 3 stalls."""
+    facts = pulse.memory.facts
+    facts.setdefault("state", "idle")
+    facts.setdefault("stall_count", 0)
+
+    # Cheapest possible check first — bail before any expensive work.
+    if job_is_done():
+        facts["state"] = "idle"
+        facts["stall_count"] = 0
+        print("[idle] nothing to do")
+        return
+
+    if facts["state"] == "idle":
+        facts["state"] = "working"
+
+    facts["stall_count"] += 1
+    if facts["stall_count"] >= 3 and facts["state"] != "escalate":
+        facts["state"] = "escalate"
+        print("[ESCALATE] job stalled 3+ times — paging a human")
+    else:
+        print(f"[working] stall_count={facts['stall_count']}")
+
+
+if __name__ == "__main__":
+    for _ in range(4):
+        result = manager.trigger("agent-heartbeat")
+        print(f"  -> state={result['memory']['facts']['state']}")

context_driven_llm_scheduler-1.0.0/examples/email_monitor.py

@@ -0,0 +1,60 @@
+"""Email-monitor pulse: notify on new urgent mail, with spam prevention.
+
+Run it twice in a row::
+
+    uv run python examples/email_monitor.py
+    uv run python examples/email_monitor.py
+
+The first run "notifies" about the simulated urgent email; the second run sees
+it in the pulse's seen-set / throttle and stays quiet — proving state persisted
+across wake-ups via the FileStore. No model is involved: the handler returns
+the same memory operations a model would emit, so de-dup and throttling run
+through the standard memory protocol.
+"""
+
+import tempfile
+from pathlib import Path
+
+from context_driven_llm_scheduler import (
+    FileStore,
+    Pulse,
+    PulseDefinition,
+    PulseManager,
+)
+
+STORE_DIR = Path(tempfile.gettempdir()) / "context_driven_llm_scheduler-email-monitor"
+
+DEFINITION = PulseDefinition(
+    id="email-monitor",
+    instructions="Notify me about new urgent emails, at most once a minute.",
+    throttles={"alert": 60.0},
+    keep={"seen": 500},
+)
+manager = PulseManager(FileStore(STORE_DIR))
+
+
+def fetch_urgent_emails() -> list[dict[str, str]]:
+    """Stand-in inbox fetch. Returns one fixed urgent email."""
+    return [{"id": "msg-42", "subject": "Server on fire"}]
+
+
+@manager.pulse(DEFINITION)
+def handle(pulse: Pulse, extra: dict | None = None) -> list[dict[str, object]]:
+    """Notify once per urgent email, throttled to one alert per minute."""
+    ops: list[dict[str, object]] = []
+    for email in fetch_urgent_emails():
+        if email["id"] in pulse.memory.seen.get("notified", []):
+            print(f"[skip] already notified about {email['id']}")
+            continue
+        ops.append({"op": "seen", "field": "notified", "id": email["id"]})
+        if pulse.seconds_until_available("alert") > 0:
+            print("[skip] cooling down — not alerting yet")
+            continue
+        print(f"[ALERT] {email['subject']} ({email['id']})")
+        ops.append({"op": "throttle", "field": "alert"})
+    return ops
+
+
+if __name__ == "__main__":
+    result = manager.trigger("email-monitor")
+    print(f"trigger_count={result['trigger_count']} store={STORE_DIR}")

context_driven_llm_scheduler-1.0.0/examples/fastapi_bedrock.py

@@ -0,0 +1,106 @@
+"""FastAPI + Bedrock + markdown jobs + markdown results, wired end to end.
+
+Shows the shape for running unattended, markdown-defined LLM jobs inside a
+FastAPI backend:
+
+* **Markdown jobs, no frontmatter.** ``pulses/daily_digest.md`` is pure prose;
+  its id (``daily_digest``) comes from the filename. Scheduling lives in code,
+  where an engineer is already typing — not in the markdown.
+* **Bedrock via LiteLLM.** ``LiteLLMAdapter("bedrock/...")`` needs only AWS
+  credentials from the usual boto3 chain. The membrane stays model-agnostic.
+* **Markdown results.** A :class:`ResultLog` records each run — result, the
+  context the model saw, and the memory changes persisted for next time — to
+  ``results/<id>.md``.
+* **Safe under multiple workers.** The scheduler runs in ONE process (guarded
+  by an env flag), and ``add_cron`` defaults a coalesce window on, so even if
+  the flag is misconfigured the same tick won't double-fire.
+
+This is a sketch: it has no real route handlers and won't call Bedrock without
+credentials. The wiring is the point.
+"""
+
+import os
+from contextlib import asynccontextmanager
+from pathlib import Path
+
+from fastapi import FastAPI
+
+from context_driven_llm_scheduler import (
+    APSchedulerPulse,
+    FileStore,
+    LiteLLMAdapter,
+    Pulse,
+    PulseManager,
+    ResultLog,
+)
+
+PULSES_DIR = Path(__file__).parent / "pulses"
+STATE_DIR = Path(os.environ.get("PULSE_STATE_DIR", "/var/lib/pulses"))
+
+# One adapter for every pulse; swap the model string for any Bedrock model.
+adapter = LiteLLMAdapter(
+    "bedrock/anthropic.claude-3-5-sonnet-20241022-v2:0",
+    timeout=30,
+    num_retries=2,
+)
+
+# Markdown state (machine) and markdown results (human) live side by side.
+store = FileStore(STATE_DIR / "store")
+result_log = ResultLog(STATE_DIR / "results")
+manager = PulseManager.from_dir(PULSES_DIR, store, result_log=result_log)
+
+
+def fetch_recent_events() -> list[dict[str, str]]:
+    """Stand-in for whatever the job should look at this run."""
+    return [{"id": "evt-1", "summary": "deploy finished"}]
+
+
+@manager.pulse("daily_digest")
+def run_digest(pulse: Pulse, extra: dict | None = None) -> list[dict[str, object]]:
+    """Recall memory, ask Bedrock to decide, record the result and memory ops.
+
+    The model call is ours, exactly as the membrane intends: recall the prompt,
+    call the adapter, record the human-readable result, and return the memory
+    operations the model emitted for the library to persist.
+    """
+    events = fetch_recent_events()
+    prompt = pulse.recall(extra={"events": events}, adapter=adapter, max_tokens=8000)
+    digest = adapter.complete(prompt)
+    pulse.record_result(digest, events=len(events))
+    return adapter.propose_memory_ops(prompt)
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Start the pulse scheduler in exactly one process.
+
+    Run the API with many workers if you like, but set ``RUN_SCHEDULER=1`` for
+    only one of them (e.g. a dedicated worker, or a sidecar started with a
+    single worker). The coalesce window is a second line of defense, not a
+    substitute for this.
+    """
+    pulses: APSchedulerPulse | None = None
+    if os.environ.get("RUN_SCHEDULER") == "1":
+        pulses = APSchedulerPulse(manager)
+        # Coalesce window defaults to the schedule's period, so duplicate
+        # fires across processes collapse to a single run.
+        pulses.add_cron("daily_digest", "0 9 * * *")
+        pulses.start()
+    try:
+        yield
+    finally:
+        if pulses is not None:
+            pulses.shutdown()
+
+
+app = FastAPI(lifespan=lifespan)
+
+
+@app.post("/pulses/{pulse_id}/trigger")
+def trigger_now(pulse_id: str) -> dict[str, object]:
+    """Trigger a pulse on demand (e.g. for testing or a manual re-run).
+
+    No coalesce window here: a manual trigger should always run.
+    """
+    context = manager.trigger(pulse_id)
+    return {"trigger_count": context.get("trigger_count")}

context_driven_llm_scheduler-1.0.0/examples/inbox_triage.py

@@ -0,0 +1,98 @@
+"""Markdown-defined pulse: the membrane in action, runnable offline.
+
+The pulse is defined entirely in ``pulses/inbox_triage.md`` — schedule, memory
+policy, and the standing instructions. context_driven_llm_scheduler assembles the prompt from
+those instructions plus what the pulse remembers (:meth:`Pulse.recall`), the
+model decides what to do, and context_driven_llm_scheduler folds the model's memory operations
+back into stored state (:meth:`Pulse.persist`).
+
+This example ships a fake adapter so it runs with no API key. The real thing is
+one line — see ``REAL_ADAPTER`` below. Run it twice::
+
+    uv run python examples/inbox_triage.py
+    uv run python examples/inbox_triage.py
+
+The first run "notifies"; the second sees the email in memory and stays quiet.
+"""
+
+import tempfile
+from pathlib import Path
+
+from context_driven_llm_scheduler import FileStore, Pulse, PulseManager
+
+PULSES_DIR = Path(__file__).parent / "pulses"
+STORE_DIR = Path(tempfile.gettempdir()) / "context_driven_llm_scheduler-inbox-triage"
+
+manager = PulseManager.from_dir(PULSES_DIR, FileStore(STORE_DIR))
+
+
+def fetch_urgent_emails() -> list[dict[str, str]]:
+    """Stand-in inbox fetch. Returns one fixed urgent email."""
+    return [{"id": "msg-42", "subject": "Server on fire"}]
+
+
+class FakeAdapter:
+    """Offline stand-in for a real model: emits ops by simple rules.
+
+    Mirrors what a model would return through ``update_memory`` so the example
+    runs deterministically without network or keys.
+    """
+
+    def complete(self, prompt: str, **kwargs: object) -> str:
+        """Return the prompt unchanged (unused here)."""
+        return prompt
+
+    def count_tokens(self, text: str) -> int:
+        """Rough token estimate for budgeting demos."""
+        return len(text) // 4
+
+    def propose_memory_ops(
+        self, pulse: Pulse, emails: list[dict[str, str]]
+    ) -> list[dict[str, object]]:
+        """Decide ops the way the instructions describe."""
+        ops: list[dict[str, object]] = []
+        for email in emails:
+            if email["id"] in pulse.memory.seen.get("emails", []):
+                continue
+            ops.append({"op": "seen", "field": "emails", "id": email["id"]})
+            if pulse.seconds_until_available("notify") > 0:
+                ops.append({"op": "note", "text": "Held alert (throttle)."})
+                continue
+            print(f"[ALERT] {email['subject']} ({email['id']})")
+            ops.append({"op": "throttle", "field": "notify"})
+            ops.append(
+                {"op": "note", "text": f"Notified about {email['id']}."}
+            )
+        return ops
+
+
+adapter = FakeAdapter()
+
+# REAL_ADAPTER: swap the block below in (and
+# `pip install context_driven_llm_scheduler[litellm]`) to run on any provider — the model emits
+# the same ops. Call defaults (timeout, retries, ...) are configured once at
+# construction, not per call:
+#
+#   from context_driven_llm_scheduler import LiteLLMAdapter
+#   adapter = LiteLLMAdapter(
+#       "anthropic/claude-sonnet-4-6", timeout=30, num_retries=2,
+#   )
+#   # inside the handler:
+#   prompt = pulse.recall(extra={"emails": emails})
+#   return adapter.propose_memory_ops(prompt)
+
+
+@manager.pulse("inbox-triage")
+def triage(pulse: Pulse, extra: dict | None = None) -> list[dict[str, object]]:
+    """Recall memory, let the model decide, return memory ops to persist."""
+    emails = fetch_urgent_emails()
+    prompt = pulse.recall(extra={"emails": emails})
+    print("--- prompt the model would see ---")
+    print(prompt)
+    print("----------------------------------")
+    return adapter.propose_memory_ops(pulse, emails)
+
+
+if __name__ == "__main__":
+    result = manager.trigger("inbox-triage")
+    print(f"notes={result['memory']['notes']}")