cuddlytoddly 0.1.0__tar.gz

cuddlytoddly-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 3IVIS
+
+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.

cuddlytoddly-0.1.0/PKG-INFO

@@ -0,0 +1,165 @@
+Metadata-Version: 2.1
+Name: cuddlytoddly
+Version: 0.1.0
+Summary: LLM-driven autonomous DAG planning and execution system
+Author: 3IVIS GmbH
+License: MIT
+Project-URL: Homepage, https://github.com/3IVIS/cuddlytoddly
+Project-URL: Documentation, https://github.com/3IVIS/cuddlytoddly/tree/main/docs
+Project-URL: Issues, https://github.com/3IVIS/cuddlytoddly/issues
+Keywords: llm,dag,planning,autonomous,agent
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: gitpython>=3.1
+Requires-Dist: windows-curses>=2.3; sys_platform == "win32"
+Provides-Extra: openai
+Requires-Dist: openai>=1.0; extra == "openai"
+Provides-Extra: claude
+Requires-Dist: anthropic>=0.25; extra == "claude"
+Provides-Extra: local
+Requires-Dist: llama-cpp-python>=0.2; extra == "local"
+Requires-Dist: outlines>=0.0.46; extra == "local"
+Provides-Extra: all
+Requires-Dist: cuddlytoddly[claude,local,openai]; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-timeout; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+
+# cuddlytoddly
+
+An LLM-driven autonomous planning and execution system built around a DAG (directed acyclic graph) of tasks. Give it a goal; it breaks the goal into tasks, executes them with tools, verifies results, and fills in gaps — continuously, with live terminal and web UIs.
+
+Why "cuddlytoddly"?
+
+Large language models are powerful at generating text and solving well-scoped problems, but they are widely recognized as weak at long-horizon, complex planning. Left alone, they often miss dependencies, overlook edge cases, or wander off track.
+
+cuddlytoddly takes a different approach: instead of expecting the LLM to plan everything autonomously, we provide a structured framework where humans and the system collaborate. The LLM handles decomposition, execution, and verification, while the framework ensures tasks are organized, dependencies are respected, and gaps are bridged.
+
+Think of it as holding the model’s hand while it learns to walk through complex goals — hence the name cuddlytoddly. It’s not about blind autonomy; it’s about guided, reliable progress.
+
+## How it works
+
+1. A plain-English **goal** is seeded into the graph.
+2. The **LLMPlanner** decomposes it into a DAG of tasks with explicit dependencies.
+3. The **SimpleOrchestrator** picks up ready nodes and hands them to the **LLMExecutor**.
+4. The executor runs a multi-turn LLM loop, calling tools (code execution, file I/O, custom skills) until the task is done.
+5. The **QualityGate** checks the result against declared outputs; if something is missing it injects a bridging task automatically.
+6. Every mutation is written to an **event log** — crash and resume with no lost work.
+
+```
+goal → LLMPlanner → TaskGraph (DAG)
+                        │
+              SimpleOrchestrator
+              ├── LLMExecutor + tools
+              └── QualityGate (verify / bridge)
+                        │
+                   EventLog (JSONL) → replay on restart
+```
+
+## Installation
+
+```bash
+pip install cuddlytoddly                       
+```
+
+**Requirements:** Python 3.11+, `git` on your PATH (for the DAG visualiser).
+
+## Quick start
+
+```bash
+export ANTHROPIC_API_KEY=sk-ant-...
+cuddlytoddly "Write a market analysis for electric scooters"
+```
+
+Or pass no argument to use the startup screen with multiple options.
+The UI opens automatically. The run data is stored locally and can be resumed later — the event log preserves all state.
+
+## LLM backends
+
+| Backend | Install | `create_llm_client` call |
+|---|---|---|
+| Anthropic Claude | included | `create_llm_client("claude", model="claude-3-5-sonnet-20241022")` |
+| OpenAI / compatible | `[openai]` | `create_llm_client("openai", model="gpt-4o")` |
+| Local llama.cpp | `[local]` | `create_llm_client("llamacpp", model_path="/path/to/model.gguf")` |
+
+## Adding skills
+
+Drop a folder with a `SKILL.md` (and optional `tools.py`) into `cuddlytoddly/skills/`. The `SkillLoader` discovers it automatically. See [docs/skills.md](docs/skills.md) for the full format.
+
+## Documentation
+
+- [Architecture](docs/architecture.md) — how the components fit together
+- [Configuration](docs/configuration.md) — LLM backends, run directory, environment variables
+- [Skills](docs/skills.md) — built-in skills and how to add custom ones
+- [API Reference](docs/api.md) — public Python API
+
+## Project structure
+
+```
+cuddlytoddly/
+├── core/           # TaskGraph, events, reducer, ID generator
+├── engine/         # SimpleOrchestrator, QualityGate, ExecutionStepReporter
+├── infra/          # Logging, EventQueue, EventLog, replay
+├── planning/       # LLM interface, LLMPlanner, LLMExecutor, output validator
+├── skills/         # SkillLoader + built-in skill packs
+│   ├── code_execution/
+│   └── file_ops/
+└── ui/             # Curses terminal UI, Git DAG projection
+docs/
+pyproject.toml
+LICENSE
+```
+
+## Python API
+
+```python
+from cuddlytoddly.core.task_graph import TaskGraph
+from cuddlytoddly.core.events import Event, ADD_NODE
+from cuddlytoddly.core.reducer import apply_event
+from cuddlytoddly.infra.event_queue import EventQueue
+from cuddlytoddly.infra.event_log import EventLog
+from cuddlytoddly.planning.llm_interface import create_llm_client
+from cuddlytoddly.planning.llm_planner import LLMPlanner
+from cuddlytoddly.planning.llm_executor import LLMExecutor
+from cuddlytoddly.engine.quality_gate import QualityGate
+from cuddlytoddly.engine.llm_orchestrator import SimpleOrchestrator
+from cuddlytoddly.skills.skill_loader import SkillLoader
+
+# LLM client — swap "claude" for "openai" or "llamacpp"
+llm = create_llm_client("claude", model="claude-3-5-sonnet-20241022")
+
+graph    = TaskGraph()
+skills   = SkillLoader()
+planner  = LLMPlanner(llm_client=llm, graph=graph, skills_summary=skills.prompt_summary)
+executor = LLMExecutor(llm_client=llm, tool_registry=skills.registry)
+gate     = QualityGate(llm_client=llm, tool_registry=skills.registry)
+
+orchestrator = SimpleOrchestrator(
+    graph=graph, planner=planner, executor=executor,
+    quality_gate=gate, event_queue=EventQueue(),
+)
+
+# Seed a goal
+apply_event(graph, Event(ADD_NODE, {
+    "node_id": "my_goal",
+    "node_type": "goal",
+    "metadata": {"description": "Summarise the key risks of AGI", "expanded": False},
+}))
+
+orchestrator.start()
+# orchestrator runs in the background — block however suits your use case
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).

cuddlytoddly-0.1.0/README.md

@@ -0,0 +1,128 @@
+# cuddlytoddly
+
+An LLM-driven autonomous planning and execution system built around a DAG (directed acyclic graph) of tasks. Give it a goal; it breaks the goal into tasks, executes them with tools, verifies results, and fills in gaps — continuously, with live terminal and web UIs.
+
+Why "cuddlytoddly"?
+
+Large language models are powerful at generating text and solving well-scoped problems, but they are widely recognized as weak at long-horizon, complex planning. Left alone, they often miss dependencies, overlook edge cases, or wander off track.
+
+cuddlytoddly takes a different approach: instead of expecting the LLM to plan everything autonomously, we provide a structured framework where humans and the system collaborate. The LLM handles decomposition, execution, and verification, while the framework ensures tasks are organized, dependencies are respected, and gaps are bridged.
+
+Think of it as holding the model’s hand while it learns to walk through complex goals — hence the name cuddlytoddly. It’s not about blind autonomy; it’s about guided, reliable progress.
+
+## How it works
+
+1. A plain-English **goal** is seeded into the graph.
+2. The **LLMPlanner** decomposes it into a DAG of tasks with explicit dependencies.
+3. The **SimpleOrchestrator** picks up ready nodes and hands them to the **LLMExecutor**.
+4. The executor runs a multi-turn LLM loop, calling tools (code execution, file I/O, custom skills) until the task is done.
+5. The **QualityGate** checks the result against declared outputs; if something is missing it injects a bridging task automatically.
+6. Every mutation is written to an **event log** — crash and resume with no lost work.
+
+```
+goal → LLMPlanner → TaskGraph (DAG)
+                        │
+              SimpleOrchestrator
+              ├── LLMExecutor + tools
+              └── QualityGate (verify / bridge)
+                        │
+                   EventLog (JSONL) → replay on restart
+```
+
+## Installation
+
+```bash
+pip install cuddlytoddly                       
+```
+
+**Requirements:** Python 3.11+, `git` on your PATH (for the DAG visualiser).
+
+## Quick start
+
+```bash
+export ANTHROPIC_API_KEY=sk-ant-...
+cuddlytoddly "Write a market analysis for electric scooters"
+```
+
+Or pass no argument to use the startup screen with multiple options.
+The UI opens automatically. The run data is stored locally and can be resumed later — the event log preserves all state.
+
+## LLM backends
+
+| Backend | Install | `create_llm_client` call |
+|---|---|---|
+| Anthropic Claude | included | `create_llm_client("claude", model="claude-3-5-sonnet-20241022")` |
+| OpenAI / compatible | `[openai]` | `create_llm_client("openai", model="gpt-4o")` |
+| Local llama.cpp | `[local]` | `create_llm_client("llamacpp", model_path="/path/to/model.gguf")` |
+
+## Adding skills
+
+Drop a folder with a `SKILL.md` (and optional `tools.py`) into `cuddlytoddly/skills/`. The `SkillLoader` discovers it automatically. See [docs/skills.md](docs/skills.md) for the full format.
+
+## Documentation
+
+- [Architecture](docs/architecture.md) — how the components fit together
+- [Configuration](docs/configuration.md) — LLM backends, run directory, environment variables
+- [Skills](docs/skills.md) — built-in skills and how to add custom ones
+- [API Reference](docs/api.md) — public Python API
+
+## Project structure
+
+```
+cuddlytoddly/
+├── core/           # TaskGraph, events, reducer, ID generator
+├── engine/         # SimpleOrchestrator, QualityGate, ExecutionStepReporter
+├── infra/          # Logging, EventQueue, EventLog, replay
+├── planning/       # LLM interface, LLMPlanner, LLMExecutor, output validator
+├── skills/         # SkillLoader + built-in skill packs
+│   ├── code_execution/
+│   └── file_ops/
+└── ui/             # Curses terminal UI, Git DAG projection
+docs/
+pyproject.toml
+LICENSE
+```
+
+## Python API
+
+```python
+from cuddlytoddly.core.task_graph import TaskGraph
+from cuddlytoddly.core.events import Event, ADD_NODE
+from cuddlytoddly.core.reducer import apply_event
+from cuddlytoddly.infra.event_queue import EventQueue
+from cuddlytoddly.infra.event_log import EventLog
+from cuddlytoddly.planning.llm_interface import create_llm_client
+from cuddlytoddly.planning.llm_planner import LLMPlanner
+from cuddlytoddly.planning.llm_executor import LLMExecutor
+from cuddlytoddly.engine.quality_gate import QualityGate
+from cuddlytoddly.engine.llm_orchestrator import SimpleOrchestrator
+from cuddlytoddly.skills.skill_loader import SkillLoader
+
+# LLM client — swap "claude" for "openai" or "llamacpp"
+llm = create_llm_client("claude", model="claude-3-5-sonnet-20241022")
+
+graph    = TaskGraph()
+skills   = SkillLoader()
+planner  = LLMPlanner(llm_client=llm, graph=graph, skills_summary=skills.prompt_summary)
+executor = LLMExecutor(llm_client=llm, tool_registry=skills.registry)
+gate     = QualityGate(llm_client=llm, tool_registry=skills.registry)
+
+orchestrator = SimpleOrchestrator(
+    graph=graph, planner=planner, executor=executor,
+    quality_gate=gate, event_queue=EventQueue(),
+)
+
+# Seed a goal
+apply_event(graph, Event(ADD_NODE, {
+    "node_id": "my_goal",
+    "node_type": "goal",
+    "metadata": {"description": "Summarise the key risks of AGI", "expanded": False},
+}))
+
+orchestrator.start()
+# orchestrator runs in the background — block however suits your use case
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).

