agentic-dev 0.2.1 → 0.2.3

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

@@ -1,367 +0,0 @@
-#!/usr/bin/env python3
-from __future__ import annotations
-
-import argparse
-import json
-from pathlib import Path
-
-from common import (
-    anchor_plan_path,
-    canonicalize_plan,
-    ensure_anchor_plan,
-    load_json,
-    load_loop_results,
-    load_text,
-    plan_steps,
-    planner_timeout_seconds,
-    repo_root_from_run_dir,
-    run_codex_exec,
-    salvage_json_output,
-    skill_dir_from_file,
-    set_plan_steps,
-    set_task_step,
-    task_step,
-    write_json,
-)
-
-
-def normalize_pending_loop_numbers(plan: dict) -> dict:
-    plan = canonicalize_plan(plan)
-    plan_version = int(plan["plan_version"])
-    pending_loops = sorted({task_step(task) for task in plan.get("tasks", []) if task.get("status") == "pending"})
-    if not pending_loops:
-        return plan
-    mapping = {old: plan_version + idx for idx, old in enumerate(pending_loops)}
-    if all(old == new for old, new in mapping.items()):
-        return plan
-
-    task_index = {task["id"]: task for task in plan.get("tasks", [])}
-    for task in plan.get("tasks", []):
-        if task.get("status") == "pending":
-            set_task_step(task, mapping[task_step(task)])
-
-    normalized_steps = []
-    for entry in plan_steps(plan):
-        item = dict(entry)
-        old_wave = int(item["step"])
-        pending_ids = [task_id for task_id in entry.get("task_ids", []) if task_index.get(task_id, {}).get("status") == "pending"]
-        if old_wave in mapping and pending_ids:
-            item["step"] = mapping[old_wave]
-            item["goal"] = str(item.get("goal", "")).replace(f"Wave {old_wave}", f"Loop {mapping[old_wave]}")
-            item["goal"] = str(item.get("goal", "")).replace(f"wave {old_wave}", f"loop {mapping[old_wave]}")
-            item["goal"] = str(item.get("goal", "")).replace(f"Step {old_wave}", f"Step {mapping[old_wave]}")
-            item["goal"] = str(item.get("goal", "")).replace(f"step {old_wave}", f"step {mapping[old_wave]}")
-        normalized_steps.append(item)
-
-    set_plan_steps(plan, sorted(normalized_steps, key=lambda item: int(item["step"])))
-    return plan
-
-
-def split_timeout_followups(task: dict) -> list[dict]:
-    owned_paths = list(task.get("owned_paths", []))
-    read_paths = list(task.get("read_paths", []))
-    acceptance = list(task.get("acceptance_criteria", []))
-    verification = list(task.get("verification_commands", []))
-
-    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
-
-    owned_a, owned_b = split_list(owned_paths)
-    read_a, read_b = split_list(read_paths)
-    acc_a, acc_b = split_list(acceptance)
-    ver_a, ver_b = split_list(verification)
-
-    if not owned_a:
-        owned_a = owned_paths[:]
-    if not owned_b:
-        owned_b = owned_paths[:] if owned_paths else read_b[:]
-    if not read_a:
-        read_a = read_paths[:]
-    if not read_b:
-        read_b = read_paths[:] if read_paths else read_a[:]
-
-    return [
-        {
-            "title": f"{task['title']} [split-A]",
-            "kind": task["kind"],
-            "objective": (
-                f"Recover from timeout by completing the first narrowed half of `{task['title']}`. "
-                f"Focus only on these paths first: {', '.join(owned_a or read_a)}."
-            ),
-            "owned_paths": owned_a,
-            "read_paths": read_a,
-            "acceptance_criteria": acc_a or acceptance,
-            "verification_commands": ver_a,
-            "reason": f"Automatic timeout split of {task['id']} into the first narrower subtask.",
-        },
-        {
-            "title": f"{task['title']} [split-B]",
-            "kind": task["kind"],
-            "objective": (
-                f"Recover from timeout by completing the second narrowed half of `{task['title']}`. "
-                f"Focus only on these paths after split-A stabilizes: {', '.join(owned_b or read_b)}."
-            ),
-            "owned_paths": owned_b,
-            "read_paths": read_b,
-            "acceptance_criteria": acc_b or acceptance,
-            "verification_commands": ver_b,
-            "reason": f"Automatic timeout split of {task['id']} into the second narrower subtask.",
-        },
-    ]
-
-
-def compact_results_blob(results_payload: dict, current_plan: dict) -> str:
-    task_index = {task["id"]: task for task in current_plan.get("tasks", [])}
-    compact = {
-        "loop": results_payload.get("loop", results_payload.get("wave")),
-        "tasks": [],
-    }
-    for item in results_payload.get("tasks", []):
-        result = item.get("result", {})
-        source_task = task_index.get(item.get("task_id"), {})
-        timed_out = int(item.get("returncode", 0)) == 124
-        compact["tasks"].append(
-            {
-                "task_id": item.get("task_id"),
-                "returncode": item.get("returncode"),
-                "timed_out": timed_out,
-                "status": result.get("status"),
-                "summary": result.get("summary"),
-                "changed_files": result.get("changed_files", []),
-                "blockers": result.get("blockers", []),
-                "integration_notes": result.get("integration_notes", []),
-                "residual_signals": result.get("residual_signals", []),
-                "proposed_follow_up_tasks": result.get("proposed_follow_up_tasks", []),
-                "timeout_split_tasks": split_timeout_followups(source_task) if timed_out and source_task else [],
-            }
-        )
-    return json.dumps(compact, indent=2, ensure_ascii=False)
-
-
-def build_initial_prompt(
-    run_name: str,
-    goal_text: str,
-    max_tasks: int,
-    plan_version: int,
-    run_dir_rel: str,
-    overlap_policy: str,
-) -> str:
-    return f"""Use $otro.
-
-You are producing a repository-wide refactoring plan for run `{run_name}`.
-This workflow is not recursive depth-first delegation. It is:
-1. Analyze the repository and the goal globally.
-2. Produce an upfront TODO/task graph.
-3. Group disjoint tasks into execution steps.
-4. Reserve merge and integration work for later loops.
-
-Requirements:
-- Inspect the repository before answering.
-- Use at most 12 shell commands before finalizing.
-- Inspect only the paths needed to satisfy the stated repository-wide goal.
-- Produce at most {max_tasks} tasks total in this plan version.
-- The first execution loop should favor analysis, boundary clarification, inventory building, and low-conflict work.
-- Overlap policy for this run: `{overlap_policy}`.
-- If overlap policy is `strict`, keep `owned_paths` disjoint inside a loop.
-- If overlap policy is `tolerant`, allow overlap where it improves exploration and add explicit residual/integration tasks for the next loop.
-- Keep worker prompts concrete enough that a separate Codex process can execute the task.
-- Fill `verification_commands` only with commands that are actually relevant.
-- Use status `pending` for not-yet-run tasks.
-- Emit `step` on every task and `steps` as the grouped frontier list. Do not use `wave`/`waves` in new output.
-- Emit `anchor_alignment` with `status` and `notes`. For the initial plan, mark it `aligned`.
-- Emit `completion_policy` with all of:
-  - `done_when`: short legacy summary mirroring repository completion
-  - `loop_done`: when the current plan backlog is exhausted
-  - `run_done`: when a fresh repository-wide rescan after loop_done yields no materially new tasks
-  - `repository_done`: when run_done and repository-level deployment/verification gates pass
-  - `replan_when`: conditions that should open the next OTRO plan or run
-- Return one final JSON object only. Do not emit provisional JSON.
-- Do not output partial plans, intermediate JSON, or command-budget narration.
-- Finish repository inspection first, then emit a single consolidated plan that covers the full goal scope.
-
-Planning guidance:
-- Cover all major repository surfaces that matter to the stated goal.
-- Prefer broad initial decomposition over narrow local optimization.
-- Use later loops for integration or edit work after the analysis frontier is established.
-- Favor coarse-grained tasks that partition the repository cleanly over many tiny tasks.
-- Keep orchestration state run-local. Use `{run_dir_rel}/plans/current-plan.json` for the synthesized plan, and place run artifacts under `{run_dir_rel}/` unless the task is explicitly about repo-level production assets.
-
-Run name: {run_name}
-Plan version to emit: {plan_version}
-Run directory: {run_dir_rel}
-
-Goal file:
-{goal_text}
-"""
-
-
-def build_replan_prompt(
-    run_name: str,
-    goal_text: str,
-    anchor_plan_text: str,
-    current_plan_text: str,
-    results_blob: str,
-    max_tasks: int,
-    plan_version: int,
-    finished_loop: int,
-    run_dir_rel: str,
-    overlap_policy: str,
-) -> str:
-    return f"""Use $otro.
-
-You are reconciling a repository-wide Codex orchestration run after loop {finished_loop} for `{run_name}`.
-
-Workflow contract:
-1. Read the goal.
-2. Read the anchor plan from the first planning pass.
-3. Read the current plan.
-4. Read the completed task results.
-5. Inspect the current repository state.
-6. Emit the next plan version with updated statuses and next-loop tasks.
-
-Rules:
-- Use at most 12 shell commands before finalizing.
-- Treat the anchor plan as the teacher prior for repository-wide intent, decomposition axes, and invariants.
-- Preserve completed tasks in the task list and mark them `completed`, `blocked`, or `failed`.
-- Emit `anchor_alignment` with `status` and `notes` explaining whether the live plan still matches the anchor plan.
-- Keep `step` and `steps` as the canonical execution-slice fields. Do not emit new `wave`/`waves` keys.
-- Emit `completion_policy` with all of:
-  - `done_when`: short legacy summary mirroring repository completion
-  - `loop_done`: when the current plan backlog is exhausted
-  - `run_done`: when a fresh repository-wide rescan after loop_done yields no materially new tasks
-  - `repository_done`: when run_done and repository-level deployment/verification gates pass
-  - `replan_when`: conditions that should open the next OTRO plan or run
-- Add new tasks only when integration evidence requires them.
-- Do not re-queue tasks that already succeeded unless integration broke their acceptance criteria.
-- If a task timed out, do not re-run it unchanged. Replace it with exactly two narrower follow-up tasks derived from the timeout split hints or an equivalent two-way split.
-- Keep at most {max_tasks} tasks in the emitted plan.
-- Overlap policy for this run: `{overlap_policy}`.
-- If overlap policy is `strict`, maintain disjoint `owned_paths` inside each pending loop.
-- If overlap policy is `tolerant`, preserve useful overlap and express repair work through residual-driven follow-up tasks.
-- Insert explicit integration tasks when cross-file reconciliation is needed.
-- Return one final JSON object only. Do not emit provisional JSON.
-- Do not output partial plans, intermediate JSON, or command-budget narration.
-
-Replanning guidance:
-- Keep the plan aligned with the repository-wide goal and the anchor plan rather than a single subsystem.
-- Preserve successful work and only refine the graph where new evidence requires it.
-- Prefer updating the existing task graph over replacing it wholesale.
-- Do not let temporary overlap or a dirty intermediate repo state erase the original decomposition intent.
-- If the current state materially diverges from the anchor plan, express that as explicit residual or repair tasks rather than silently drifting the plan.
-- For timeouts, prefer scope reduction over retry. The next plan should shrink timed-out work into two smaller tasks, not repeat the same task verbatim.
-- Keep orchestration state run-local. Use `{run_dir_rel}/plans/current-plan.json` for synthesized plan updates, and keep run artifacts under `{run_dir_rel}/` unless the task is explicitly about repo-level production assets.
-
-Run name: {run_name}
-Next plan version: {plan_version}
-Finished loop: {finished_loop}
-Run directory: {run_dir_rel}
-
-Goal file:
-{goal_text}
-
-Anchor plan JSON:
-{anchor_plan_text}
-
-Current plan JSON:
-{current_plan_text}
-
-Loop results JSON:
-{results_blob}
-"""
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument("run_dir")
-    parser.add_argument("--mode", choices=["initial", "replan"], default="initial")
-    parser.add_argument("--finished-loop", type=int)
-    parser.add_argument("--finished-wave", type=int)
-    args = parser.parse_args()
-
-    run_dir = Path(args.run_dir).resolve()
-    skill_dir = skill_dir_from_file(__file__)
-    repo_root = repo_root_from_run_dir(run_dir)
-    schema_path = skill_dir / "schemas" / "step_plan.schema.json"
-    config = load_json(run_dir / "config.json")
-    state = load_json(run_dir / "state.json")
-    goal_text = load_text(run_dir / "goal.md")
-    run_dir_rel = str(run_dir.relative_to(repo_root))
-    plan_version = int(state["plan_version"]) + 1
-    output_path = run_dir / "plans" / f"plan-v{plan_version}.json"
-    current_link = run_dir / "plans" / "current-plan.json"
-    log_path = run_dir / "logs" / f"plan-v{plan_version}.log"
-
-    max_tasks = int(config.get("max_tasks_total", config.get("max_tasks_per_step", config["max_tasks_per_wave"])))
-    overlap_policy = str(config.get("overlap_policy", "strict"))
-
-    if args.mode == "initial":
-        prompt = build_initial_prompt(
-            run_name=config["run_name"],
-            goal_text=goal_text,
-            max_tasks=max_tasks,
-            plan_version=plan_version,
-            run_dir_rel=run_dir_rel,
-            overlap_policy=overlap_policy,
-        )
-    else:
-        finished_loop = args.finished_loop if args.finished_loop is not None else args.finished_wave
-        if finished_loop is None:
-            raise SystemExit("--finished-loop is required in replan mode")
-        anchor_path = anchor_plan_path(run_dir)
-        if not anchor_path.exists():
-            fallback_plan = run_dir / "plans" / "plan-v1.json"
-            ensure_anchor_plan(run_dir, fallback_plan if fallback_plan.exists() else current_link)
-        anchor_plan_text = load_text(anchor_path)
-        current_plan_text = load_text(current_link)
-        results_payload = load_loop_results(run_dir, int(finished_loop))
-        results_blob = compact_results_blob(results_payload, load_json(current_link))
-        prompt = build_replan_prompt(
-            run_name=config["run_name"],
-            goal_text=goal_text,
-            anchor_plan_text=anchor_plan_text,
-            current_plan_text=current_plan_text,
-            results_blob=results_blob,
-            max_tasks=max_tasks,
-            plan_version=plan_version,
-            finished_loop=int(finished_loop),
-            run_dir_rel=run_dir_rel,
-            overlap_policy=overlap_policy,
-        )
-
-    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=planner_timeout_seconds(config),
-    )
-    if not output_path.exists():
-        salvage_json_output(log_path, output_path)
-    elif output_path.stat().st_size == 0:
-        salvage_json_output(log_path, output_path)
-    if not output_path.exists() or result.returncode != 0 or output_path.stat().st_size == 0:
-        raise SystemExit(result.returncode)
-
-    plan_payload = canonicalize_plan(load_json(output_path))
-    plan_payload = normalize_pending_loop_numbers(plan_payload)
-    write_json(output_path, plan_payload)
-
-    state["plan_version"] = plan_version
-    state["current_loop"] = plan_version
-    state["current_step"] = plan_version
-    write_json(run_dir / "state.json", state)
-    current_link.write_text(load_text(output_path), encoding="utf-8")
-    if args.mode == "initial":
-        ensure_anchor_plan(run_dir, output_path)
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

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

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

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

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

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

@@ -1,37 +0,0 @@
-#!/usr/bin/env python3
-from __future__ import annotations
-
-import argparse
-from pathlib import Path
-
-from common import load_loop_results
-from plan_loop import main as plan_loop_main
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument("run_dir")
-    parser.add_argument("--loop", type=int, help="Loop number to reconcile.")
-    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()
-    load_loop_results(run_dir, loop_number)
-    import sys
-
-    sys.argv = [
-        "plan_loop.py",
-        str(run_dir),
-        "--mode",
-        "replan",
-        "--finished-loop",
-        str(loop_number),
-    ]
-    return plan_loop_main()
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

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

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