dodar 0.1.0__tar.gz

dodar-0.1.0/.gitignore

@@ -0,0 +1,41 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.eggs/
+*.egg
+
+# Virtual environments
+.venv/
+venv/
+env/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Environment
+.env
+.env.local
+
+# Data (runs and scores are generated, not committed)
+backend/data/runs/
+backend/data/scores/
+
+# Node
+node_modules/
+frontend/dist/
+frontend/.vite/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/

dodar-0.1.0/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: dodar
+Version: 0.1.0
+Summary: DODAR — Structured reasoning framework for AI agents, adapted from aviation CRM
+Project-URL: Homepage, https://dodar.crox.io
+Project-URL: Documentation, https://dodar.crox.io/framework
+Project-URL: Repository, https://github.com/afieldofdreams/dodar
+Project-URL: Research, https://dodar.crox.io/research
+Author-email: Adam Field <adam@crox.io>
+License-Expression: MIT
+Keywords: agents,ai,crm,decision-making,dodar,llm,reasoning
+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.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: anthropic>=0.30
+Requires-Dist: openai>=1.30
+Provides-Extra: all
+Requires-Dist: google-genai>=1.0; extra == 'all'
+Requires-Dist: httpx>=0.27; extra == 'all'
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Provides-Extra: google
+Requires-Dist: google-genai>=1.0; extra == 'google'
+Provides-Extra: ollama
+Requires-Dist: httpx>=0.27; extra == 'ollama'
+Description-Content-Type: text/markdown
+
+# DODAR
+
+**Structured reasoning framework for AI agents** — adapted from aviation Crew Resource Management.
+
+DODAR (Diagnose, Options, Decide, Action, Review) imposes explicit gates at each stage of analysis, preventing the reasoning failures that LLMs share with humans under pressure: premature anchoring, option narrowing, and treating decisions as final.
+
+## Install
+
+```bash
+pip install dodar
+```
+
+## Quick start
+
+```python
+from dodar import DODAR
+
+dodar = DODAR(model="gpt-4.1-mini")
+result = dodar.analyze("Your scenario here...")
+
+# Structured access to each reasoning phase
+result.diagnosis.hypotheses       # Ranked competing causes
+result.options.alternatives       # Distinct paths with trade-offs
+result.decision.recommendation    # The call + justification
+result.action.steps               # Sequenced implementation plan
+result.review.failure_modes       # Self-critique
+```
+
+## Pipeline mode
+
+For maximum quality, use the pipeline where each DODAR phase runs as a separate model call:
+
+```python
+from dodar import DODAR
+
+dodar = DODAR(model="gpt-4.1-mini", mode="pipeline")
+result = dodar.analyze("Your scenario here...")
+```
+
+Research shows GPT-4.1 Mini + pipeline scores 104% of Claude Opus 4.6 zero-shot quality at 89% lower cost. [Read the whitepaper](https://dodar.crox.io/research).
+
+## Supported models
+
+| Provider | Models |
+|----------|--------|
+| Anthropic | claude-opus-4-6, claude-sonnet-4-5, claude-haiku-4-5 |
+| OpenAI | gpt-5.4, gpt-4o, gpt-4o-mini, gpt-4.1-mini, gpt-4.1-nano |
+| Google | gemini-2.0-flash (install with `pip install dodar[google]`) |
+| Ollama | Any local model (install with `pip install dodar[ollama]`) |
+
+## Links
+
+- [Documentation](https://dodar.crox.io/framework)
+- [Research & whitepaper](https://dodar.crox.io/research)
+- [GitHub](https://github.com/afieldofdreams/dodar)
+
+## License
+
+MIT

dodar-0.1.0/README.md

@@ -0,0 +1,59 @@
+# DODAR
+
+**Structured reasoning framework for AI agents** — adapted from aviation Crew Resource Management.
+
+DODAR (Diagnose, Options, Decide, Action, Review) imposes explicit gates at each stage of analysis, preventing the reasoning failures that LLMs share with humans under pressure: premature anchoring, option narrowing, and treating decisions as final.
+
+## Install
+
+```bash
+pip install dodar
+```
+
+## Quick start
+
+```python
+from dodar import DODAR
+
+dodar = DODAR(model="gpt-4.1-mini")
+result = dodar.analyze("Your scenario here...")
+
+# Structured access to each reasoning phase
+result.diagnosis.hypotheses       # Ranked competing causes
+result.options.alternatives       # Distinct paths with trade-offs
+result.decision.recommendation    # The call + justification
+result.action.steps               # Sequenced implementation plan
+result.review.failure_modes       # Self-critique
+```
+
+## Pipeline mode
+
+For maximum quality, use the pipeline where each DODAR phase runs as a separate model call:
+
+```python
+from dodar import DODAR
+
+dodar = DODAR(model="gpt-4.1-mini", mode="pipeline")
+result = dodar.analyze("Your scenario here...")
+```
+
+Research shows GPT-4.1 Mini + pipeline scores 104% of Claude Opus 4.6 zero-shot quality at 89% lower cost. [Read the whitepaper](https://dodar.crox.io/research).
+
+## Supported models
+
+| Provider | Models |
+|----------|--------|
+| Anthropic | claude-opus-4-6, claude-sonnet-4-5, claude-haiku-4-5 |
+| OpenAI | gpt-5.4, gpt-4o, gpt-4o-mini, gpt-4.1-mini, gpt-4.1-nano |
+| Google | gemini-2.0-flash (install with `pip install dodar[google]`) |
+| Ollama | Any local model (install with `pip install dodar[ollama]`) |
+
+## Links
+
+- [Documentation](https://dodar.crox.io/framework)
+- [Research & whitepaper](https://dodar.crox.io/research)
+- [GitHub](https://github.com/afieldofdreams/dodar)
+
+## License
+
+MIT

dodar-0.1.0/pyproject.toml

@@ -0,0 +1,46 @@
+[project]
+name = "dodar"
+version = "0.1.0"
+description = "DODAR — Structured reasoning framework for AI agents, adapted from aviation CRM"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    { name = "Adam Field", email = "adam@crox.io" },
+]
+keywords = ["ai", "agents", "reasoning", "llm", "decision-making", "crm", "dodar"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "anthropic>=0.30",
+    "openai>=1.30",
+]
+
+[project.optional-dependencies]
+google = ["google-genai>=1.0"]
+ollama = ["httpx>=0.27"]
+all = ["google-genai>=1.0", "httpx>=0.27"]
+dev = ["pytest>=8.0", "pytest-asyncio>=0.24"]
+
+[project.urls]
+Homepage = "https://dodar.crox.io"
+Documentation = "https://dodar.crox.io/framework"
+Repository = "https://github.com/afieldofdreams/dodar"
+Research = "https://dodar.crox.io/research"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/dodar"]

dodar-0.1.0/src/dodar/__init__.py

@@ -0,0 +1,37 @@
+"""DODAR — Structured reasoning framework for AI agents.
+
+Usage:
+    from dodar import DODAR
+
+    dodar = DODAR(model="gpt-4.1-mini")
+    result = dodar.analyze("Your scenario here...")
+
+    print(result.diagnosis.hypotheses)
+    print(result.decision.recommendation)
+    print(result.review.failure_modes)
+"""
+
+from dodar.core import (
+    DODAR,
+    DODARResult,
+    DiagnosisResult,
+    OptionsResult,
+    DecisionResult,
+    ActionResult,
+    ReviewResult,
+)
+from dodar.runners import available_models
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "DODAR",
+    "DODARResult",
+    "DiagnosisResult",
+    "OptionsResult",
+    "DecisionResult",
+    "ActionResult",
+    "ReviewResult",
+    "available_models",
+    "__version__",
+]

dodar-0.1.0/src/dodar/core.py

@@ -0,0 +1,335 @@
+"""DODAR core — the main DODAR class and result types."""
+
+from __future__ import annotations
+
+import asyncio
+import re
+from dataclasses import dataclass, field
+from typing import Literal
+
+from dodar.prompts import (
+    DODAR_SINGLE, ZERO_SHOT, COT,
+    PIPELINE_DIAGNOSE, PIPELINE_OPTIONS, PIPELINE_DECIDE,
+    PIPELINE_ACTION, PIPELINE_REVIEW,
+)
+from dodar.runners import run_model, available_models
+
+
+# --------------------------------------------------------------------------- #
+# Result dataclasses
+# --------------------------------------------------------------------------- #
+
+@dataclass
+class DiagnosisResult:
+    raw_text: str = ""
+    hypotheses: list[str] = field(default_factory=list)
+    assumptions: list[str] = field(default_factory=list)
+    unknowns: list[str] = field(default_factory=list)
+
+
+@dataclass
+class OptionsResult:
+    raw_text: str = ""
+    alternatives: list[str] = field(default_factory=list)
+    core_tension: str = ""
+    trade_offs: list[str] = field(default_factory=list)
+
+
+@dataclass
+class DecisionResult:
+    raw_text: str = ""
+    recommendation: str = ""
+    confidence: str = ""
+    falsifiability: str = ""
+
+
+@dataclass
+class ActionResult:
+    raw_text: str = ""
+    steps: list[str] = field(default_factory=list)
+    reversible_steps: list[str] = field(default_factory=list)
+    irreversible_steps: list[str] = field(default_factory=list)
+
+
+@dataclass
+class ReviewResult:
+    raw_text: str = ""
+    failure_modes: list[str] = field(default_factory=list)
+    assumptions_to_validate: list[str] = field(default_factory=list)
+    abort_conditions: list[str] = field(default_factory=list)
+
+
+@dataclass
+class DODARResult:
+    """Complete DODAR analysis result with structured phase access."""
+    text: str = ""
+    diagnosis: DiagnosisResult = field(default_factory=DiagnosisResult)
+    options: OptionsResult = field(default_factory=OptionsResult)
+    decision: DecisionResult = field(default_factory=DecisionResult)
+    action: ActionResult = field(default_factory=ActionResult)
+    review: ReviewResult = field(default_factory=ReviewResult)
+    input_tokens: int = 0
+    output_tokens: int = 0
+    latency_seconds: float = 0.0
+    model: str = ""
+    mode: str = "dodar"
+
+
+# --------------------------------------------------------------------------- #
+# Parsing
+# --------------------------------------------------------------------------- #
+
+def _extract_list_items(text: str) -> list[str]:
+    items = []
+    for line in text.split("\n"):
+        line = line.strip()
+        m = re.match(r"^(?:\d+[\.\)]\s*|\-\s+|\*\s+|•\s+)(.+)", line)
+        if m:
+            items.append(m.group(1).strip())
+    return items
+
+
+def _split_phases(text: str) -> dict[str, str]:
+    phases: dict[str, str] = {}
+    phase_names = ["DIAGNOSE", "OPTIONS", "DECIDE", "ACTION", "REVIEW"]
+    pattern = r"##?\s*(?:Phase\s*\d+\s*[:\-]\s*)?(" + "|".join(phase_names) + r")\b"
+    matches = list(re.finditer(pattern, text, re.IGNORECASE))
+    for i, match in enumerate(matches):
+        name = match.group(1).upper()
+        start = match.end()
+        end = matches[i + 1].start() if i + 1 < len(matches) else len(text)
+        phases[name] = text[start:end].strip()
+    return phases
+
+
+def _parse_phase(text: str, phase: str) -> DiagnosisResult | OptionsResult | DecisionResult | ActionResult | ReviewResult:
+    items = _extract_list_items(text)
+    lower = text.lower()
+
+    if phase == "DIAGNOSE":
+        r = DiagnosisResult(raw_text=text, hypotheses=items[:10])
+        for line in text.split("\n"):
+            if any(kw in line.lower() for kw in ["assumption", "assuming"]):
+                r.assumptions.append(line.strip().lstrip("-*• "))
+            if any(kw in line.lower() for kw in ["unknown", "missing"]):
+                r.unknowns.append(line.strip().lstrip("-*• "))
+        return r
+
+    if phase == "OPTIONS":
+        r = OptionsResult(raw_text=text, alternatives=items)
+        for line in text.split("\n"):
+            if any(kw in line.lower() for kw in ["core tension", "fundamental trade-off"]):
+                r.core_tension = line.strip().lstrip("-*• :").strip()
+                break
+        return r
+
+    if phase == "DECIDE":
+        r = DecisionResult(raw_text=text)
+        paragraphs = [p.strip() for p in text.split("\n\n") if p.strip()]
+        if paragraphs:
+            r.recommendation = paragraphs[0]
+        for line in text.split("\n"):
+            if "confidence" in line.lower():
+                r.confidence = line.strip().lstrip("-*• :").strip()
+            if any(kw in line.lower() for kw in ["change my mind", "falsif"]):
+                r.falsifiability = line.strip().lstrip("-*• :").strip()
+        return r
+
+    if phase == "ACTION":
+        r = ActionResult(raw_text=text, steps=items)
+        for step in items:
+            sl = step.lower()
+            if any(kw in sl for kw in ["reversible", "can undo"]):
+                r.reversible_steps.append(step)
+            if any(kw in sl for kw in ["irreversible", "cannot undo", "permanent"]):
+                r.irreversible_steps.append(step)
+        return r
+
+    # REVIEW
+    r = ReviewResult(raw_text=text, failure_modes=items)
+    for line in text.split("\n"):
+        ll = line.lower()
+        if any(kw in ll for kw in ["assumption", "validate"]):
+            r.assumptions_to_validate.append(line.strip().lstrip("-*• "))
+        if any(kw in ll for kw in ["abandon", "abort", "pivot"]):
+            r.abort_conditions.append(line.strip().lstrip("-*• "))
+    return r
+
+
+def _parse_response(text: str) -> DODARResult:
+    result = DODARResult(text=text)
+    phases = _split_phases(text)
+    if "DIAGNOSE" in phases:
+        result.diagnosis = _parse_phase(phases["DIAGNOSE"], "DIAGNOSE")  # type: ignore
+    if "OPTIONS" in phases:
+        result.options = _parse_phase(phases["OPTIONS"], "OPTIONS")  # type: ignore
+    if "DECIDE" in phases:
+        result.decision = _parse_phase(phases["DECIDE"], "DECIDE")  # type: ignore
+    if "ACTION" in phases:
+        result.action = _parse_phase(phases["ACTION"], "ACTION")  # type: ignore
+    if "REVIEW" in phases:
+        result.review = _parse_phase(phases["REVIEW"], "REVIEW")  # type: ignore
+    return result
+
+
+# --------------------------------------------------------------------------- #
+# Main class
+# --------------------------------------------------------------------------- #
+
+Mode = Literal["dodar", "pipeline", "zero_shot", "cot"]
+
+
+class DODAR:
+    """DODAR structured reasoning framework for AI agents.
+
+    Args:
+        model: Model ID (e.g., "gpt-4.1-mini", "claude-sonnet-4-5").
+        mode: Default mode — "dodar" (single prompt), "pipeline" (5 calls),
+              "zero_shot", or "cot".
+        max_tokens: Maximum tokens per model call.
+
+    Example::
+
+        dodar = DODAR(model="gpt-4.1-mini")
+        result = dodar.analyze("Your scenario...")
+        print(result.diagnosis.hypotheses)
+    """
+
+    def __init__(
+        self,
+        model: str = "gpt-4.1-mini",
+        mode: Mode = "dodar",
+        max_tokens: int = 4096,
+    ) -> None:
+        self._model = model
+        self._default_mode = mode
+        self._max_tokens = max_tokens
+
+    @property
+    def model(self) -> str:
+        return self._model
+
+    def analyze(self, scenario: str, mode: Mode | None = None) -> DODARResult:
+        """Analyze a scenario synchronously.
+
+        Args:
+            scenario: The scenario text to analyze.
+            mode: Override the default mode for this call.
+
+        Returns:
+            DODARResult with structured phase access.
+        """
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            loop = None
+
+        if loop and loop.is_running():
+            import concurrent.futures
+            with concurrent.futures.ThreadPoolExecutor() as pool:
+                return pool.submit(
+                    asyncio.run, self.analyze_async(scenario, mode)
+                ).result()
+        return asyncio.run(self.analyze_async(scenario, mode))
+
+    async def analyze_async(self, scenario: str, mode: Mode | None = None) -> DODARResult:
+        """Analyze a scenario asynchronously."""
+        m = mode or self._default_mode
+
+        if m == "pipeline":
+            return await self._run_pipeline(scenario)
+
+        prompt = self._build_prompt(scenario, m)
+        response = await run_model(self._model, prompt, max_tokens=self._max_tokens)
+
+        if m == "dodar":
+            result = _parse_response(response.text)
+        else:
+            result = DODARResult(text=response.text)
+
+        result.input_tokens = response.input_tokens
+        result.output_tokens = response.output_tokens
+        result.latency_seconds = response.latency_seconds
+        result.model = self._model
+        result.mode = m
+        return result
+
+    async def _run_pipeline(self, scenario: str) -> DODARResult:
+        """Run the 5-phase DODAR pipeline."""
+        total_input = 0
+        total_output = 0
+        t0 = __import__("time").monotonic()
+        context_parts: list[str] = []
+
+        # Phase 1: Diagnose
+        r1 = await run_model(
+            self._model,
+            PIPELINE_DIAGNOSE.format(scenario=scenario),
+            max_tokens=self._max_tokens,
+        )
+        total_input += r1.input_tokens
+        total_output += r1.output_tokens
+        context_parts.append(f"## DIAGNOSE\n{r1.text}")
+
+        # Phase 2: Options
+        r2 = await run_model(
+            self._model,
+            PIPELINE_OPTIONS.format(scenario=scenario, prior_context="\n\n".join(context_parts)),
+            max_tokens=self._max_tokens,
+        )
+        total_input += r2.input_tokens
+        total_output += r2.output_tokens
+        context_parts.append(f"## OPTIONS\n{r2.text}")
+
+        # Phase 3: Decide
+        r3 = await run_model(
+            self._model,
+            PIPELINE_DECIDE.format(scenario=scenario, prior_context="\n\n".join(context_parts)),
+            max_tokens=self._max_tokens,
+        )
+        total_input += r3.input_tokens
+        total_output += r3.output_tokens
+        context_parts.append(f"## DECIDE\n{r3.text}")
+
+        # Phase 4: Action
+        r4 = await run_model(
+            self._model,
+            PIPELINE_ACTION.format(scenario=scenario, prior_context="\n\n".join(context_parts)),
+            max_tokens=self._max_tokens,
+        )
+        total_input += r4.input_tokens
+        total_output += r4.output_tokens
+        context_parts.append(f"## ACTION\n{r4.text}")
+
+        # Phase 5: Review
+        r5 = await run_model(
+            self._model,
+            PIPELINE_REVIEW.format(scenario=scenario, prior_context="\n\n".join(context_parts)),
+            max_tokens=self._max_tokens,
+        )
+        total_input += r5.input_tokens
+        total_output += r5.output_tokens
+        context_parts.append(f"## REVIEW\n{r5.text}")
+
+        full_text = "\n\n".join(context_parts)
+        result = _parse_response(full_text)
+        result.input_tokens = total_input
+        result.output_tokens = total_output
+        result.latency_seconds = __import__("time").monotonic() - t0
+        result.model = self._model
+        result.mode = "pipeline"
+        return result
+
+    def _build_prompt(self, scenario: str, mode: Mode) -> str:
+        match mode:
+            case "dodar":
+                return DODAR_SINGLE.format(scenario=scenario)
+            case "zero_shot":
+                return ZERO_SHOT.format(scenario=scenario)
+            case "cot":
+                return COT.format(scenario=scenario)
+            case _:
+                raise ValueError(f"Unknown mode: {mode}")
+
+    def __repr__(self) -> str:
+        return f"DODAR(model={self._model!r}, mode={self._default_mode!r})"

dodar-0.1.0/src/dodar/prompts.py

@@ -0,0 +1,159 @@
+"""Prompt templates for DODAR framework."""
+
+ZERO_SHOT = """\
+You are an expert analyst. Please analyze the following scenario and provide \
+your best response.
+
+{scenario}
+"""
+
+COT = """\
+You are an expert analyst. Please analyze the following scenario step by step. \
+Think through the problem carefully, showing your reasoning at each stage \
+before reaching your conclusions.
+
+{scenario}
+"""
+
+DODAR_SINGLE = """\
+You are an expert analyst using the DODAR structured reasoning framework. \
+Analyze the following scenario by working through ALL FIVE phases explicitly. \
+Each phase is a cognitive gate — do not skip or combine phases.
+
+## Phase 1: DIAGNOSE
+- List at least 3 competing hypotheses for what is happening
+- Challenge your first instinct — what would a contrarian view say?
+- Surface any latent assumptions you are making
+- Identify paradoxes or contradictions in the information
+- Map the unknowns — what information would change your diagnosis?
+- Consider polycontribution — could multiple causes be interacting?
+
+## Phase 2: OPTIONS
+- Generate at least 4 genuinely distinct options (not minor variations)
+- Name the core tension — the fundamental trade-off this decision hinges on
+- Identify different types of risk for each option (financial, reputational, technical, etc.)
+- Test your assumptions — what must be true for each option to work?
+- Quantify opportunity costs — what do you give up with each choice?
+- Consider hidden stakeholders and constraints
+
+## Phase 3: DECIDE
+- Make a clear recommendation
+- Justify your choice explicitly against each alternative you rejected
+- Identify the binding constraints that shaped this decision
+- Reframe the time horizon — is this optimised for the right timeframe?
+- Quantify the opportunity cost of your chosen path
+- State your confidence level and what would change your mind (falsifiability)
+
+## Phase 4: ACTION
+- Define specific, concrete implementation steps
+- Identify dependencies between steps
+- Specify timeline and resource requirements
+- Identify blockers and prerequisites
+- Mark which actions are reversible vs. irreversible
+
+## Phase 5: REVIEW
+- Identify at least 3 specific failure modes/risks, each with:
+  (a) trigger condition, (b) detection method, (c) contingency response
+- List assumptions from earlier phases that need validation
+- Define conditions under which you would abandon this plan entirely
+
+SCENARIO:
+{scenario}
+
+Work through each phase systematically. Label each phase clearly.
+"""
+
+PIPELINE_DIAGNOSE = """\
+You are a diagnostic reasoning specialist. Your role is to hold diagnosis OPEN \
+and resist premature closure.
+
+Analyze the following scenario. Do NOT recommend solutions yet — focus only on \
+understanding what is happening.
+
+1. List at least 3 competing hypotheses for what is happening
+2. Challenge your first instinct — what would a contrarian view say?
+3. Surface any latent assumptions
+4. Identify paradoxes or contradictions
+5. Map the unknowns — what information would change the diagnosis?
+6. Consider polycontribution — could multiple causes interact?
+
+SCENARIO:
+{scenario}
+"""
+
+PIPELINE_OPTIONS = """\
+You are a strategic options analyst. Your role is to enumerate genuinely \
+distinct alternatives with explicit trade-offs.
+
+Given the scenario and the diagnosis below, generate options. Do NOT decide yet.
+
+1. Generate at least 4 genuinely distinct options (not minor variations)
+2. Name the core tension — the fundamental trade-off
+3. Separate different types of risk for each option
+4. Quantify opportunity costs for each path
+5. Identify hidden stakeholders and constraints
+
+SCENARIO:
+{scenario}
+
+DIAGNOSIS (from prior phase):
+{prior_context}
+"""
+
+PIPELINE_DECIDE = """\
+You are a decision architect. Your role is to commit to a recommendation \
+with transparent, falsifiable reasoning.
+
+Given the scenario, diagnosis, and options below, make the call.
+
+1. Make a clear recommendation
+2. Justify against each rejected alternative specifically
+3. Identify binding constraints that shaped this decision
+4. State your confidence level
+5. State what would change your mind (falsifiability)
+6. Quantify the opportunity cost of your chosen path
+
+SCENARIO:
+{scenario}
+
+PRIOR ANALYSIS:
+{prior_context}
+"""
+
+PIPELINE_ACTION = """\
+You are an implementation planning specialist. Your role is to translate \
+decisions into concrete, sequenced action plans.
+
+Given the scenario and the decision below, create the action plan.
+
+1. Define specific, concrete implementation steps
+2. Identify dependencies between steps
+3. Specify timeline and resource requirements
+4. Identify blockers and prerequisites
+5. Mark which actions are reversible vs. irreversible
+
+SCENARIO:
+{scenario}
+
+PRIOR ANALYSIS:
+{prior_context}
+"""
+
+PIPELINE_REVIEW = """\
+You are a critical review analyst. Your role is to identify failure modes \
+and validate assumptions. Be adversarial — find the weaknesses.
+
+Given the full analysis below, conduct the review.
+
+1. Identify at least 3 specific failure modes, each with:
+   (a) trigger condition, (b) detection method, (c) contingency response
+2. Audit assumptions from earlier phases — are they still valid?
+3. Define conditions for abandoning this plan entirely
+4. What would you monitor to detect early warning signs?
+
+SCENARIO:
+{scenario}
+
+FULL ANALYSIS:
+{prior_context}
+"""

dodar-0.1.0/src/dodar/runners.py

@@ -0,0 +1,156 @@
+"""Model runners for DODAR — thin wrappers around provider SDKs."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Literal
+import time
+
+
+@dataclass
+class RunnerResponse:
+    text: str
+    input_tokens: int = 0
+    output_tokens: int = 0
+    latency_seconds: float = 0.0
+
+
+def _detect_provider(model: str) -> str:
+    if model.startswith("claude"):
+        return "anthropic"
+    elif model.startswith(("gpt-", "o1", "o3", "o4")):
+        return "openai"
+    elif model.startswith("gemini"):
+        return "google"
+    else:
+        return "ollama"
+
+
+# ---- Anthropic ---- #
+
+async def _run_anthropic(model: str, prompt: str, system: str | None = None, max_tokens: int = 4096) -> RunnerResponse:
+    import anthropic
+    client = anthropic.AsyncAnthropic()
+    messages = [{"role": "user", "content": prompt}]
+    kwargs: dict = {"model": model, "messages": messages, "max_tokens": max_tokens}
+    if system:
+        kwargs["system"] = system
+
+    t0 = time.monotonic()
+    response = await client.messages.create(**kwargs)
+    latency = time.monotonic() - t0
+
+    return RunnerResponse(
+        text=response.content[0].text,
+        input_tokens=response.usage.input_tokens,
+        output_tokens=response.usage.output_tokens,
+        latency_seconds=latency,
+    )
+
+
+# ---- OpenAI ---- #
+
+async def _run_openai(model: str, prompt: str, system: str | None = None, max_tokens: int = 4096) -> RunnerResponse:
+    import openai
+    client = openai.AsyncOpenAI()
+    messages = []
+    if system:
+        messages.append({"role": "system", "content": system})
+    messages.append({"role": "user", "content": prompt})
+
+    # Newer models use max_completion_tokens
+    use_new_param = model.startswith(("gpt-5", "o3", "o4"))
+    kwargs: dict = {"model": model, "messages": messages}
+    if use_new_param:
+        kwargs["max_completion_tokens"] = max_tokens
+    else:
+        kwargs["max_tokens"] = max_tokens
+
+    t0 = time.monotonic()
+    response = await client.chat.completions.create(**kwargs)
+    latency = time.monotonic() - t0
+
+    usage = response.usage
+    return RunnerResponse(
+        text=response.choices[0].message.content or "",
+        input_tokens=usage.prompt_tokens if usage else 0,
+        output_tokens=usage.completion_tokens if usage else 0,
+        latency_seconds=latency,
+    )
+
+
+# ---- Google ---- #
+
+async def _run_google(model: str, prompt: str, system: str | None = None, max_tokens: int = 4096) -> RunnerResponse:
+    from google import genai
+    client = genai.Client()
+    full_prompt = f"{system}\n\n{prompt}" if system else prompt
+
+    t0 = time.monotonic()
+    response = await client.aio.models.generate_content(
+        model=model,
+        contents=full_prompt,
+    )
+    latency = time.monotonic() - t0
+
+    return RunnerResponse(
+        text=response.text or "",
+        latency_seconds=latency,
+    )
+
+
+# ---- Ollama ---- #
+
+async def _run_ollama(model: str, prompt: str, system: str | None = None, max_tokens: int = 4096) -> RunnerResponse:
+    import httpx
+    messages = []
+    if system:
+        messages.append({"role": "system", "content": system})
+    messages.append({"role": "user", "content": prompt})
+
+    t0 = time.monotonic()
+    async with httpx.AsyncClient(timeout=600) as client:
+        resp = await client.post(
+            "http://localhost:11434/api/chat",
+            json={"model": model, "messages": messages, "stream": False},
+        )
+        resp.raise_for_status()
+        data = resp.json()
+    latency = time.monotonic() - t0
+
+    return RunnerResponse(
+        text=data.get("message", {}).get("content", ""),
+        input_tokens=data.get("prompt_eval_count", 0),
+        output_tokens=data.get("eval_count", 0),
+        latency_seconds=latency,
+    )
+
+
+# ---- Registry ---- #
+
+_MODELS = {
+    "claude-opus-4-6", "claude-sonnet-4-5", "claude-haiku-4-5",
+    "gpt-5.4", "gpt-4o", "gpt-4o-mini", "gpt-4.1-mini", "gpt-4.1-nano",
+    "gemini-2.0-flash",
+}
+
+
+def available_models() -> list[str]:
+    """List all known model IDs."""
+    return sorted(_MODELS)
+
+
+async def run_model(model: str, prompt: str, system: str | None = None, max_tokens: int = 4096) -> RunnerResponse:
+    """Run a prompt against any supported model."""
+    provider = _detect_provider(model)
+    match provider:
+        case "anthropic":
+            return await _run_anthropic(model, prompt, system, max_tokens)
+        case "openai":
+            return await _run_openai(model, prompt, system, max_tokens)
+        case "google":
+            return await _run_google(model, prompt, system, max_tokens)
+        case "ollama":
+            return await _run_ollama(model, prompt, system, max_tokens)
+        case _:
+            raise ValueError(f"Unknown provider for model: {model}")