cuddlytoddly-0.1.0/cuddlytoddly/__init__.py

@@ -0,0 +1 @@
+

cuddlytoddly-0.1.0/cuddlytoddly/__main__.py

@@ -0,0 +1,276 @@
+# __main__.py  — updated startup section
+# Replace the existing main() function with this version.
+# Everything from the LLM client setup downward is unchanged.
+
+import sys
+import os
+import argparse
+import threading
+
+from pathlib import Path
+
+from cuddlytoddly.core.task_graph import TaskGraph
+from cuddlytoddly.core.events import Event, ADD_NODE
+from cuddlytoddly.core.reducer import apply_event
+from cuddlytoddly.infra.event_queue import EventQueue
+from cuddlytoddly.infra.event_log import EventLog
+from cuddlytoddly.infra.replay import rebuild_graph_from_log
+from cuddlytoddly.infra.logging import setup_logging, get_logger
+from cuddlytoddly.planning.llm_interface import create_llm_client
+from cuddlytoddly.planning.llm_planner import LLMPlanner
+from cuddlytoddly.planning.llm_executor import LLMExecutor
+from cuddlytoddly.engine.quality_gate import QualityGate
+from cuddlytoddly.engine.llm_orchestrator import SimpleOrchestrator
+from cuddlytoddly.skills.skill_loader import SkillLoader
+from cuddlytoddly.ui.curses_ui import run_ui
+from cuddlytoddly.ui.startup import StartupChoice
+from cuddlytoddly.ui.startup import run_startup_curses
+from cuddlytoddly.ui.web_server import run_web_ui
+from cuddlytoddly.core.id_generator import StableIDGenerator
+import cuddlytoddly.planning.llm_interface as llm_iface
+
+REPO_ROOT = Path(__file__).resolve().parent
+
+setup_logging()
+logger = get_logger(__name__)
+
+# ── Configuration ──────────────────────────────────────────────────────────────
+
+MODEL_PATH   = str(REPO_ROOT / "models/Llama-3.3-70B-Instruct-Q4_K_M.gguf")
+N_GPU_LAYERS = -1
+TEMPERATURE  = 0.1
+N_CTX        = int(131072 / 8)
+MAX_TOKENS   = int(65536 / 8)
+MAX_WORKERS  = 1
+
+
+def make_run_dir(goal_text: str) -> Path:
+    safe    = goal_text.lower().replace(" ", "_")
+    safe    = "".join(c for c in safe if c.isalnum() or c == "_")[:60]
+    run_dir = REPO_ROOT / "runs" / safe
+    run_dir.mkdir(parents=True, exist_ok=True)
+    (run_dir / "outputs").mkdir(exist_ok=True)
+    return run_dir
+
+
+def main():
+
+    # ── CLI ───────────────────────────────────────────────────────────────────
+    parser = argparse.ArgumentParser(
+        prog="cuddlytoddly",
+        description="LLM-powered DAG planning and execution system.",
+    )
+    parser.add_argument(
+        "--terminal",
+        action="store_true",
+        default=False,
+        help="Launch the terminal UI instead of the web UI.",
+    )
+    parser.add_argument(
+        "--host",
+        default="127.0.0.1",
+        help="Host for the web UI server (default: 127.0.0.1).",
+    )
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=8765,
+        help="Port for the web UI server (default: 8765).",
+    )
+    parser.add_argument(
+        "goal",
+        nargs="*",
+        help=(
+            "Goal text to start immediately, skipping the startup screen. "
+            "If omitted the startup screen is shown."
+        ),
+    )
+    args = parser.parse_args()
+    use_web = not args.terminal
+
+    # ── Startup screen ────────────────────────────────────────────────────────
+    # If a goal was passed on the CLI, skip the startup screen and go straight
+    # to a new-goal run.  Otherwise show the appropriate startup UI.
+    inline_goal = " ".join(args.goal).strip()
+
+    if inline_goal:
+        # Bypass startup screen — behaves like the old CLI usage
+        choice = StartupChoice(
+            mode="new_goal",
+            run_dir=make_run_dir(inline_goal).resolve(),
+            goal_text=inline_goal,
+            is_fresh=True,
+        )
+    elif use_web:
+        # Web startup screen is shown inside the browser — no blocking call here.
+        # We use a deferred choice that will be filled in via /api/startup.
+        choice = None
+    else:
+        # Curses startup screen — blocks until the user makes a choice.
+        try:
+            choice = run_startup_curses(REPO_ROOT)
+        except SystemExit:
+            return   # user pressed q
+
+    # ── For web UI with no inline goal, defer all init to init_fn ────────────
+    if use_web and choice is None:
+
+        def init_fn(ch: StartupChoice):
+            return _init_system(ch, use_web)
+
+        run_web_ui(
+            repo_root=REPO_ROOT,
+            init_fn=init_fn,
+            host=args.host,
+            port=args.port,
+        )
+        return
+
+    # ── Init system ───────────────────────────────────────────────────────────
+    orchestrator, run_dir = _init_system(choice, use_web)
+
+    # ── Launch UI ─────────────────────────────────────────────────────────────
+    if use_web:
+        run_web_ui(
+            orchestrator=orchestrator,
+            run_dir=run_dir,
+            host=args.host,
+            port=args.port,
+        )
+    else:
+        run_ui(
+            orchestrator,
+            run_dir=run_dir,
+            repo_root=REPO_ROOT,
+            restart_fn=_init_system,
+        )
+
+    # ── Final log ─────────────────────────────────────────────────────────────
+    snap = orchestrator.graph.get_snapshot()
+    logger.info("=== Final graph state (%d nodes) ===", len(snap))
+    for nid, n in snap.items():
+        logger.info("  [%s] %s", n.status, nid)
+
+
+def _init_system(choice: "StartupChoice", use_web: bool):
+    """
+    Build the full orchestrator from a StartupChoice.
+    Extracted so both the curses and web startup paths share the same logic.
+    Returns (orchestrator, run_dir).
+    """
+    goal_text = choice.goal_text
+    goal_id   = goal_text.replace(" ", "_")[:60]
+    run_dir   = choice.run_dir.resolve()
+
+    # ── Logging ───────────────────────────────────────────────────────────────
+    setup_logging(log_dir=run_dir / "logs")
+    _logger = get_logger(__name__)
+    _logger.info("=== cuddlytoddly starting  mode=%s  ui=%s ===",
+                 choice.mode, "web" if use_web else "curses")
+    _logger.info("Run directory: %s", run_dir)
+
+    # ── Event log ─────────────────────────────────────────────────────────────
+    event_log_path = run_dir / "events.jsonl"
+    event_log      = EventLog(str(event_log_path))
+    log_path       = Path(event_log_path)
+
+    # ── LLM cache ─────────────────────────────────────────────────────────────
+    cache_path = str(run_dir / "llamacpp_cache.json")
+
+    # ── Git repo — per run ────────────────────────────────────────────────────
+    import cuddlytoddly.ui.git_projection as git_proj
+    git_proj.REPO_PATH = str(run_dir / "dag_repo")
+
+    # ── Working directory — sandbox file tools ────────────────────────────────
+    os.chdir(run_dir / "outputs")
+    _logger.info("Working directory: %s", Path.cwd())
+
+    llm_iface.id_gen = StableIDGenerator(
+        mapping_file=run_dir / "task_id_map.json",
+        id_length=6,
+    )
+
+    # ── Graph init ────────────────────────────────────────────────────────────
+    if not choice.is_fresh and log_path.exists() and log_path.stat().st_size > 0:
+        _logger.info("[STARTUP] Replaying event log")
+        graph       = rebuild_graph_from_log(event_log)
+        fresh_start = False
+        _logger.info("[STARTUP] Restored %d nodes", len(graph.nodes))
+
+        for step_id in [n.id for n in graph.nodes.values()
+                        if n.node_type == "execution_step"]:
+            if step_id in graph.nodes:
+                graph.detach_node(step_id)
+
+        for node_id in {n.id for n in graph.nodes.values()
+                        if n.status in ("running", "failed")
+                        and n.node_type != "execution_step"}:
+            n = graph.nodes.get(node_id)
+            if n:
+                n.status = "pending"
+                n.result = None
+                n.metadata.pop("retry_count",          None)
+                n.metadata.pop("verification_failure", None)
+                n.metadata.pop("verified",             None)
+
+        graph.recompute_readiness()
+    else:
+        graph       = TaskGraph()
+        fresh_start = True
+
+    # ── LLM / components ──────────────────────────────────────────────────────
+    shared_llm = create_llm_client(
+        "llamacpp",
+        model_path=MODEL_PATH,
+        n_gpu_layers=N_GPU_LAYERS,
+        temperature=TEMPERATURE,
+        n_ctx=N_CTX,
+        max_tokens=MAX_TOKENS,
+        cache_path=cache_path,
+    )
+
+    skills       = SkillLoader()
+    registry     = skills.registry
+    planner      = LLMPlanner(llm_client=shared_llm, graph=graph,
+                              skills_summary=skills.prompt_summary)
+    executor     = LLMExecutor(llm_client=shared_llm, tool_registry=registry, max_turns=5)
+    quality_gate = QualityGate(llm_client=shared_llm, tool_registry=registry)
+
+    queue        = EventQueue()
+    orchestrator = SimpleOrchestrator(
+        graph=graph, planner=planner, executor=executor,
+        quality_gate=quality_gate, event_log=event_log,
+        event_queue=queue, max_workers=MAX_WORKERS,
+    )
+
+    # ── Seed graph ────────────────────────────────────────────────────────────
+    if fresh_start:
+        if choice.mode == "manual_plan" and choice.plan_events:
+            _logger.info("[STARTUP] Seeding manual plan (%d events)",
+                         len(choice.plan_events))
+            for evt_dict in choice.plan_events:
+                apply_event(graph, Event(evt_dict["type"], evt_dict["payload"]),
+                            event_log=event_log)
+        else:
+            _logger.info("[STARTUP] Seeding new goal: %s", goal_text)
+            apply_event(graph, Event(ADD_NODE, {
+                "node_id":      goal_id,
+                "node_type":    "goal",
+                "dependencies": [],
+                "origin":       "user",
+                "metadata":     {"description": goal_text, "expanded": False},
+            }), event_log=event_log)
+
+    orchestrator.start()
+
+    if not fresh_start:
+        def _bg_verify():
+            _logger.info("[STARTUP] Background verification pass starting...")
+            orchestrator.verify_restored_nodes()
+            _logger.info("[STARTUP] Background verification complete")
+        threading.Thread(target=_bg_verify, daemon=True, name="startup-verify").start()
+
+    return orchestrator, run_dir
+
+if __name__ == "__main__":
+    main()

