agileforagents 0.3.0__tar.gz

agileforagents-0.3.0/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: agileforagents
+Version: 0.3.0
+Summary: Zero-config MCP server that turns prompts into verified agile task boards for AI coding agents
+License: MIT
+Project-URL: Homepage, https://github.com/FAJU85/AgileForAgents
+Project-URL: Repository, https://github.com/FAJU85/AgileForAgents
+Project-URL: Issues, https://github.com/FAJU85/AgileForAgents/issues
+Keywords: mcp,agile,ai-agents,claude-code,cursor,codex
+Classifier: Development Status :: 4 - Beta
+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 :: Software Development :: Build Tools
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: mcp>=1.9.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=5.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23.0; extra == "dev"
+Requires-Dist: ruff>=0.4.0; extra == "dev"
+Requires-Dist: mypy>=1.10.0; extra == "dev"
+Requires-Dist: pip-audit>=2.7.0; extra == "dev"
+
+# AgileForAgents
+
+**Turn any project prompt into a verified, sprint-ready agile task board — right inside your AI coding agent.**
+
+AgileForAgents is a zero-config [MCP](https://modelcontextprotocol.io) server for
+Claude Code, Cursor, Codex CLI, and any MCP-compatible host. You describe a project
+in your IDE as you normally would; AgileForAgents turns it into a structured agile
+board (epics → sprints → user stories → subtasks) where **every subtask has an
+observable done-criteria** and **every assumption is made explicit** — following
+Andrej Karpathy's Spec methodology.
+
+## How it works
+
+```
+┌──────────────────────────┐   stdio    ┌────────────────────────┐   HTTPS    ┌──────────────────────────────┐
+│  Your IDE                │◀──────────▶│  agileforagents        │───────────▶│  Hosted backend (HF Space)   │
+│  Claude Code / Cursor /  │  MCP tool  │  MCP server            │  /api/     │  • runs a free HF model       │
+│  Codex — you type here   │  call      │  (stdlib-only client)  │  generate  │  • holds the token server-side│
+└──────────────────────────┘            └────────────────────────┘◀───────────│  • returns a verified board   │
+                                                                                └───────────────┬──────────────┘
+                                                                                                │ logs metrics
+                                                                                                ▼
+                                                                                  ┌──────────────────────────┐
+                                                                                  │  Gradio Control Panel     │
+                                                                                  │  (monitoring dashboard,   │
+                                                                                  │   no prompt input)        │
+                                                                                  └──────────────────────────┘
+```
+
+- **You never leave your IDE.** Prompts come from your editor through the MCP tool —
+  not from a web form.
+- **No API key, no token, no heavy dependencies.** The MCP server installs with just
+  the MCP SDK + pydantic. All model inference happens on the hosted backend, which
+  holds the Hugging Face token as a server-side secret.
+- **The Gradio Space is a control panel**, not an input form — it shows how the
+  generator is performing (volume, average verification score, recent activity).
+- **Works offline, degraded.** If the backend is unreachable, a local heuristic
+  fallback still returns a valid scaffold board so the tool never hard-fails.
+
+## Install
+
+```bash
+pip install agileforagents
+```
+
+Then register the `agileforagents` stdio server with your MCP host.
+
+**Claude Code** (`~/.claude/mcp.json` or project `.mcp.json`):
+
+```json
+{
+  "mcpServers": {
+    "agileforagents": {
+      "command": "agileforagents"
+    }
+  }
+}
+```
+
+**Cursor / Codex CLI:** point your MCP config at the `agileforagents` command. No
+environment variables are required.
+
+## Tools
+
+| Tool | What it does |
+|---|---|
+| `generate_agile_tasks` | Turn a prompt into a verified agile board. Args: `prompt`, `format` (`claude` \| `json` \| `cursor`), `detail_level` (`standard` \| `detailed`). |
+| `get_agent_rules` | Return the AgileForAgents working protocol to paste into `CLAUDE.md` / `.cursorrules`. |
+| `feedback_stats` | Local generation count + backend health. |
+
+## Configuration (optional)
+
+The MCP server works with no configuration. For self-hosting or testing you can override:
+
+| Env var | Purpose | Default |
+|---|---|---|
+| `AFA_BACKEND_URL` | Hosted backend base URL | `https://vooom-agileforagents.hf.space` |
+| `AFA_BACKEND_TIMEOUT` | Request timeout (seconds) | `120` |
+
+## Repository layout
+
+| Path | Purpose |
+|---|---|
+| `src/agileforagents/` | The installable stdio MCP server (thin client + formatters + fallback). |
+| `space/` | The Hugging Face Space: FastAPI inference backend + Gradio monitoring dashboard. |
+| `tests/` | Unit + E2E tests. |
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+make format-check && make lint && make typecheck && make test
+```
+
+## License
+
+MIT

agileforagents-0.3.0/README.md

@@ -0,0 +1,97 @@
+# AgileForAgents
+
+**Turn any project prompt into a verified, sprint-ready agile task board — right inside your AI coding agent.**
+
+AgileForAgents is a zero-config [MCP](https://modelcontextprotocol.io) server for
+Claude Code, Cursor, Codex CLI, and any MCP-compatible host. You describe a project
+in your IDE as you normally would; AgileForAgents turns it into a structured agile
+board (epics → sprints → user stories → subtasks) where **every subtask has an
+observable done-criteria** and **every assumption is made explicit** — following
+Andrej Karpathy's Spec methodology.
+
+## How it works
+
+```
+┌──────────────────────────┐   stdio    ┌────────────────────────┐   HTTPS    ┌──────────────────────────────┐
+│  Your IDE                │◀──────────▶│  agileforagents        │───────────▶│  Hosted backend (HF Space)   │
+│  Claude Code / Cursor /  │  MCP tool  │  MCP server            │  /api/     │  • runs a free HF model       │
+│  Codex — you type here   │  call      │  (stdlib-only client)  │  generate  │  • holds the token server-side│
+└──────────────────────────┘            └────────────────────────┘◀───────────│  • returns a verified board   │
+                                                                                └───────────────┬──────────────┘
+                                                                                                │ logs metrics
+                                                                                                ▼
+                                                                                  ┌──────────────────────────┐
+                                                                                  │  Gradio Control Panel     │
+                                                                                  │  (monitoring dashboard,   │
+                                                                                  │   no prompt input)        │
+                                                                                  └──────────────────────────┘
+```
+
+- **You never leave your IDE.** Prompts come from your editor through the MCP tool —
+  not from a web form.
+- **No API key, no token, no heavy dependencies.** The MCP server installs with just
+  the MCP SDK + pydantic. All model inference happens on the hosted backend, which
+  holds the Hugging Face token as a server-side secret.
+- **The Gradio Space is a control panel**, not an input form — it shows how the
+  generator is performing (volume, average verification score, recent activity).
+- **Works offline, degraded.** If the backend is unreachable, a local heuristic
+  fallback still returns a valid scaffold board so the tool never hard-fails.
+
+## Install
+
+```bash
+pip install agileforagents
+```
+
+Then register the `agileforagents` stdio server with your MCP host.
+
+**Claude Code** (`~/.claude/mcp.json` or project `.mcp.json`):
+
+```json
+{
+  "mcpServers": {
+    "agileforagents": {
+      "command": "agileforagents"
+    }
+  }
+}
+```
+
+**Cursor / Codex CLI:** point your MCP config at the `agileforagents` command. No
+environment variables are required.
+
+## Tools
+
+| Tool | What it does |
+|---|---|
+| `generate_agile_tasks` | Turn a prompt into a verified agile board. Args: `prompt`, `format` (`claude` \| `json` \| `cursor`), `detail_level` (`standard` \| `detailed`). |
+| `get_agent_rules` | Return the AgileForAgents working protocol to paste into `CLAUDE.md` / `.cursorrules`. |
+| `feedback_stats` | Local generation count + backend health. |
+
+## Configuration (optional)
+
+The MCP server works with no configuration. For self-hosting or testing you can override:
+
+| Env var | Purpose | Default |
+|---|---|---|
+| `AFA_BACKEND_URL` | Hosted backend base URL | `https://vooom-agileforagents.hf.space` |
+| `AFA_BACKEND_TIMEOUT` | Request timeout (seconds) | `120` |
+
+## Repository layout
+
+| Path | Purpose |
+|---|---|
+| `src/agileforagents/` | The installable stdio MCP server (thin client + formatters + fallback). |
+| `space/` | The Hugging Face Space: FastAPI inference backend + Gradio monitoring dashboard. |
+| `tests/` | Unit + E2E tests. |
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+make format-check && make lint && make typecheck && make test
+```
+
+## License
+
+MIT

agileforagents-0.3.0/pyproject.toml

@@ -0,0 +1,92 @@
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "agileforagents"
+version = "0.3.0"
+description = "Zero-config MCP server that turns prompts into verified agile task boards for AI coding agents"
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "MIT" }
+keywords = ["mcp", "agile", "ai-agents", "claude-code", "cursor", "codex"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Build Tools",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+# The installable MCP server is intentionally dependency-light: only the MCP SDK
+# and pydantic. All LLM work happens on the hosted backend (a Hugging Face Space),
+# reached over the standard library, so users need no API keys or heavy ML deps.
+dependencies = [
+    "mcp>=1.9.0",
+    "pydantic>=2.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/FAJU85/AgileForAgents"
+Repository = "https://github.com/FAJU85/AgileForAgents"
+Issues = "https://github.com/FAJU85/AgileForAgents/issues"
+
+[project.scripts]
+agileforagents = "agileforagents.server:main"
+agile-for-agents = "agileforagents.server:main"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-cov>=5.0.0",
+    "pytest-asyncio>=0.23.0",
+    "ruff>=0.4.0",
+    "mypy>=1.10.0",
+    "pip-audit>=2.7.0",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+asyncio_mode = "auto"
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "N", "UP", "B", "T20"]
+# T20 catches print() statements in production code per policy
+ignore = []
+
+[tool.mypy]
+python_version = "3.11"
+strict = true
+ignore_missing_imports = true
+files = ["src/"]
+
+# ── third-party without stubs ────────────────────────────────────────────────
+[[tool.mypy.overrides]]
+module = [
+    "mcp", "mcp.*",
+    "pydantic", "pydantic.*",
+]
+ignore_errors = true
+
+[[tool.mypy.overrides]]
+module = ["agileforagents.models"]
+disable_error_code = ["misc"]
+
+# The mcp SDK's @app.list_tools() / @app.call_tool() decorators are untyped, and
+# which error code mypy emits for them ("untyped-decorator" vs "no-untyped-call")
+# varies by installed mcp version. Disable both here so the gate is deterministic
+# across environments, and turn off unused-ignore warnings for this module.
+[[tool.mypy.overrides]]
+module = ["agileforagents.server"]
+disable_error_code = ["untyped-decorator", "no-untyped-call", "misc"]
+warn_unused_ignores = false

agileforagents-0.3.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

agileforagents-0.3.0/src/agileforagents/__init__.py

@@ -0,0 +1,3 @@
+"""AgileForAgents: Verified agile task generation via Karpathy's three-layer methodology."""
+
+__version__ = "0.1.0"

agileforagents-0.3.0/src/agileforagents/backend_client.py

@@ -0,0 +1,63 @@
+"""Backend client — talks to the hosted AgileForAgents inference service.
+
+Uses only the Python standard library (``urllib``) so the MCP server installs
+with zero heavy dependencies. The hosted backend (a Hugging Face Space) holds
+the model token server-side, so the end user never supplies any credentials.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import urllib.error
+import urllib.request
+from typing import Any
+
+# Public Hugging Face Space backend. Overridable for self-hosting / testing.
+DEFAULT_BACKEND_URL = "https://vooom-agileforagents.hf.space"
+BACKEND_URL = os.getenv("AFA_BACKEND_URL", DEFAULT_BACKEND_URL).rstrip("/")
+
+# The backend can be slow on a cold start (model spin-up), so allow generous time.
+REQUEST_TIMEOUT_SECONDS = float(os.getenv("AFA_BACKEND_TIMEOUT", "120"))
+
+
+class BackendError(RuntimeError):
+    """Raised when the hosted backend is unreachable or returns an error."""
+
+
+def generate_board(prompt: str, detail_level: str = "standard") -> dict[str, Any]:
+    """POST a prompt to the backend and return ``{"board": ..., "verification": ...}``.
+
+    Raises :class:`BackendError` on any network or protocol failure so the caller
+    can fall back to local generation.
+    """
+    payload = json.dumps({"prompt": prompt, "detail_level": detail_level}).encode("utf-8")
+    request = urllib.request.Request(
+        f"{BACKEND_URL}/api/generate",
+        data=payload,
+        headers={"Content-Type": "application/json", "Accept": "application/json"},
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(request, timeout=REQUEST_TIMEOUT_SECONDS) as response:
+            body = response.read().decode("utf-8")
+    except (urllib.error.URLError, urllib.error.HTTPError, TimeoutError, OSError) as exc:
+        raise BackendError(f"Backend request failed: {exc}") from exc
+
+    try:
+        data: dict[str, Any] = json.loads(body)
+    except json.JSONDecodeError as exc:
+        raise BackendError(f"Backend returned invalid JSON: {exc}") from exc
+
+    if "board" not in data:
+        raise BackendError(f"Backend response missing 'board': {data}")
+    return data
+
+
+def health() -> bool:
+    """Return ``True`` if the backend health endpoint responds OK."""
+    try:
+        with urllib.request.urlopen(f"{BACKEND_URL}/health", timeout=10) as response:
+            return bool(response.status == 200)
+    except (urllib.error.URLError, urllib.error.HTTPError, TimeoutError, OSError):
+        return False

agileforagents-0.3.0/src/agileforagents/environment_layer.py

@@ -0,0 +1,115 @@
+"""Layer 3 — Environment Layer: Formats output and injects agent guardrails."""
+
+import json
+
+from .models import AgileTaskBoard, VerificationResult
+from .prompts import ENVIRONMENT_RULES
+
+
+class EnvironmentLayer:
+    """Adapts the verified AgileTaskBoard for different agent environments."""
+
+    SUPPORTED_FORMATS = ("claude", "json", "cursor")
+
+    def format(
+        self,
+        board: AgileTaskBoard,
+        verification: VerificationResult,
+        output_format: str = "claude",
+    ) -> str:
+        if output_format not in self.SUPPORTED_FORMATS:
+            raise ValueError(
+                f"Unknown format '{output_format}'. Choose from: {self.SUPPORTED_FORMATS}"
+            )
+
+        if output_format == "json":
+            return self._format_json(board, verification)
+        if output_format == "cursor":
+            return self._format_cursor(board)
+        return self._format_claude(board, verification)
+
+    # ------------------------------------------------------------------
+    # Private formatters
+    # ------------------------------------------------------------------
+
+    def _format_claude(self, board: AgileTaskBoard, verification: VerificationResult) -> str:
+        lines = [ENVIRONMENT_RULES]
+
+        lines.append(f"## Project Goal\n{board.project_goal}\n")
+        lines.append(f"## Tech Stack\n{', '.join(board.tech_stack)}\n")
+
+        lines.append("## Assumptions")
+        for a in board.assumptions:
+            lines.append(f"- {a}")
+        lines.append("")
+
+        lines.append("## Epics")
+        for e in board.epics:
+            lines.append(f"- {e}")
+        lines.append("")
+
+        for sprint in board.sprints:
+            lines.append(f"## Sprint {sprint.number}: {sprint.goal}")
+            lines.append(f"**Done when:** {sprint.done_criteria}\n")
+
+            for story in sprint.user_stories:
+                lines.append(f"### {story.id} — {story.title} ({story.story_points} pts)")
+                lines.append(
+                    f"As a **{story.as_a}**, I want **{story.i_want}** "
+                    f"so that **{story.so_that}**.\n"
+                )
+                lines.append("**Acceptance Criteria:**")
+                for ac in story.acceptance_criteria:
+                    lines.append(f"- {ac}")
+                lines.append("")
+                lines.append("**Subtasks:**")
+                for st in story.subtasks:
+                    lines.append(f"- [ ] `{st.id}` {st.title} ({st.estimated_hours}h)")
+                    lines.append(f"  - {st.description}")
+                    lines.append(f"  - **Done when:** {st.done_criteria}")
+                lines.append("")
+
+        lines.append("---")
+        lines.append(
+            f"*Verification score: {verification.score:.0%} — "
+            f"{'✓ Passed' if verification.passed else '⚠ Partial'}*"
+        )
+
+        return "\n".join(lines)
+
+    def _format_json(self, board: AgileTaskBoard, verification: VerificationResult) -> str:
+        return json.dumps(
+            {
+                "board": board.model_dump(),
+                "verification": verification.model_dump(),
+            },
+            indent=2,
+        )
+
+    def _format_cursor(self, board: AgileTaskBoard) -> str:
+        """Cursor Rules format: compact task list for .cursorrules injection."""
+        lines = [
+            "# Project: " + board.project_goal,
+            "",
+            "## Rules",
+            "- Complete one user story at a time before starting the next.",
+            "- Every subtask has a done_criteria — self-test against it before marking [x].",
+            "- State any new assumptions explicitly before acting on them.",
+            "",
+            "## Assumptions",
+        ]
+        for a in board.assumptions:
+            lines.append(f"- {a}")
+        lines.append("")
+
+        for sprint in board.sprints:
+            lines.append(f"## Sprint {sprint.number}: {sprint.goal}")
+            for story in sprint.user_stories:
+                lines.append(f"\n### {story.id}: {story.title}")
+                for st in story.subtasks:
+                    lines.append(f"- [ ] {st.id}: {st.title} | done: {st.done_criteria}")
+        return "\n".join(lines)
+
+    def get_rules_only(self) -> str:
+        """Returns the injected agent rules without any task content."""
+        return ENVIRONMENT_RULES.strip()

agileforagents-0.3.0/src/agileforagents/fallback.py

@@ -0,0 +1,156 @@
+"""Local fallback generator — used only when the hosted backend is unreachable.
+
+This is a deterministic, dependency-free heuristic decomposition. It is
+intentionally conservative: it produces a valid, well-structured AgileTaskBoard
+so the MCP tool never hard-fails, but it does not attempt LLM-quality planning.
+The hosted backend is always preferred when available.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from .models import AgileTaskBoard, Sprint, Subtask, UserStory, VerificationResult
+
+# Lightweight tech-stack detection so the fallback board reflects the prompt.
+_TECH_KEYWORDS = {
+    "python": "Python",
+    "fastapi": "FastAPI",
+    "django": "Django",
+    "flask": "Flask",
+    "react": "React",
+    "next": "Next.js",
+    "vue": "Vue",
+    "node": "Node.js",
+    "typescript": "TypeScript",
+    "postgres": "PostgreSQL",
+    "mysql": "MySQL",
+    "sqlite": "SQLite",
+    "mongo": "MongoDB",
+    "redis": "Redis",
+    "docker": "Docker",
+    "tailwind": "Tailwind CSS",
+}
+
+
+def _detect_tech_stack(prompt: str) -> list[str]:
+    lower = prompt.lower()
+    found = [label for key, label in _TECH_KEYWORDS.items() if key in lower]
+    return found or ["TBD — confirm with stakeholder"]
+
+
+def _first_sentence(prompt: str) -> str:
+    cleaned = prompt.strip().rstrip(".")
+    match = re.split(r"[.!?\n]", cleaned, maxsplit=1)
+    return match[0].strip() if match and match[0].strip() else cleaned
+
+
+def generate_board(prompt: str, detail_level: str = "standard") -> dict[str, Any]:
+    """Return ``{"board": ..., "verification": ...}`` matching the backend contract."""
+    goal = _first_sentence(prompt)
+    tech_stack = _detect_tech_stack(prompt)
+
+    board = AgileTaskBoard(
+        project_goal=f"Deliver: {goal}.",
+        tech_stack=tech_stack,
+        assumptions=[
+            "Generated locally (hosted backend was unreachable) — review before use.",
+            "Single small team; no external compliance constraints assumed.",
+            "Scope limited to a demonstrable MVP first.",
+        ],
+        epics=["Foundation & Setup", "Core Feature", "Polish & Ship"],
+        sprints=[
+            Sprint(
+                number=1,
+                goal="Stand up a runnable skeleton that proves the core idea.",
+                done_criteria="App boots locally and the primary happy path is demonstrable.",
+                user_stories=[
+                    UserStory(
+                        id="US-1",
+                        title="Project skeleton",
+                        as_a="developer",
+                        i_want="a runnable project skeleton with the chosen stack",
+                        so_that="feature work has a verified foundation",
+                        story_points=3,
+                        acceptance_criteria=[
+                            "Given the repo is cloned, when setup is run, then the app starts "
+                            "without errors.",
+                        ],
+                        subtasks=[
+                            Subtask(
+                                id="ST-1",
+                                title="Initialise project & dependencies",
+                                description="Scaffold the project structure and install deps.",
+                                done_criteria="The dev server / entry point runs and prints a "
+                                "startup message.",
+                                estimated_hours=2.0,
+                            ),
+                            Subtask(
+                                id="ST-2",
+                                title="Define the core data model",
+                                description="Model the central entity implied by the prompt.",
+                                done_criteria="The model is created and a smoke test reads/writes "
+                                "one record.",
+                                estimated_hours=3.0,
+                            ),
+                        ],
+                    )
+                ],
+            ),
+            Sprint(
+                number=2,
+                goal="Implement the primary user-facing capability end to end.",
+                done_criteria="A user can complete the main task the product exists to serve.",
+                user_stories=[
+                    UserStory(
+                        id="US-2",
+                        title="Core capability",
+                        as_a="end user",
+                        i_want="to accomplish the product's primary task",
+                        so_that="the product delivers its core value",
+                        story_points=5,
+                        acceptance_criteria=[
+                            "Given the app is running, when I perform the main action, then I see "
+                            "a correct, persisted result.",
+                        ],
+                        subtasks=[
+                            Subtask(
+                                id="ST-3",
+                                title="Implement core action endpoint/handler",
+                                description="Build the primary action path identified in the goal.",
+                                done_criteria="The action returns a successful result and persists "
+                                "state.",
+                                estimated_hours=4.0,
+                            ),
+                            Subtask(
+                                id="ST-4",
+                                title="Wire up the user interface / interface surface",
+                                description="Expose the core action to the user.",
+                                done_criteria="The action is reachable and usable from the "
+                                "interface.",
+                                estimated_hours=4.0,
+                            ),
+                        ],
+                    )
+                ],
+            ),
+        ],
+    )
+
+    verification = VerificationResult(
+        passed=False,
+        score=0.5,
+        issues=["Generated by the offline fallback — not LLM-verified."],
+        feedback=(
+            "This board was produced locally because the hosted backend was unreachable. "
+            "Treat it as a starting scaffold and refine the sprints for your specific project."
+        ),
+        suggested_fixes=["Retry once the backend is reachable for a fully verified board."],
+    )
+
+    return {
+        "board": board.model_dump(),
+        "verification": verification.model_dump(),
+        "source": "local-fallback",
+    }