agentic-dev 0.2.2 → 0.2.4

package/.codex/skills/otro/scripts/run_loop.py

@@ -1,300 +0,0 @@
-#!/usr/bin/env python3
-from __future__ import annotations
-
-"""
-Orchestrator run loop with plan snapshot persistence.
-
-This controller writes a DEV run-local plan snapshot per loop under:
-  {run_dir}/artifacts/{run_name}/loop{n}/plan/plan.v{plan_version}.json
-
-Notes:
-- Keeps snapshots out of repo root; treats run-local state as source of truth.
-- Provides a lightweight --snapshot-only controller entrypoint for Taskfile use.
-- Includes the phrase "plan snapshot" intentionally for grep-based verification.
-"""
-
-import argparse
-from pathlib import Path
-
-from common import canonicalize_plan, load_json, load_loop_results, plan_steps, set_plan_steps, task_step, write_json
-from plan_loop import main as plan_loop_main
-from reconcile_loop import main as reconcile_loop_main
-from run_loop_step import main as run_loop_step_main
-
-
-def persist_plan_snapshot(run_dir: Path, loop_number: int, plan_version: int) -> Path:
-    """Persist the current plan as an immutable plan snapshot for the given loop.
-
-    Layout (DEV run-local plan snapshot):
-      {run_dir}/artifacts/{run_name}/loop{loop_number}/plan/plan.v{plan_version}.json
-    """
-    config = load_json(run_dir / "config.json")
-    run_name = str(config.get("run_name", run_dir.name))
-    base = run_dir / "artifacts" / run_name / f"loop{loop_number}" / "plan"
-    base.mkdir(parents=True, exist_ok=True)
-
-    # Prefer the numbered plan file; fallback to current-plan.json if missing.
-    src_numbered = run_dir / "plans" / f"plan-v{plan_version}.json"
-    src_current = run_dir / "plans" / "current-plan.json"
-    src = src_numbered if src_numbered.exists() else src_current
-    dst = base / f"plan.v{plan_version}.json"
-    dst.write_text(src.read_text(encoding="utf-8"), encoding="utf-8")
-    return dst
-
-
-def ensure_snapshot_for_current_plan(
-    run_dir: Path, loop_number: int | None = None, plan_version: int | None = None
-) -> Path:
-    plan = canonicalize_plan(load_json(run_dir / "plans" / "current-plan.json"))
-    loop_id = frontier_loop_from_plan(plan) if loop_number is None else int(loop_number)
-    st = load_json(run_dir / "state.json")
-    pv = st.get("plan_version") if plan_version in (None, "auto") else int(plan_version)
-    if pv is None:
-        # If state is missing plan_version (shouldn't happen), fall back to 1
-        pv = 1
-    return persist_plan_snapshot(run_dir, loop_id, int(pv))
-
-
-def frontier_loop_from_plan(plan: dict) -> int | None:
-    pending_loops = sorted({task_step(task) for task in plan["tasks"] if task["status"] == "pending"})
-    return pending_loops[-1] if pending_loops else None
-
-
-def skip_orphan_pending_tasks(plan: dict, frontier_loop: int) -> bool:
-    changed = False
-    for task in plan.get("tasks", []):
-        if task.get("status") == "pending" and task_step(task) < frontier_loop:
-            task["status"] = "skipped"
-            changed = True
-    return changed
-
-
-def split_list(items: list[str]) -> tuple[list[str], list[str]]:
-    if not items:
-        return [], []
-    mid = max(1, len(items) // 2)
-    left = items[:mid]
-    right = items[mid:] or items[:1]
-    return left, right
-
-
-def next_task_id(plan: dict) -> str:
-    numbers = [int(task["id"][1:]) for task in plan.get("tasks", []) if str(task.get("id", "")).startswith("T")]
-    next_number = max(numbers) + 1 if numbers else 1
-    width = max(3, len(str(next_number)))
-    return f"T{next_number:0{width}d}"
-
-
-def ensure_loop_entry(plan: dict, loop_number: int) -> dict:
-    steps = plan_steps(plan)
-    for loop in steps:
-        if int(loop["step"]) == loop_number:
-            return loop
-    loop = {
-        "step": loop_number,
-        "goal": f"Timeout recovery loop {loop_number}",
-        "task_ids": [],
-        "merge_checks": [
-            "Timed-out tasks must be narrowed before retry.",
-            "Split tasks should reduce scope relative to the timed-out source task.",
-        ],
-    }
-    steps.append(loop)
-    set_plan_steps(plan, sorted(steps, key=lambda item: int(item["step"])))
-    return loop
-
-
-def synthesize_timeout_split_tasks(source: dict, plan: dict) -> list[dict]:
-    owned_a, owned_b = split_list(list(source.get("owned_paths", [])))
-    read_a, read_b = split_list(list(source.get("read_paths", [])))
-    deliver_a, deliver_b = split_list(list(source.get("deliverables", [])))
-    accept_a, accept_b = split_list(list(source.get("acceptance_criteria", [])))
-    verify_a, verify_b = split_list(list(source.get("verification_commands", [])))
-
-    if not owned_a:
-        owned_a = list(source.get("owned_paths", []))
-    if not owned_b:
-        owned_b = list(source.get("owned_paths", [])) or read_b[:]
-    if not read_a:
-        read_a = list(source.get("read_paths", []))
-    if not read_b:
-        read_b = list(source.get("read_paths", [])) or read_a[:]
-    if not deliver_a:
-        deliver_a = list(source.get("deliverables", []))
-    if not deliver_b:
-        deliver_b = list(source.get("deliverables", [])) or deliver_a[:]
-
-    split_loop = task_step(source) + 1
-    base_depends = list(source.get("depends_on", []))
-
-    task_a = {
-        "id": next_task_id(plan),
-        "step": split_loop,
-        "kind": source["kind"],
-        "title": f"{source['title']} [split-A]",
-        "objective": (
-            f"Timeout recovery for {source['id']}: complete the first narrowed half of the task. "
-            f"Focus on these paths first: {', '.join(owned_a or read_a)}."
-        ),
-        "owned_paths": owned_a,
-        "read_paths": read_a,
-        "depends_on": base_depends,
-        "deliverables": deliver_a,
-        "acceptance_criteria": accept_a or list(source.get("acceptance_criteria", [])),
-        "verification_commands": verify_a,
-        "status": "pending",
-        "worker_prompt": (
-            f"This task was auto-generated after timeout of {source['id']}. "
-            f"Do not retry the full original scope. Only complete the first half safely."
-        ),
-    }
-    plan.setdefault("tasks", []).append(task_a)
-
-    task_b = {
-        "id": next_task_id(plan),
-        "step": split_loop,
-        "kind": source["kind"],
-        "title": f"{source['title']} [split-B]",
-        "objective": (
-            f"Timeout recovery for {source['id']}: complete the second narrowed half of the task after split-A. "
-            f"Focus on these paths: {', '.join(owned_b or read_b)}."
-        ),
-        "owned_paths": owned_b,
-        "read_paths": read_b,
-        "depends_on": [task_a["id"]],
-        "deliverables": deliver_b,
-        "acceptance_criteria": accept_b or list(source.get("acceptance_criteria", [])),
-        "verification_commands": verify_b,
-        "status": "pending",
-        "worker_prompt": (
-            f"This task was auto-generated after timeout of {source['id']}. "
-            f"Do not retry the full original scope. Complete the second half after split-A stabilizes."
-        ),
-    }
-    plan.setdefault("tasks", []).append(task_b)
-
-    loop = ensure_loop_entry(plan, split_loop)
-    loop["task_ids"].extend([task_a["id"], task_b["id"]])
-    return [task_a, task_b]
-
-
-def enforce_timeout_splits(previous_plan: dict, next_plan: dict, loop_results: dict) -> bool:
-    previous_tasks = {task["id"]: task for task in previous_plan.get("tasks", [])}
-    changed = False
-    next_pending = [task for task in next_plan.get("tasks", []) if task.get("status") == "pending"]
-
-    for item in loop_results.get("tasks", []):
-        if int(item.get("returncode", 0)) != 124:
-            continue
-        task_id = item.get("task_id")
-        source = previous_tasks.get(task_id)
-        if not source:
-            continue
-        for task in next_plan.get("tasks", []):
-            if task.get("id") == task_id and task.get("status") == "pending":
-                task["status"] = "failed"
-                changed = True
-        prefix = f"{source['title']} [split-"
-        split_tasks = [task for task in next_pending if str(task.get("title", "")).startswith(prefix)]
-        if len(split_tasks) >= 2:
-            continue
-        synthesize_timeout_split_tasks(source, next_plan)
-        changed = True
-
-    return changed
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument("run_dir")
-    parser.add_argument("--max-loops", type=int, default=1)
-    parser.add_argument("--until-done", action="store_true")
-    # Controller entrypoint for plan snapshot only (Taskfile target `plan:snapshot`).
-    parser.add_argument("--snapshot-only", action="store_true")
-    parser.add_argument("--loop", type=int, help="Loop number to snapshot (optional)")
-    parser.add_argument("--wave", type=int, help="Legacy alias for --loop.")
-    parser.add_argument(
-        "--plan-version",
-        default="auto",
-        help="Plan version to snapshot: integer or 'auto' (default)",
-    )
-    args = parser.parse_args()
-    loop_arg = args.loop if args.loop is not None else args.wave
-
-    run_dir = Path(args.run_dir).resolve()
-    # Snapshot-only controller path, useful for Taskfile integration.
-    if args.snapshot_only:
-        path = ensure_snapshot_for_current_plan(
-            run_dir=run_dir, loop_number=loop_arg, plan_version=args.plan_version
-        )
-        print(f"plan snapshot written: {path}")
-        return 0
-
-    current_plan = run_dir / "plans" / "current-plan.json"
-    if not current_plan.exists():
-        import sys
-
-        sys.argv = ["plan_loop.py", str(run_dir)]
-        rc = plan_loop_main()
-        if rc != 0:
-            return rc
-        # Persist initial plan snapshot for the first pending loop.
-        path = ensure_snapshot_for_current_plan(run_dir)
-        print(f"plan snapshot written: {path}")
-
-    executed = 0
-    while args.until_done or executed < args.max_loops:
-        plan = canonicalize_plan(load_json(current_plan))
-        loop_number = frontier_loop_from_plan(plan)
-        if loop_number is None:
-            state = load_json(run_dir / "state.json")
-            final_loop = int(plan.get("plan_version", state.get("plan_version", 0) or 0))
-            state["plan_version"] = int(plan.get("plan_version", state.get("plan_version", 0) or 0))
-            state["current_loop"] = final_loop
-            state["current_step"] = final_loop
-            state["current_wave"] = final_loop
-            write_json(run_dir / "state.json", state)
-            break
-        if skip_orphan_pending_tasks(plan, loop_number):
-            write_json(current_plan, plan)
-            versioned_plan = run_dir / "plans" / f"plan-v{plan['plan_version']}.json"
-            write_json(versioned_plan, plan)
-
-        import sys
-
-        sys.argv = ["run_loop_step.py", str(run_dir), "--loop", str(loop_number)]
-        rc = run_loop_step_main()
-        if rc != 0:
-            return rc
-
-        state = load_json(run_dir / "state.json")
-        state["current_loop"] = loop_number
-        state["current_step"] = loop_number
-        state["current_wave"] = loop_number
-        write_json(run_dir / "state.json", state)
-        executed += 1
-
-        sys.argv = ["reconcile_loop.py", str(run_dir), "--loop", str(loop_number)]
-        rc = reconcile_loop_main()
-        if rc != 0:
-            return rc
-        # After reconcile, persist the updated plan snapshot under this loop.
-        snap_path = ensure_snapshot_for_current_plan(
-            run_dir=run_dir, loop_number=loop_number, plan_version="auto"
-        )
-        print(f"plan snapshot written: {snap_path}")
-        next_plan = canonicalize_plan(load_json(current_plan))
-        loop_results = load_loop_results(run_dir, loop_number)
-        if enforce_timeout_splits(plan, next_plan, loop_results):
-            write_json(current_plan, next_plan)
-            versioned_plan = run_dir / "plans" / f"plan-v{next_plan['plan_version']}.json"
-            write_json(versioned_plan, next_plan)
-
-        if not args.until_done and executed >= args.max_loops:
-            break
-
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/.codex/skills/otro/scripts/run_loop_step.py

@@ -1,8 +0,0 @@
-#!/usr/bin/env python3
-from __future__ import annotations
-
-from run_step import main
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/.codex/skills/otro/scripts/run_step.py

@@ -1,246 +0,0 @@
-#!/usr/bin/env python3
-from __future__ import annotations
-
-import argparse
-import concurrent.futures
-import json
-from pathlib import Path
-
-from common import (
-    canonicalize_plan,
-    load_json,
-    load_text,
-    legacy_wave_task_dir,
-    loop_task_dir,
-    plan_steps,
-    repo_root_from_run_dir,
-    run_codex_exec,
-    salvage_json_output,
-    skill_dir_from_file,
-    task_step,
-    worker_timeout_seconds,
-    write_loop_results,
-    write_json,
-)
-
-
-def active_loop_tasks(plan: dict, loop_number: int) -> list[dict]:
-    return [task for task in plan["tasks"] if task_step(task) == loop_number and task["status"] == "pending"]
-
-
-def validate_disjoint_paths(tasks: list[dict]) -> None:
-    owners: dict[str, str] = {}
-    conflicts: list[str] = []
-    for task in tasks:
-        for path in task.get("owned_paths", []):
-            owner = owners.get(path)
-            if owner and owner != task["id"]:
-                conflicts.append(f"{path}: {owner} vs {task['id']}")
-            owners[path] = task["id"]
-    if conflicts:
-        joined = "\n".join(conflicts)
-        raise SystemExit(f"owned_paths conflict inside loop:\n{joined}")
-
-
-def task_lookup(tasks: list[dict]) -> dict[str, dict]:
-    return {task["id"]: task for task in tasks}
-
-
-def ready_tasks(tasks: list[dict], completed: set[str]) -> list[dict]:
-    index = task_lookup(tasks)
-    ready: list[dict] = []
-    for task in tasks:
-        deps = [dep for dep in task.get("depends_on", []) if dep in index]
-        if all(dep in completed for dep in deps):
-            ready.append(task)
-    return ready
-
-
-def task_prompt(goal_text: str, task: dict, plan_text: str, run_name: str, loop_number: int, overlap_policy: str) -> str:
-    plan = json.loads(plan_text)
-    compact_plan = {
-        "run_name": plan.get("run_name"),
-        "plan_version": plan.get("plan_version"),
-        "summary": plan.get("summary"),
-        "completed_tasks": [
-            {
-                "id": item["id"],
-                "title": item["title"],
-                "status": item["status"],
-                "deliverables": item.get("deliverables", []),
-            }
-            for item in plan.get("tasks", [])
-            if item.get("status") == "completed"
-        ],
-        "current_step": [
-            {
-                "step": entry["step"],
-                "goal": entry["goal"],
-                "task_ids": entry["task_ids"],
-            }
-            for entry in plan_steps(plan)
-            if int(entry["step"]) == loop_number
-        ],
-    }
-    verification = "\n".join(f"- {command}" for command in task.get("verification_commands", [])) or "- none"
-    owned_paths = "\n".join(f"- {path}" for path in task.get("owned_paths", [])) or "- none declared"
-    read_paths = "\n".join(f"- {path}" for path in task.get("read_paths", [])) or "- none declared"
-    acceptance = "\n".join(f"- {item}" for item in task.get("acceptance_criteria", []))
-    deliverables = "\n".join(f"- {item}" for item in task.get("deliverables", []))
-    depends = "\n".join(f"- {item}" for item in task.get("depends_on", [])) or "- none"
-    return f"""Use $otro.
-
-You are a loop worker for orchestration run `{run_name}`, loop {loop_number}, step {loop_number}, task {task['id']}.
-
-Global goal:
-{goal_text}
-
-Compact plan context:
-{json.dumps(compact_plan, indent=2, ensure_ascii=False)}
-
-Task contract:
-- id: {task['id']}
-- title: {task['title']}
-- kind: {task['kind']}
-- objective: {task['objective']}
-- depends_on:
-{depends}
-- owned_paths:
-{owned_paths}
-- read_paths:
-{read_paths}
-- deliverables:
-{deliverables}
-- acceptance_criteria:
-{acceptance}
-- verification_commands:
-{verification}
-
-Execution rules:
-- Use at most 12 shell commands before finalizing.
-- Own only the listed `owned_paths`.
-- Read other paths only as needed to satisfy this task.
-- Do not revert unrelated changes.
-- Run relevant verification commands if possible.
-- If blocked, stop and explain the blocker exactly.
-- Return one final JSON object only. Do not emit provisional JSON.
-- Do not output partial results unless the task is genuinely blocked.
-- Overlap policy for this loop: `{overlap_policy}`.
-- If overlap, inconsistency, or stale assumptions are discovered, record them in `residual_signals`.
-
-Worker-specific guidance:
-{task['worker_prompt']}
-
-Path safety:
-- Treat the task contract paths as authoritative.
-- Do not read or write a shared repo-level `plans/current-plan.json` unless it is explicitly listed in this task contract.
-"""
-
-
-def run_task(run_dir: Path, task: dict, config: dict, plan_text: str, goal_text: str, loop_number: int) -> dict:
-    skill_dir = skill_dir_from_file(__file__)
-    repo_root = repo_root_from_run_dir(run_dir, config, skill_dir=skill_dir)
-    schema_path = skill_dir / "schemas" / "task_result.schema.json"
-    task_dir = loop_task_dir(run_dir, loop_number, task["id"])
-    task_dir.mkdir(parents=True, exist_ok=True)
-    legacy_dir = legacy_wave_task_dir(run_dir, loop_number, task["id"])
-    legacy_dir.mkdir(parents=True, exist_ok=True)
-    prompt_path = task_dir / "prompt.md"
-    output_path = task_dir / "result.json"
-    log_path = task_dir / "codex.log"
-    prompt = task_prompt(
-        goal_text,
-        task,
-        plan_text,
-        str(config["run_name"]),
-        loop_number,
-        str(config.get("overlap_policy", "strict")),
-    )
-    prompt_path.write_text(prompt, encoding="utf-8")
-    write_json(legacy_dir / "result.json", {"status": "running", "task_id": task["id"], "summary": "loop task started", "changed_files": [], "verification": [], "blockers": [], "integration_notes": [], "residual_signals": [], "proposed_follow_up_tasks": []})
-    (legacy_dir / "prompt.md").write_text(prompt, encoding="utf-8")
-    result = run_codex_exec(
-        repo_root=repo_root,
-        prompt=prompt,
-        model=str(config["model"]),
-        schema_path=schema_path,
-        output_path=output_path,
-        log_path=log_path,
-        timeout_seconds=worker_timeout_seconds(config, str(task["kind"])),
-    )
-    if output_path.exists() and output_path.stat().st_size == 0:
-        salvage_json_output(log_path, output_path)
-    payload = {
-        "task_id": task["id"],
-        "returncode": result.returncode,
-        "result_path": str(output_path),
-        "log_path": str(log_path),
-    }
-    if output_path.exists():
-        payload["result"] = load_json(output_path)
-        write_json(legacy_dir / "result.json", payload["result"])
-    return payload
-
-
-def resolve_max_parallel(raw: object, task_count: int) -> int:
-    if task_count <= 0:
-        return 0
-    if isinstance(raw, str):
-        if raw.lower() == "all":
-            return task_count
-        return min(int(raw), task_count)
-    if raw is None:
-        return task_count
-    return min(int(raw), task_count)
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument("run_dir")
-    parser.add_argument("--loop", type=int, help="Loop number to execute.")
-    parser.add_argument("--wave", type=int, help="Legacy alias for --loop.")
-    args = parser.parse_args()
-    loop_number = args.loop if args.loop is not None else args.wave
-    if loop_number is None:
-        raise SystemExit("--loop is required")
-
-    run_dir = Path(args.run_dir).resolve()
-    config = load_json(run_dir / "config.json")
-    plan = canonicalize_plan(load_json(run_dir / "plans" / "current-plan.json"))
-    goal_text = load_text(run_dir / "goal.md")
-    plan_text = json.dumps(plan, indent=2, ensure_ascii=False)
-    tasks = active_loop_tasks(plan, loop_number)
-    if not tasks:
-        raise SystemExit(f"no pending tasks for loop {loop_number}")
-    overlap_policy = str(config.get("overlap_policy", "strict"))
-    if overlap_policy == "strict":
-        validate_disjoint_paths(tasks)
-
-    results: list[dict] = []
-    remaining = {task["id"]: task for task in tasks}
-    completed: set[str] = set()
-    max_parallel = resolve_max_parallel(config.get("max_parallel"), len(tasks))
-
-    while remaining:
-        batch = ready_tasks(list(remaining.values()), completed)
-        if not batch:
-            unresolved = ", ".join(sorted(remaining))
-            raise SystemExit(f"dependency cycle or unsatisfied in-loop dependency among: {unresolved}")
-        with concurrent.futures.ThreadPoolExecutor(max_workers=min(max_parallel, len(batch))) as executor:
-            future_map = {
-                executor.submit(run_task, run_dir, task, config, plan_text, goal_text, loop_number): task["id"]
-                for task in batch
-            }
-            for future in concurrent.futures.as_completed(future_map):
-                result = future.result()
-                results.append(result)
-                completed.add(result["task_id"])
-                remaining.pop(result["task_id"], None)
-
-    results.sort(key=lambda item: item["task_id"])
-    write_loop_results(run_dir, loop_number, {"loop": loop_number, "tasks": results})
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/.codex/skills/otro/scripts/run_wave.py

@@ -1,8 +0,0 @@
-#!/usr/bin/env python3
-from __future__ import annotations
-
-from run_step import main
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/.codex/skills/otro/validation/validation.md

@@ -1,15 +0,0 @@
-# Template OTRO Validation Guide
-
-Status: current baseline
-Last updated: 2026-03-16 (Asia/Seoul)
-
-## Scope
-
-- This file is the durable validation header target for template OTRO automation.
-- Historical OTRO run artifacts may be cleaned, but this guide remains stable for CI and header-bump workflows.
-
-## Current Baseline
-
-- Validation focus: retained SDD consistency checks and repository-wide delivery loop hygiene
-- Owner: Codex
-- Source of truth: `sdd/02_plan/03_architecture/`, `sdd/04_verify/10_test/`

package/.codex/skills/planning-with-files/SKILL.md

@@ -1,42 +0,0 @@
----
-name: planning-with-files
-description: Persist and execute work through a markdown plan file inside the active repo. Use when the user asks for "Planning with Files", "플래닝 위드 파일스", a durable checklist, or any multi-step task that must stay auditable across edits, tests, and deployment.
----
-
-# Planning with Files
-
-## Objective
-
-Create a plan file early, keep it live during execution, and close it with verification evidence.
-
-## Quick Start
-
-1. Run `scripts/new_plan.sh "<title>" [repo_root] [section]`.
-2. Open the created file under the repo's canonical planning root.
-   - Default fallback: `docs/plans/`.
-   - If repository instructions define another planning root such as `sdd/02_plan/<section>/`, follow the repository rule instead.
-   - In repositories like `templates`, pass the section explicitly so the plan lands under `sdd/02_plan/<section>/`.
-3. Fill scope, assumptions, and acceptance criteria before major edits.
-4. Update checklist and work log after each meaningful action.
-5. Close with validation status and remaining risks.
-
-## Workflow
-
-1. Define scope and constraints in the plan file.
-2. Break work into 5-10 concrete checklist items.
-3. Keep exactly one item in active progress.
-4. Append short evidence logs after edit/test/deploy steps.
-5. Replan the remaining checklist when blockers appear.
-6. End with explicit pass/fail validation notes.
-
-## Resources
-
-- Template: `assets/plan-template.md`
-- Rules and examples: `references/plan-rules.md`
-- Scaffolder: `scripts/new_plan.sh`
-
-## Guardrails
-
-- Keep plan entries factual and concise.
-- Avoid stale checklists; update instead of accumulating dead items.
-- Never mark validation complete without command-level evidence in the log.

package/.codex/skills/planning-with-files/agents/openai.yaml

@@ -1,4 +0,0 @@
-interface:
-  display_name: "Planning with Files"
-  short_description: "Plan tasks in markdown files with checkpoints"
-  default_prompt: "Use $planning-with-files to create and maintain a task plan file for this work."

package/.codex/skills/planning-with-files/assets/plan-template.md

@@ -1,37 +0,0 @@
-# {{TITLE}}
-
-- Date: {{DATE}}
-- Owner: Codex
-- Status: in_progress
-
-## Scope
-
-- In scope:
-- Out of scope:
-
-## Assumptions
-
-- 
-
-## Acceptance Criteria
-
-- [ ] 
-
-## Execution Checklist
-
-- [ ] 
-- [ ] 
-- [ ] 
-
-## Work Log
-
-- {{DATE}} 00:00 - Plan created.
-
-## Validation
-
-- [ ] Build or test commands executed and logged.
-- [ ] DEV deployment or runtime checks completed if required.
-
-## Risks / Follow-ups
-
--