codd-dev 2.10.0__tar.gz → 2.11.0__tar.gz

codd_dev-2.11.0/PKG-INFO

@@ -0,0 +1,205 @@
+Metadata-Version: 2.4
+Name: codd-dev
+Version: 2.11.0
+Summary: CoDD: Coherence-Driven Development — cross-artifact change impact analysis
+Project-URL: Homepage, https://github.com/yohey-w/codd-dev
+Project-URL: Repository, https://github.com/yohey-w/codd-dev
+Project-URL: Issues, https://github.com/yohey-w/codd-dev/issues
+Author-email: Yohei Watanabe <yohey-w@users.noreply.github.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: change-impact,claude-code,dependency-graph,plugin,software-engineering
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.10
+Requires-Dist: click>=8.0
+Requires-Dist: jinja2>=3.1.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: tomli>=2.0.1; python_version < '3.11'
+Requires-Dist: watchdog>=4.0.0
+Requires-Dist: websocket-client>=1.8.0
+Provides-Extra: ai
+Provides-Extra: api-parsers
+Requires-Dist: graphql-core>=3.2.0; extra == 'api-parsers'
+Provides-Extra: infra
+Requires-Dist: python-hcl2>=7.0.0; extra == 'infra'
+Provides-Extra: mcp
+Provides-Extra: scan
+Requires-Dist: tree-sitter-java>=0.22; extra == 'scan'
+Requires-Dist: tree-sitter-python>=0.22; extra == 'scan'
+Requires-Dist: tree-sitter-typescript>=0.22; extra == 'scan'
+Requires-Dist: tree-sitter>=0.22; extra == 'scan'
+Provides-Extra: tree-sitter
+Requires-Dist: tree-sitter-python<0.26.0,>=0.25.0; extra == 'tree-sitter'
+Requires-Dist: tree-sitter-typescript<0.24.0,>=0.23.0; extra == 'tree-sitter'
+Requires-Dist: tree-sitter<0.26.0,>=0.25.0; extra == 'tree-sitter'
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <strong>CoDD — Coherence-Driven Development</strong>
+</p>
+
+<p align="center">
+  <a href="https://pypi.org/project/codd-dev/"><img src="https://img.shields.io/pypi/v/codd-dev?style=flat-square&color=blue" alt="PyPI"></a>
+  <a href="https://pypi.org/project/codd-dev/"><img src="https://img.shields.io/pypi/pyversions/codd-dev?style=flat-square" alt="Python"></a>
+  <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-green?style=flat-square" alt="License"></a>
+  <a href="https://github.com/yohey-w/codd-dev/stargazers"><img src="https://img.shields.io/github/stars/yohey-w/codd-dev?style=flat-square" alt="Stars"></a>
+</p>
+
+<p align="center">
+  <a href="README_ja.md">日本語</a> | English | <a href="README_zh.md">中文</a>
+</p>
+
+---
+
+## 🚀 Get started in 60 seconds
+
+```bash
+pip install codd-dev
+
+# Inside your project root
+codd init --suggest-lexicons --llm-enhanced   # AI picks the lexicons that fit
+codd elicit                                    # AI finds gaps in your requirements
+codd dag verify --auto-repair --max-attempts 10  # AI fixes coherence violations
+```
+
+That's it. Three commands, three feedback loops, one coherent project.
+
+> Real-world: dogfooded against a Next.js + Prisma + PostgreSQL LMS. See [Case study](#-case-study-real-world-lms).
+
+---
+
+## ✨ What it does
+
+| Command | One-line summary |
+| --- | --- |
+| 🔍 **`codd elicit`** | LLM finds **specification holes** in your requirements, scoped against industry-standard lexicons (BABOK, OWASP, WCAG, PCI DSS, ISO 25010, …). |
+| 🔄 **`codd diff`** | Detects **drift** between requirements and the actual implementation (brownfield-friendly). |
+| 🛠️ **`codd dag verify --auto-repair`** | Validates the requirements → design → implementation → tests DAG; an LLM proposes patches when violations appear and the loop retries until SUCCESS or MAX_ATTEMPTS. |
+| 📦 **38 lexicon plug-ins** | Industry standards bundled as opt-in coverage axes — Web (WCAG / OWASP / Web Vitals / WebAuthn / forms / SEO / PWA / browser-compat / responsive), Mobile (HIG / Material 3 / a11y / MASVS), Backend (REST / GraphQL / gRPC / events), Data (SQL / JSON Schema / event sourcing / governance), Ops (CI/CD / Kubernetes / Terraform / observability / DORA), Compliance (ISO 27001 / HIPAA / PCI DSS / GDPR / EU AI Act), Process (ISO 25010 / 29119 / DDD / 12-factor / i18n / model cards / API rate-limit), and Methodology (BABOK). |
+| 🌐 **`codd brownfield`** | Extract → diff → elicit pipeline: point CoDD at an existing codebase and it reverse-engineers requirements, finds drift, and surfaces gaps in one shot. |
+| 🎯 **`codd init --suggest-lexicons --llm-enhanced`** | LLM reads your code/docs, identifies data types and function traits, and recommends which lexicons to install (with confidence + reasoning). |
+| 📊 **`codd lexicon list/install/diff` + `codd coverage report`** | Manage plug-ins and produce JSON / Markdown / self-contained HTML coverage matrices. |
+| 🛡️ CI gate | `.github/workflows/codd_coverage.yml` template + `codd coverage check` exit code make coverage regressions block merges. |
+
+---
+
+## 🎨 Visual flow
+
+```mermaid
+flowchart LR
+    R["Requirements (.md)"] --> E["codd elicit"]
+    E -->|gap findings| H{HITL: approve / reject}
+    H -->|[x]| L["project_lexicon.yaml + requirements TODOs"]
+    H -->|[r]| I["ignored_findings.yaml"]
+    L --> V["codd dag verify --auto-repair"]
+    V -->|violation| AR["LLM patch propose → apply"]
+    AR --> V
+    V -->|SUCCESS| D["✅ deploy gate passes"]
+    AR -->|max attempts| P["PARTIAL_SUCCESS: unrepairable surfaced honestly"]
+```
+
+Brownfield path:
+
+```mermaid
+flowchart LR
+    Code["Existing codebase"] --> X["codd extract"]
+    X --> DIFF["codd diff (drift)"]
+    DIFF --> EL["codd elicit (coverage gaps)"]
+    EL --> H{HITL gate}
+    H --> Apply["codd elicit apply"]
+    Apply --> V["codd dag verify"]
+```
+
+---
+
+## 📊 Case study: real-world LMS
+
+A Next.js + Prisma + PostgreSQL multi-tenant LMS (≈30 design docs, 12 DB tables, RLS-enforced isolation):
+
+| Stage | Result |
+| --- | --- |
+| `codd init --suggest-lexicons --llm-enhanced` | LLM detected **data types** (PII / payment / video) and **function traits** (auth / payment / public REST), recommended 15 lexicons, 9 of which the human had already chosen — confirming the heuristic. |
+| `codd elicit` (10 lexicons loaded, scope=`system_implementation`, phase=`mvp`) | **70 findings** across web a11y / data governance / SQL / security / Web Vitals / WebAuthn / API / process. Business-tier dimensions (KPI, UAT detail, risk register) auto-filtered out. |
+| `codd dag verify --auto-repair` | Started with 16 unrepairable violations; through targeted core fixes (deployment chain auto-discovery, runtime-state auto-binding, mock harness no-op, scope/phase filter) the same project now reaches **PASS or amber-WARN** with deploy allowed. |
+| VPS smoke (`/`, `/login`, `/api/health`) | All 3 endpoints **200 OK**. |
+
+The full pipeline change is **zero lines of CoDD core changes per project** — every project-specific concern lives in `project_lexicon.yaml` or in `codd_plugins/` (Generality Gate, Layer A / B / C).
+
+---
+
+## 🌟 Why CoDD exists
+
+> **"Write only functional requirements and constraints. Code is generated, repaired, and verified automatically."**
+
+Most "AI-assisted dev" tools focus on the **generation** side. CoDD focuses on the **constraint** side: the LLM is most useful when it has a precise picture of what *must* be true. CoDD provides that picture as a DAG that links every artifact, plus a plug-in surface that lets industry standards (BABOK / WCAG / OWASP / PCI / ISO …) supply the constraints mechanically.
+
+When something breaks the DAG, an LLM proposes a patch, the loop re-verifies, and either reaches SUCCESS or surfaces what is structurally unrepairable — honestly.
+
+### Generality Gate (three-layer architecture)
+
+| Layer | Where stack-specific names live | Examples |
+| --- | --- | --- |
+| **A — Core** | **Nowhere.** Zero `react`, `django`, `Stripe`, `LMS` literals. | `codd/elicit/`, `codd/dag/`, `codd/lexicon_cli/` |
+| **B — Templates** | Generic placeholders only. | `codd/templates/*.j2`, `codd/templates/lexicon_schema.yaml` |
+| **C — Plug-ins** | Free to name anything. | `codd_plugins/lexicons/*/`, `codd_plugins/stack_map.yaml` |
+
+This is what lets CoDD ship one core that works for Next.js, Django, FastAPI, Rails, Go services, mobile apps, ML model cards — and that lets contributors add a lexicon without touching the core.
+
+---
+
+## 🧭 Roadmap
+
+- **v2.10.0 (current)** — Lexicon-driven completeness, 38 plug-ins, LLM-enhanced init, scope/phase filter, auto-repair across the full DAG.
+- **v2.11.0 (next)** — Sprint-less `codd implement` (`--design <path> --output <dir>` directly; `implementation_plan.md` parser removed). See [migration guide](docs/migrations/v2.11.0-sprintless.md).
+
+---
+
+## 🤝 Contributing
+
+CoDD is shaped by the following people:
+
+- **[@yohey-w](https://github.com/yohey-w)** — Maintainer / Architect
+- **[@Seika86](https://github.com/Seika86)** — Sprint regex insight (PR #11)
+- **[@v-kato](https://github.com/v-kato)** — Brownfield reproduction reports (Issues #17 / #18 / #19)
+- **[@dev-komenzar](https://github.com/dev-komenzar)** — `source_dirs` bug reproduction (Issue #13)
+
+External issues, PRs, and lexicon proposals are welcome — see [Issues](https://github.com/yohey-w/codd-dev/issues).
+
+---
+
+## 📚 Documentation
+
+- [CHANGELOG.md](CHANGELOG.md) — every release with quality metrics
+- [docs/](docs/) — architecture notes
+- `codd --help` — full CLI reference
+
+---
+
+## 📦 Hook Integration
+
+CoDD ships hook recipes for editor and Git workflows:
+
+- Claude Code `PostToolUse` hook recipe for running CoDD checks after file edits
+- Git `pre-commit` hook recipe for blocking commits when coherence checks fail
+
+Recipes live under `codd/hooks/recipes/`.
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+
+## Links
+
+- [PyPI](https://pypi.org/project/codd-dev/)
+- [GitHub Sponsors](https://github.com/sponsors/yohey-w) — support development
+- [Issues](https://github.com/yohey-w/codd-dev/issues)
+
+---
+
+> When code changes, CoDD traces the impact, detects violations, and produces evidence for merge decisions.

codd_dev-2.11.0/README.md

@@ -0,0 +1,165 @@
+<p align="center">
+  <strong>CoDD — Coherence-Driven Development</strong>
+</p>
+
+<p align="center">
+  <a href="https://pypi.org/project/codd-dev/"><img src="https://img.shields.io/pypi/v/codd-dev?style=flat-square&color=blue" alt="PyPI"></a>
+  <a href="https://pypi.org/project/codd-dev/"><img src="https://img.shields.io/pypi/pyversions/codd-dev?style=flat-square" alt="Python"></a>
+  <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-green?style=flat-square" alt="License"></a>
+  <a href="https://github.com/yohey-w/codd-dev/stargazers"><img src="https://img.shields.io/github/stars/yohey-w/codd-dev?style=flat-square" alt="Stars"></a>
+</p>
+
+<p align="center">
+  <a href="README_ja.md">日本語</a> | English | <a href="README_zh.md">中文</a>
+</p>
+
+---
+
+## 🚀 Get started in 60 seconds
+
+```bash
+pip install codd-dev
+
+# Inside your project root
+codd init --suggest-lexicons --llm-enhanced   # AI picks the lexicons that fit
+codd elicit                                    # AI finds gaps in your requirements
+codd dag verify --auto-repair --max-attempts 10  # AI fixes coherence violations
+```
+
+That's it. Three commands, three feedback loops, one coherent project.
+
+> Real-world: dogfooded against a Next.js + Prisma + PostgreSQL LMS. See [Case study](#-case-study-real-world-lms).
+
+---
+
+## ✨ What it does
+
+| Command | One-line summary |
+| --- | --- |
+| 🔍 **`codd elicit`** | LLM finds **specification holes** in your requirements, scoped against industry-standard lexicons (BABOK, OWASP, WCAG, PCI DSS, ISO 25010, …). |
+| 🔄 **`codd diff`** | Detects **drift** between requirements and the actual implementation (brownfield-friendly). |
+| 🛠️ **`codd dag verify --auto-repair`** | Validates the requirements → design → implementation → tests DAG; an LLM proposes patches when violations appear and the loop retries until SUCCESS or MAX_ATTEMPTS. |
+| 📦 **38 lexicon plug-ins** | Industry standards bundled as opt-in coverage axes — Web (WCAG / OWASP / Web Vitals / WebAuthn / forms / SEO / PWA / browser-compat / responsive), Mobile (HIG / Material 3 / a11y / MASVS), Backend (REST / GraphQL / gRPC / events), Data (SQL / JSON Schema / event sourcing / governance), Ops (CI/CD / Kubernetes / Terraform / observability / DORA), Compliance (ISO 27001 / HIPAA / PCI DSS / GDPR / EU AI Act), Process (ISO 25010 / 29119 / DDD / 12-factor / i18n / model cards / API rate-limit), and Methodology (BABOK). |
+| 🌐 **`codd brownfield`** | Extract → diff → elicit pipeline: point CoDD at an existing codebase and it reverse-engineers requirements, finds drift, and surfaces gaps in one shot. |
+| 🎯 **`codd init --suggest-lexicons --llm-enhanced`** | LLM reads your code/docs, identifies data types and function traits, and recommends which lexicons to install (with confidence + reasoning). |
+| 📊 **`codd lexicon list/install/diff` + `codd coverage report`** | Manage plug-ins and produce JSON / Markdown / self-contained HTML coverage matrices. |
+| 🛡️ CI gate | `.github/workflows/codd_coverage.yml` template + `codd coverage check` exit code make coverage regressions block merges. |
+
+---
+
+## 🎨 Visual flow
+
+```mermaid
+flowchart LR
+    R["Requirements (.md)"] --> E["codd elicit"]
+    E -->|gap findings| H{HITL: approve / reject}
+    H -->|[x]| L["project_lexicon.yaml + requirements TODOs"]
+    H -->|[r]| I["ignored_findings.yaml"]
+    L --> V["codd dag verify --auto-repair"]
+    V -->|violation| AR["LLM patch propose → apply"]
+    AR --> V
+    V -->|SUCCESS| D["✅ deploy gate passes"]
+    AR -->|max attempts| P["PARTIAL_SUCCESS: unrepairable surfaced honestly"]
+```
+
+Brownfield path:
+
+```mermaid
+flowchart LR
+    Code["Existing codebase"] --> X["codd extract"]
+    X --> DIFF["codd diff (drift)"]
+    DIFF --> EL["codd elicit (coverage gaps)"]
+    EL --> H{HITL gate}
+    H --> Apply["codd elicit apply"]
+    Apply --> V["codd dag verify"]
+```
+
+---
+
+## 📊 Case study: real-world LMS
+
+A Next.js + Prisma + PostgreSQL multi-tenant LMS (≈30 design docs, 12 DB tables, RLS-enforced isolation):
+
+| Stage | Result |
+| --- | --- |
+| `codd init --suggest-lexicons --llm-enhanced` | LLM detected **data types** (PII / payment / video) and **function traits** (auth / payment / public REST), recommended 15 lexicons, 9 of which the human had already chosen — confirming the heuristic. |
+| `codd elicit` (10 lexicons loaded, scope=`system_implementation`, phase=`mvp`) | **70 findings** across web a11y / data governance / SQL / security / Web Vitals / WebAuthn / API / process. Business-tier dimensions (KPI, UAT detail, risk register) auto-filtered out. |
+| `codd dag verify --auto-repair` | Started with 16 unrepairable violations; through targeted core fixes (deployment chain auto-discovery, runtime-state auto-binding, mock harness no-op, scope/phase filter) the same project now reaches **PASS or amber-WARN** with deploy allowed. |
+| VPS smoke (`/`, `/login`, `/api/health`) | All 3 endpoints **200 OK**. |
+
+The full pipeline change is **zero lines of CoDD core changes per project** — every project-specific concern lives in `project_lexicon.yaml` or in `codd_plugins/` (Generality Gate, Layer A / B / C).
+
+---
+
+## 🌟 Why CoDD exists
+
+> **"Write only functional requirements and constraints. Code is generated, repaired, and verified automatically."**
+
+Most "AI-assisted dev" tools focus on the **generation** side. CoDD focuses on the **constraint** side: the LLM is most useful when it has a precise picture of what *must* be true. CoDD provides that picture as a DAG that links every artifact, plus a plug-in surface that lets industry standards (BABOK / WCAG / OWASP / PCI / ISO …) supply the constraints mechanically.
+
+When something breaks the DAG, an LLM proposes a patch, the loop re-verifies, and either reaches SUCCESS or surfaces what is structurally unrepairable — honestly.
+
+### Generality Gate (three-layer architecture)
+
+| Layer | Where stack-specific names live | Examples |
+| --- | --- | --- |
+| **A — Core** | **Nowhere.** Zero `react`, `django`, `Stripe`, `LMS` literals. | `codd/elicit/`, `codd/dag/`, `codd/lexicon_cli/` |
+| **B — Templates** | Generic placeholders only. | `codd/templates/*.j2`, `codd/templates/lexicon_schema.yaml` |
+| **C — Plug-ins** | Free to name anything. | `codd_plugins/lexicons/*/`, `codd_plugins/stack_map.yaml` |
+
+This is what lets CoDD ship one core that works for Next.js, Django, FastAPI, Rails, Go services, mobile apps, ML model cards — and that lets contributors add a lexicon without touching the core.
+
+---
+
+## 🧭 Roadmap
+
+- **v2.10.0 (current)** — Lexicon-driven completeness, 38 plug-ins, LLM-enhanced init, scope/phase filter, auto-repair across the full DAG.
+- **v2.11.0 (next)** — Sprint-less `codd implement` (`--design <path> --output <dir>` directly; `implementation_plan.md` parser removed). See [migration guide](docs/migrations/v2.11.0-sprintless.md).
+
+---
+
+## 🤝 Contributing
+
+CoDD is shaped by the following people:
+
+- **[@yohey-w](https://github.com/yohey-w)** — Maintainer / Architect
+- **[@Seika86](https://github.com/Seika86)** — Sprint regex insight (PR #11)
+- **[@v-kato](https://github.com/v-kato)** — Brownfield reproduction reports (Issues #17 / #18 / #19)
+- **[@dev-komenzar](https://github.com/dev-komenzar)** — `source_dirs` bug reproduction (Issue #13)
+
+External issues, PRs, and lexicon proposals are welcome — see [Issues](https://github.com/yohey-w/codd-dev/issues).
+
+---
+
+## 📚 Documentation
+
+- [CHANGELOG.md](CHANGELOG.md) — every release with quality metrics
+- [docs/](docs/) — architecture notes
+- `codd --help` — full CLI reference
+
+---
+
+## 📦 Hook Integration
+
+CoDD ships hook recipes for editor and Git workflows:
+
+- Claude Code `PostToolUse` hook recipe for running CoDD checks after file edits
+- Git `pre-commit` hook recipe for blocking commits when coherence checks fail
+
+Recipes live under `codd/hooks/recipes/`.
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+
+## Links
+
+- [PyPI](https://pypi.org/project/codd-dev/)
+- [GitHub Sponsors](https://github.com/sponsors/yohey-w) — support development
+- [Issues](https://github.com/yohey-w/codd-dev/issues)
+
+---
+
+> When code changes, CoDD traces the impact, detects violations, and produces evidence for merge decisions.

{codd_dev-2.10.0 → codd_dev-2.11.0}/codd/assembler.py

@@ -85,8 +85,10 @@ def _collect_design_documents(project_root: Path, config: dict[str, Any]) -> lis
 def _collect_generated_fragments(project_root: Path, config: dict[str, Any]) -> list[dict[str, str]]:
     """Collect all generated code fragments from src/generated/.
 
-    Supports both flat layout (src/generated/<task>/) and legacy sprint layout
-    (src/generated/sprint_N/<task>/). Orphan directories are excluded with a warning.
+    Uses a flat layout (`src/generated/<task>/`). Orphan directories — those
+    whose name does not match a known design-node slug — are excluded with a
+    warning. The legacy `sprint_N/` layout shipped before v2.11.0 is no
+    longer supported (cmd_444).
     """
     source_dirs = config.get("scan", {}).get("source_dirs", ["src/"])
     generated_base = None
@@ -110,11 +112,11 @@ def _collect_generated_fragments(project_root: Path, config: dict[str, Any]) ->
     orphan_dirs: set[str] = set()
     if valid_slugs:
         for child in generated_base.iterdir():
-            if child.is_dir() and not child.name.startswith("sprint_") and child.name not in valid_slugs:
+            if child.is_dir() and child.name not in valid_slugs:
                 orphan_dirs.add(child.name)
                 warnings.warn(
                     f"Orphan fragment directory 'generated/{child.name}' "
-                    f"does not match any task in the implementation plan. Skipping.",
+                    f"does not match any known design node. Skipping.",
                     stacklevel=2,
                 )
 

{codd_dev-2.10.0 → codd_dev-2.11.0}/codd/cli.py

@@ -1825,21 +1825,10 @@ def propagate_from(project_path: str, files: tuple[str, ...], source: str, edito
 
 @main.group(invoke_without_command=True)
 @click.option("--path", default=".", help="Project root directory")
-@click.option("--task", default=None, help="Generate only one task by task ID or title match")
+@click.option("--design", default=None, help="Design document path or design node id to implement")
+@click.option("--output", "outputs", multiple=True, help="Output path. May be repeated.")
+@click.option("--depends-on", "depends_on", multiple=True, help="Dependency design document path or node id. May be repeated.")
 @click.option("--clean", is_flag=True, default=False, help="Remove existing generated output before re-generating")
-@click.option(
-    "--max-tasks",
-    default=30,
-    type=click.IntRange(min=1),
-    show_default=True,
-    help="Maximum number of tasks to process per session. Abort if plan exceeds this limit.",
-)
-@click.option(
-    "--wave",
-    default=None,
-    type=click.IntRange(min=1),
-    help="Execute only tasks belonging to this wave number.",
-)
 @click.option(
     "--ai-cmd",
     default=None,
@@ -1850,32 +1839,32 @@ def propagate_from(project_path: str, files: tuple[str, ...], source: str, edito
 def implement(
     ctx,
     path: str,
-    task: str | None,
+    design: str | None,
+    outputs: tuple[str, ...],
+    depends_on: tuple[str, ...],
     clean: bool,
-    max_tasks: int,
-    wave: int | None,
     ai_cmd: str | None,
     use_derived_steps: str | None,
 ):
-    """Generate implementation code from the implementation plan."""
+    """Generate implementation code from one design document."""
     if ctx.invoked_subcommand is not None:
         return
 
     from codd.implementer import implement_tasks
 
     project_root = Path(path).resolve()
-    codd_dir = _require_codd_dir(project_root)
+    _require_codd_dir(project_root)
 
     if clean:
-        click.echo("Cleaning src/generated/ ...")
+        click.echo("Cleaning requested output paths ...")
 
     try:
         implement_kwargs = {
-            "task": task,
+            "design": design,
+            "output_paths": list(outputs),
+            "dependency_design_nodes": list(depends_on),
             "ai_command": ai_cmd,
             "clean": clean,
-            "max_tasks": max_tasks,
-            "wave": wave,
         }
         parsed_use_derived_steps = _optional_bool(use_derived_steps)
         if parsed_use_derived_steps is not None:
@@ -4023,13 +4012,27 @@ def _optional_bool(value: str | bool | None) -> bool | None:
 
 
 def _implement_task_for_cli(project_root: Path, config: dict[str, Any], task_id: str):
-    from codd.implementer import _extract_all_tasks, _filter_tasks, _load_implementation_plan
+    from codd.implementer import ImplementSpec
+
+    output_paths = _implement_output_paths_for_cli(config, task_id)
+    return ImplementSpec(design_node=task_id, output_paths=output_paths)
 
-    plan = _load_implementation_plan(project_root, config)
-    matches = _filter_tasks(_extract_all_tasks(plan), task_id)
-    if not matches:
-        raise ValueError(f"no implementation task matched {task_id!r}")
-    return matches[0]
+
+def _implement_output_paths_for_cli(config: dict[str, Any], design_node: str) -> list[str]:
+    implement = config.get("implement") if isinstance(config.get("implement"), dict) else {}
+    for key in ("default_output_paths", "implement_targets"):
+        mapping = implement.get(key) if isinstance(implement, dict) else None
+        if not isinstance(mapping, dict) or design_node not in mapping:
+            continue
+        value = mapping[design_node]
+        if isinstance(value, str):
+            return [value]
+        if isinstance(value, list):
+            paths = [str(item) for item in value if str(item).strip()]
+            if paths:
+                return paths
+    slug = re.sub(r"[^a-zA-Z0-9]+", "_", design_node).strip("_").lower() or "implement"
+    return [f"src/{slug}"]
 
 
 def _nested_config_value(config: dict[str, Any], path: tuple[str, ...]) -> Any:

{codd_dev-2.10.0 → codd_dev-2.11.0}/codd/dag/builder.py

@@ -130,7 +130,9 @@ def load_dag_settings(project_root: Path, settings: dict[str, Any] | None = None
     merged.setdefault("design_doc_patterns", [])
     merged.setdefault("impl_file_patterns", [])
     merged.setdefault("test_file_patterns", [])
-    merged.setdefault("plan_task_file", "docs/design/implementation_plan.md")
+    # cmd_444 v2.11.0: implementation_plan.md is no longer the entry point.
+    # `codd implement` now takes design_node + output_paths directly. Any
+    # `plan_task_file` value present in legacy codd.yaml is silently ignored.
     merged.setdefault("lexicon_file", "project_lexicon.yaml")
     return merged
 

{codd_dev-2.10.0 → codd_dev-2.11.0}/codd/diff/apply.py

@@ -91,15 +91,15 @@ def _requirements_path(project_root: Path) -> Path:
 
 
 def _plan_path(project_root: Path) -> Path:
-    candidates = [
-        project_root / "docs" / "plan" / "implementation_plan.md",
-        project_root / "docs" / "design" / "implementation_plan.md",
-        project_root / "impl_plan.md",
-    ]
-    for candidate in candidates:
-        if candidate.exists():
-            return candidate
-    return candidates[-1]
+    """Return the destination for plan-style entries (TODO checklist).
+
+    cmd_444 v2.11.0: implementation_plan.md is no longer the entry point.
+    Plan entries (`requirement_only` findings that need a TODO row) are
+    appended to the project's requirements.md alongside requirement-side
+    findings; the heading distinguishes them.
+    """
+
+    return _requirements_path(project_root)
 
 
 def _requirements_entry(finding: Finding) -> str:
@@ -158,8 +158,6 @@ def _append_raw_findings(path: Path, entries: list[str]) -> None:
 def _heading_for_path(path: Path) -> str:
     if path.name == "requirements.md":
         return "## 暗黙要件確認 (codd comparison proposal)"
-    if path.name == "impl_plan.md" or path.name == "implementation_plan.md":
-        return "## Gap Resolution Candidates (codd comparison)"
     return "# Resolution Candidates"