cuddlytoddly-0.1.0/cuddlytoddly/core/__init__.py

@@ -0,0 +1 @@
+

cuddlytoddly-0.1.0/cuddlytoddly/core/events.py

@@ -0,0 +1,47 @@
+"""
+Event Definitions
+
+All mutations must go through reducer.
+"""
+
+# core/events.py
+
+from datetime import datetime
+
+
+class Event:
+    def __init__(self, type, payload, timestamp=None):
+        self.type = type
+        self.payload = payload
+        self.timestamp = timestamp or datetime.utcnow().isoformat()
+
+    def to_dict(self):
+        return {
+            "type": self.type,
+            "payload": self.payload,
+            "timestamp": self.timestamp,
+        }
+
+    @classmethod
+    def from_dict(cls, data):
+        return cls(
+            type=data["type"],
+            payload=data["payload"],
+            timestamp=data.get("timestamp"),
+        )
+
+# Event types
+ADD_NODE = "ADD_NODE"
+REMOVE_NODE = "REMOVE_NODE"
+ADD_DEPENDENCY = "ADD_DEPENDENCY"
+REMOVE_DEPENDENCY = "REMOVE_DEPENDENCY"
+MARK_RUNNING = "MARK_RUNNING"
+MARK_DONE = "MARK_DONE"
+MARK_FAILED = "MARK_FAILED"
+RESET_NODE = "RESET_NODE"
+UPDATE_METADATA = "UPDATE_METADATA"
+DETACH_NODE = "DETACH_NODE"
+UPDATE_STATUS = "UPDATE_STATUS"
+SET_RESULT = "SET_RESULT"
+SET_NODE_TYPE = "SET_NODE_TYPE"
+RESET_SUBTREE = "RESET_SUBTREE"