Codex Fable5

interface:
  display_name: "Codex Fable5"
  short_description: "Fable-style Codex agent workflow"
  default_prompt: "Use $codex-fable5 to run this task with a Fable-style, tool-first Codex workflow."

#!/usr/bin/env python3
"""Shared Codex Fable5 local state helpers."""

from __future__ import annotations

from contextlib import contextmanager
import json
import os
import sys
import tempfile
import time
from datetime import datetime, timezone
from pathlib import Path
from typing import Any, Iterator

try:
    import fcntl
except ImportError:  # pragma: no cover - Windows fallback only.
    fcntl = None

STATE_DIR = Path(".codex-fable5")
GOALS_FILE = STATE_DIR / "goals.json"
FINDINGS_FILE = STATE_DIR / "findings.json"
LEDGER_FILE = STATE_DIR / "ledger.jsonl"
LOCK_FILE = STATE_DIR / "state.lock"
LOCK_TIMEOUT_SECONDS = 30.0


def now() -> str:
    return datetime.now(timezone.utc).isoformat()


@contextmanager
def locked_state() -> Iterator[None]:
    STATE_DIR.mkdir(exist_ok=True)
    if fcntl is None:
        fallback = STATE_DIR / "state.lockdir"
        deadline = time.monotonic() + LOCK_TIMEOUT_SECONDS
        while True:
            try:
                fallback.mkdir()
                break
            except FileExistsError:
                if time.monotonic() >= deadline:
                    sys.exit(f"codex-fable5: timed out waiting for state lock ({fallback}).")
                time.sleep(0.05)
        try:
            yield
        finally:
            fallback.rmdir()
        return

    with LOCK_FILE.open("a", encoding="utf-8") as handle:
        fcntl.flock(handle, fcntl.LOCK_EX)
        try:
            yield
        finally:
            fcntl.flock(handle, fcntl.LOCK_UN)


def read_json(path: Path, label: str) -> Any:
    try:
        return json.loads(path.read_text(encoding="utf-8"))
    except json.JSONDecodeError as exc:
        sys.exit(
            f"codex-fable5: {label} is not valid JSON "
            f"({path}:{exc.lineno}:{exc.colno}: {exc.msg})."
        )


def write_json(path: Path, data: dict[str, Any]) -> None:
    STATE_DIR.mkdir(exist_ok=True)
    tmp_name = ""
    with tempfile.NamedTemporaryFile(
        "w",
        encoding="utf-8",
        dir=STATE_DIR,
        prefix=f".{path.name}.",
        delete=False,
    ) as handle:
        tmp_name = handle.name
        handle.write(json.dumps(data, ensure_ascii=False, indent=2) + "\n")
        handle.flush()
        os.fsync(handle.fileno())
    Path(tmp_name).replace(path)


def append_event(event: str, **fields: Any) -> None:
    STATE_DIR.mkdir(exist_ok=True)
    record = {"ts": now(), "event": event, **fields}
    with LEDGER_FILE.open("a", encoding="utf-8") as handle:
        handle.write(json.dumps(record, ensure_ascii=False) + "\n")


def require_object(value: Any, path: Path, label: str) -> dict[str, Any]:
    if not isinstance(value, dict):
        sys.exit(f"codex-fable5: {label} must be a JSON object ({path}).")
    return value

#!/usr/bin/env python3
"""Codex Fable5 findings ledger for review-and-repair gates."""

from __future__ import annotations

import argparse
import re
import sys
from pathlib import Path
from typing import Any

from codex_fable_state import (
    FINDINGS_FILE,
    GOALS_FILE,
    LEDGER_FILE,
    LOCK_FILE,
    STATE_DIR,
    append_event,
    locked_state,
    now,
    read_json,
    require_object,
    write_json,
)


OPEN_STATUSES = {"open"}
BLOCKING_STATUSES = {"open", "blocked"}
TERMINAL_STATUSES = {"resolved", "rejected"}
SEVERITY_ORDER = {"critical": 0, "high": 1, "medium": 2, "low": 3}
FINDING_STATUSES = {"open", "blocked", "resolved", "rejected"}
FINDING_REQUIRED_FIELDS = {"id", "goal", "title", "severity", "source", "status", "evidence"}


def validate_findings(data: dict[str, Any], path: Path, label: str) -> dict[str, Any]:
    data.setdefault("findings", [])
    findings = data["findings"]
    if not isinstance(findings, list):
        sys.exit(f"codex-fable5: {label} field 'findings' must be a list ({path}).")
    for index, finding in enumerate(findings, 1):
        if not isinstance(finding, dict):
            sys.exit(f"codex-fable5: {label} finding {index} must be an object ({path}).")
        missing = sorted(FINDING_REQUIRED_FIELDS - finding.keys())
        if missing:
            fields = ", ".join(missing)
            sys.exit(f"codex-fable5: {label} finding {index} is missing {fields} ({path}).")
        status = finding.get("status")
        if not isinstance(status, str) or status not in FINDING_STATUSES:
            sys.exit(f"codex-fable5: {label} finding {index} has invalid status {status!r} ({path}).")
    return data


def validate_goals(data: dict[str, Any], path: Path, label: str) -> dict[str, Any]:
    goals = data.get("goals")
    if not isinstance(goals, list):
        sys.exit(f"codex-fable5: {label} field 'goals' must be a list ({path}).")
    for index, goal in enumerate(goals, 1):
        if not isinstance(goal, dict):
            sys.exit(f"codex-fable5: {label} goal {index} must be an object ({path}).")
    return data


def load_findings() -> dict[str, Any]:
    if not FINDINGS_FILE.exists():
        return {"created": now(), "findings": []}
    data = require_object(read_json(FINDINGS_FILE, "findings ledger"), FINDINGS_FILE, "findings ledger")
    return validate_findings(data, FINDINGS_FILE, "findings ledger")


def save_findings(data: dict[str, Any]) -> None:
    data["updated"] = now()
    write_json(FINDINGS_FILE, data)


def load_goals() -> dict[str, Any] | None:
    if not GOALS_FILE.exists():
        return None
    data = require_object(read_json(GOALS_FILE, "goal plan"), GOALS_FILE, "goal plan")
    return validate_goals(data, GOALS_FILE, "goal plan")


def active_goal_id() -> str:
    goals = load_goals()
    if goals is None:
        return ""
    active = [goal for goal in goals.get("goals", []) if goal.get("status") == "in_progress"]
    if len(active) != 1:
        return ""
    return str(active[0].get("id", ""))


def next_finding_id(findings: list[dict[str, Any]]) -> str:
    max_seen = 0
    for finding in findings:
        match = re.fullmatch(r"F(\d+)", str(finding.get("id", "")))
        if match:
            max_seen = max(max_seen, int(match.group(1)))
    return f"F{max_seen + 1:03d}"


def get_finding(data: dict[str, Any], finding_id: str) -> dict[str, Any]:
    for finding in data["findings"]:
        if finding.get("id") == finding_id:
            return finding
    sys.exit(f"codex-fable5: unknown finding id {finding_id}.")


def require_text(value: str, label: str) -> str:
    text = value.strip()
    if not text:
        sys.exit(f"codex-fable5: {label} must be non-empty.")
    return text


def sort_findings(findings: list[dict[str, Any]]) -> list[dict[str, Any]]:
    return sorted(
        findings,
        key=lambda item: (
            SEVERITY_ORDER.get(str(item.get("severity", "medium")), 99),
            str(item.get("id", "")),
        ),
    )


def format_finding(finding: dict[str, Any]) -> str:
    goal = f" goal={finding['goal']}" if finding.get("goal") else ""
    location = f" location={finding['location']}" if finding.get("location") else ""
    return (
        f"{finding['id']} [{finding['status']}] {finding['severity']} "
        f"{finding['title']}{goal}{location}"
    )


def cmd_add(args: argparse.Namespace) -> None:
    with locked_state():
        data = load_findings()
        finding_id = next_finding_id(data["findings"])
        goal = args.goal.strip() or active_goal_id()
        title = require_text(args.title, "--title")
        evidence = require_text(args.evidence, "--evidence")
        finding = {
            "id": finding_id,
            "goal": goal,
            "title": title,
            "severity": args.severity,
            "source": args.source,
            "status": "open",
            "location": args.location.strip(),
            "evidence": evidence,
            "resolution": "",
            "verify_cmd": "",
            "verify_evidence": "",
            "created": now(),
            "updated": "",
        }
        data["findings"].append(finding)
        save_findings(data)
        append_event(
            "finding_added",
            id=finding_id,
            goal=goal,
            severity=args.severity,
            source=args.source,
            title=finding["title"],
        )
    print(f"codex-fable5: added {finding_id}")
    print(format_finding(finding))


def cmd_list(args: argparse.Namespace) -> None:
    data = load_findings()
    findings = data["findings"]
    if args.status:
        findings = [finding for finding in findings if finding.get("status") == args.status]
    if args.goal:
        findings = [finding for finding in findings if finding.get("goal") == args.goal]

    if not findings:
        print("codex-fable5: no findings")
        return

    for finding in sort_findings(findings):
        print(format_finding(finding))
        if args.verbose:
            print(f"  evidence: {finding.get('evidence', '')}")
            if finding.get("resolution"):
                print(f"  resolution: {finding['resolution']}")
            if finding.get("verify_cmd"):
                print(f"  verify_cmd: {finding['verify_cmd']}")
            if finding.get("verify_evidence"):
                print(f"  verify_evidence: {finding['verify_evidence']}")


def cmd_next(args: argparse.Namespace) -> None:
    data = load_findings()
    findings = [finding for finding in data["findings"] if finding.get("status") == "open"]
    if args.goal:
        findings = [finding for finding in findings if finding.get("goal") == args.goal]
    if not findings:
        print("codex-fable5: no open findings")
        return

    finding = sort_findings(findings)[0]
    print(f"=== codex-fable5 finding: {finding['id']} {finding['title']}")
    print(f"Severity: {finding['severity']}")
    if finding.get("goal"):
        print(f"Goal: {finding['goal']}")
    if finding.get("location"):
        print(f"Location: {finding['location']}")
    print(f"Evidence: {finding['evidence']}")
    print(
        f"On resolution: codex-fable5 findings resolve --id {finding['id']} "
        '--evidence "<what changed>" --verify-evidence "<verification>"'
    )


def cmd_resolve(args: argparse.Namespace) -> None:
    with locked_state():
        data = load_findings()
        finding = get_finding(data, args.id)
        if finding["status"] not in {"open", "blocked"}:
            sys.exit(f"codex-fable5: {args.id} is {finding['status']}; reopen it first.")

        evidence = require_text(args.evidence, "--evidence")
        verify_evidence = require_text(args.verify_evidence, "--verify-evidence")
        finding["status"] = "resolved"
        finding["resolution"] = evidence
        finding["verify_cmd"] = args.verify_cmd.strip()
        finding["verify_evidence"] = verify_evidence
        finding["updated"] = now()
        save_findings(data)
        append_event(
            "finding_resolved",
            id=args.id,
            goal=finding.get("goal", ""),
            verify_cmd=finding["verify_cmd"],
            verify_evidence=finding["verify_evidence"],
        )
    print(f"codex-fable5: {args.id} -> resolved")


def cmd_reject(args: argparse.Namespace) -> None:
    with locked_state():
        data = load_findings()
        finding = get_finding(data, args.id)
        if finding["status"] in TERMINAL_STATUSES:
            sys.exit(f"codex-fable5: {args.id} is already {finding['status']}.")

        reason = require_text(args.reason, "--reason")
        finding["status"] = "rejected"
        finding["resolution"] = reason
        finding["updated"] = now()
        save_findings(data)
        append_event("finding_rejected", id=args.id, goal=finding.get("goal", ""), reason=reason)
    print(f"codex-fable5: {args.id} -> rejected")


def cmd_block(args: argparse.Namespace) -> None:
    with locked_state():
        data = load_findings()
        finding = get_finding(data, args.id)
        if finding["status"] in TERMINAL_STATUSES:
            sys.exit(f"codex-fable5: {args.id} is already {finding['status']}.")

        reason = require_text(args.reason, "--reason")
        finding["status"] = "blocked"
        finding["resolution"] = reason
        finding["updated"] = now()
        save_findings(data)
        append_event("finding_blocked", id=args.id, goal=finding.get("goal", ""), reason=reason)
    print(f"codex-fable5: {args.id} -> blocked")


def cmd_reopen(args: argparse.Namespace) -> None:
    with locked_state():
        data = load_findings()
        finding = get_finding(data, args.id)
        previous_status = finding["status"]
        finding["status"] = "open"
        finding["resolution"] = ""
        finding["verify_cmd"] = ""
        finding["verify_evidence"] = ""
        finding["updated"] = now()
        save_findings(data)
        append_event("finding_reopened", id=args.id, previous_status=previous_status)
    print(f"codex-fable5: {args.id} reopened from {previous_status}")


def cmd_gate(args: argparse.Namespace) -> None:
    data = load_findings()
    blocking_statuses = OPEN_STATUSES if args.allow_blocked else BLOCKING_STATUSES
    blockers = [
        finding
        for finding in data["findings"]
        if finding.get("status") in blocking_statuses
        and (not args.goal or finding.get("goal") == args.goal)
    ]
    blockers = sort_findings(blockers)
    if blockers:
        print(f"codex-fable5: findings gate failed; {len(blockers)} blocking findings remain")
        for finding in blockers:
            print(f"  {format_finding(finding)}")
        sys.exit(1)

    scope = f" for {args.goal}" if args.goal else ""
    print(f"codex-fable5: findings gate passed{scope}")


def cmd_status(_: argparse.Namespace) -> None:
    data = load_findings()
    counts = {
        status: sum(1 for finding in data["findings"] if finding.get("status") == status)
        for status in ["open", "blocked", "resolved", "rejected"]
    }
    summary = ", ".join(f"{count} {status}" for status, count in counts.items() if count)
    if not summary:
        summary = "0 findings"
    print(f"codex-fable5: {summary}")


def build_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(prog="codex-fable5 findings")
    sub = parser.add_subparsers(dest="command", required=True)

    add = sub.add_parser("add")
    add.add_argument("--title", required=True)
    add.add_argument("--evidence", required=True)
    add.add_argument("--severity", choices=["low", "medium", "high", "critical"], default="medium")
    add.add_argument(
        "--source",
        choices=["main", "subagent", "test", "user", "review", "command"],
        default="main",
    )
    add.add_argument("--goal", default="")
    add.add_argument("--location", default="")

    list_cmd = sub.add_parser("list")
    list_cmd.add_argument("--status", choices=["open", "blocked", "resolved", "rejected"])
    list_cmd.add_argument("--goal", default="")
    list_cmd.add_argument("--verbose", action="store_true")

    next_cmd = sub.add_parser("next")
    next_cmd.add_argument("--goal", default="")

    resolve = sub.add_parser("resolve")
    resolve.add_argument("--id", required=True)
    resolve.add_argument("--evidence", required=True)
    resolve.add_argument("--verify-evidence", required=True)
    resolve.add_argument("--verify-cmd", dest="verify_cmd", default="")

    reject = sub.add_parser("reject")
    reject.add_argument("--id", required=True)
    reject.add_argument("--reason", required=True)

    block = sub.add_parser("block")
    block.add_argument("--id", required=True)
    block.add_argument("--reason", required=True)

    reopen = sub.add_parser("reopen")
    reopen.add_argument("--id", required=True)

    gate = sub.add_parser("gate")
    gate.add_argument("--goal", default="")
    gate.add_argument("--allow-blocked", action="store_true")

    sub.add_parser("status")
    return parser


def main() -> int:
    args = build_parser().parse_args()
    handlers = {
        "add": cmd_add,
        "list": cmd_list,
        "next": cmd_next,
        "resolve": cmd_resolve,
        "reject": cmd_reject,
        "block": cmd_block,
        "reopen": cmd_reopen,
        "gate": cmd_gate,
        "status": cmd_status,
    }
    handlers[args.command](args)
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

#!/usr/bin/env python3
"""Codex Fable5 goal ledger with evidence checkpoints and a final verification gate."""

from __future__ import annotations

import argparse
import sys
from pathlib import Path
from typing import Any

from codex_fable_state import (
    FINDINGS_FILE,
    GOALS_FILE,
    LEDGER_FILE,
    LOCK_FILE,
    STATE_DIR,
    append_event,
    locked_state,
    now,
    read_json,
    require_object,
    write_json,
)

OPEN_STATUSES = {"pending", "in_progress"}
INCOMPLETE_TERMINAL_STATUSES = {"failed", "blocked"}
BLOCKING_FINDING_STATUSES = {"open", "blocked"}
GOAL_STATUSES = {"pending", "in_progress", "complete", "failed", "blocked"}
GOAL_REQUIRED_FIELDS = {"id", "title", "objective", "status", "evidence", "verify_cmd", "verify_evidence"}
FINDING_STATUSES = {"open", "blocked", "resolved", "rejected"}
FINDING_REQUIRED_FIELDS = {"id", "goal", "title", "severity", "source", "status", "evidence"}


def safe_stamp() -> str:
    return now().replace(":", "").replace("+", "Z")


def validate_plan(data: dict[str, Any], path: Path, label: str) -> dict[str, Any]:
    if not isinstance(data.get("brief"), str):
        sys.exit(f"codex-fable5: {label} field 'brief' must be a string ({path}).")
    goals = data.get("goals")
    if not isinstance(goals, list):
        sys.exit(f"codex-fable5: {label} field 'goals' must be a list ({path}).")
    if not goals:
        sys.exit(f"codex-fable5: {label} field 'goals' must contain at least one goal ({path}).")
    for index, goal in enumerate(goals, 1):
        if not isinstance(goal, dict):
            sys.exit(f"codex-fable5: {label} goal {index} must be an object ({path}).")
        missing = sorted(GOAL_REQUIRED_FIELDS - goal.keys())
        if missing:
            fields = ", ".join(missing)
            sys.exit(f"codex-fable5: {label} goal {index} is missing {fields} ({path}).")
        status = goal.get("status")
        if not isinstance(status, str) or status not in GOAL_STATUSES:
            sys.exit(f"codex-fable5: {label} goal {index} has invalid status {status!r} ({path}).")
    return data


def validate_findings(data: dict[str, Any], path: Path, label: str) -> dict[str, Any]:
    data.setdefault("findings", [])
    findings = data.get("findings")
    if not isinstance(findings, list):
        sys.exit(f"codex-fable5: {label} field 'findings' must be a list ({path}).")
    for index, finding in enumerate(findings, 1):
        if not isinstance(finding, dict):
            sys.exit(f"codex-fable5: {label} finding {index} must be an object ({path}).")
        missing = sorted(FINDING_REQUIRED_FIELDS - finding.keys())
        if missing:
            fields = ", ".join(missing)
            sys.exit(f"codex-fable5: {label} finding {index} is missing {fields} ({path}).")
        status = finding.get("status")
        if not isinstance(status, str) or status not in FINDING_STATUSES:
            sys.exit(f"codex-fable5: {label} finding {index} has invalid status {status!r} ({path}).")
    return data


def load_plan() -> dict[str, Any]:
    if not GOALS_FILE.exists():
        sys.exit("codex-fable5: no goal plan. Run `create` from the repo root first.")
    data = require_object(read_json(GOALS_FILE, "goal plan"), GOALS_FILE, "goal plan")
    return validate_plan(data, GOALS_FILE, "goal plan")


def parse_goal(raw: str, index: int) -> dict[str, Any]:
    if "::" not in raw:
        sys.exit(f"codex-fable5: goal {index} must use 'title::objective' format.")
    title, objective = raw.split("::", 1)
    title = title.strip()
    objective = objective.strip()
    if not title or not objective:
        sys.exit(f"codex-fable5: goal {index} needs both title and objective.")
    return {
        "id": f"G{index:03d}",
        "title": title,
        "objective": objective,
        "status": "pending",
        "evidence": "",
        "verify_cmd": "",
        "verify_evidence": "",
    }


def incomplete_terminal_summary(goals: list[dict[str, Any]]) -> str:
    counts = {
        status: sum(1 for goal in goals if goal["status"] == status)
        for status in sorted(INCOMPLETE_TERMINAL_STATUSES)
    }
    return ", ".join(f"{count} {status}" for status, count in counts.items() if count)


def terminal_incomplete_goals(goals: list[dict[str, Any]]) -> list[dict[str, Any]]:
    return [goal for goal in goals if goal["status"] in INCOMPLETE_TERMINAL_STATUSES]


def archive_findings_for_force() -> None:
    if not FINDINGS_FILE.exists():
        return
    archive_path = STATE_DIR / f"findings.{safe_stamp()}.archive.json"
    FINDINGS_FILE.replace(archive_path)
    append_event(
        "findings_archived",
        reason="goals_create_force",
        path=str(archive_path),
    )


def blocking_findings() -> list[dict[str, Any]]:
    if not FINDINGS_FILE.exists():
        return []
    data = require_object(read_json(FINDINGS_FILE, "findings ledger"), FINDINGS_FILE, "findings ledger")
    data = validate_findings(data, FINDINGS_FILE, "findings ledger")
    return [
        finding
        for finding in data.get("findings", [])
        if finding.get("status") in BLOCKING_FINDING_STATUSES
    ]


def cmd_create(args: argparse.Namespace) -> None:
    goals = [parse_goal(raw, index) for index, raw in enumerate(args.goal, 1)]
    if not goals:
        sys.exit("codex-fable5: at least one --goal is required.")
    plan = {"brief": args.brief, "created": now(), "goals": goals}
    with locked_state():
        if GOALS_FILE.exists() and not args.force:
            sys.exit("codex-fable5: plan already exists. Use `status` or replace it with --force.")
        write_json(GOALS_FILE, plan)
        if args.force:
            archive_findings_for_force()
        append_event("plan_created", brief=args.brief, count=len(goals))
    print(f"codex-fable5: plan created with {len(goals)} stories")
    for goal in goals:
        print(f"  {goal['id']} {goal['title']}: {goal['objective']}")


def cmd_next(_: argparse.Namespace) -> None:
    with locked_state():
        plan = load_plan()
        active = [goal for goal in plan["goals"] if goal["status"] == "in_progress"]
        if active:
            goal = active[0]
        else:
            incomplete = terminal_incomplete_goals(plan["goals"])
            if incomplete:
                goal = incomplete[0]
                previous_status = goal["status"]
                goal["status"] = "in_progress"
                write_json(GOALS_FILE, plan)
                append_event(
                    "story_reopened",
                    id=goal["id"],
                    title=goal["title"],
                    previous_status=previous_status,
                )
                print(f"Reopened {goal['id']} from {previous_status}.")
            else:
                pending = [goal for goal in plan["goals"] if goal["status"] == "pending"]
                if not pending:
                    print("codex-fable5: all stories complete")
                    return
                goal = pending[0]
                goal["status"] = "in_progress"
                write_json(GOALS_FILE, plan)
                append_event("story_started", id=goal["id"], title=goal["title"])

        is_final = goal["id"] == plan["goals"][-1]["id"]
        print(f"=== codex-fable5 handoff: {goal['id']} {goal['title']}")
        print(f"Objective: {goal['objective']}")
        print("Rule: work this story only and produce concrete evidence.")
        command = (
            f"codex-fable5 goals checkpoint --id {goal['id']} --status complete "
            '--evidence "<evidence>"'
        )
        if is_final:
            print("Final story: completion requires --verify-cmd and --verify-evidence.")
            command += ' --verify-cmd "<command>" --verify-evidence "<result>"'
        print(f"On completion: {command}")


def cmd_checkpoint(args: argparse.Namespace) -> None:
    with locked_state():
        plan = load_plan()
        goal = next((item for item in plan["goals"] if item["id"] == args.id), None)
        if goal is None:
            sys.exit(f"codex-fable5: unknown goal id {args.id}.")
        if goal["status"] != "in_progress":
            sys.exit(f"codex-fable5: {args.id} is {goal['status']}; activate it with `next` first.")

        evidence = args.evidence.strip()
        verify_cmd = args.verify_cmd.strip()
        verify_evidence = args.verify_evidence.strip()
        if args.status == "complete":
            if not evidence:
                sys.exit("codex-fable5: complete checkpoints require non-empty --evidence.")
            if goal["id"] == plan["goals"][-1]["id"] and not (verify_cmd and verify_evidence):
                sys.exit("codex-fable5: final story requires --verify-cmd and --verify-evidence.")
            if goal["id"] == plan["goals"][-1]["id"]:
                findings = blocking_findings()
                if findings:
                    ids = ", ".join(str(finding.get("id", "?")) for finding in findings)
                    sys.exit(
                        "codex-fable5: final story requires findings gate; "
                        f"{len(findings)} blocking findings remain ({ids})."
                    )

        goal["status"] = args.status
        goal["evidence"] = evidence
        goal["verify_cmd"] = verify_cmd
        goal["verify_evidence"] = verify_evidence
        write_json(GOALS_FILE, plan)
        append_event(
            "checkpoint",
            id=goal["id"],
            status=args.status,
            evidence=evidence,
            verify_cmd=verify_cmd,
            verify_evidence=verify_evidence,
        )
        remaining = [item for item in plan["goals"] if item["status"] in OPEN_STATUSES]
        print(f"codex-fable5: {goal['id']} -> {args.status}")
        if terminal_incomplete_goals(plan["goals"]):
            summary = incomplete_terminal_summary(plan["goals"])
            print(f"codex-fable5: plan is not complete; {summary}.")
            if remaining:
                print(f"codex-fable5: {len(remaining)} open stories remain blocked.")
        elif remaining:
            print(f"codex-fable5: {len(remaining)} stories left")
        else:
            print("codex-fable5: all stories complete")


def cmd_status(_: argparse.Namespace) -> None:
    plan = load_plan()
    done = sum(1 for goal in plan["goals"] if goal["status"] == "complete")
    print(f"codex-fable5: {done}/{len(plan['goals'])} complete - {plan['brief']}")
    markers = {
        "complete": "done",
        "in_progress": "active",
        "pending": "pending",
        "failed": "failed",
        "blocked": "blocked",
    }
    for goal in plan["goals"]:
        marker = markers.get(goal["status"], goal["status"])
        print(f"  {goal['id']} [{marker}] {goal['title']}")
        if goal.get("evidence"):
            print(f"    evidence: {goal['evidence']}")


def build_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(prog="codex-fable5 goals")
    sub = parser.add_subparsers(dest="command", required=True)

    create = sub.add_parser("create")
    create.add_argument("--brief", required=True)
    create.add_argument("--goal", action="append", default=[])
    create.add_argument("--force", action="store_true")

    sub.add_parser("next")

    checkpoint = sub.add_parser("checkpoint")
    checkpoint.add_argument("--id", required=True)
    checkpoint.add_argument("--status", required=True, choices=["complete", "failed", "blocked"])
    checkpoint.add_argument("--evidence", default="")
    checkpoint.add_argument("--verify-cmd", dest="verify_cmd", default="")
    checkpoint.add_argument("--verify-evidence", dest="verify_evidence", default="")

    sub.add_parser("status")
    return parser


def main() -> int:
    args = build_parser().parse_args()
    handlers = {
        "create": cmd_create,
        "next": cmd_next,
        "checkpoint": cmd_checkpoint,
        "status": cmd_status,
    }
    handlers[args.command](args)
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

#!/usr/bin/env python3
"""Validate Fable section coverage against the Codex adaptation matrix."""

from __future__ import annotations

import argparse
import re
import sys
from collections import Counter
from pathlib import Path

ALLOWED_STATUSES = {"implemented", "adapted", "unsupported", "not_applicable"}


def normalize_status(raw: str) -> str:
    return raw.strip().lower().replace(" ", "_").replace("-", "_")


def extract_source_sections(path: Path) -> list[str]:
    headings: list[tuple[int, str]] = []
    for line in path.read_text(encoding="utf-8").splitlines():
        match = re.match(r"^(#{1,6})\s+(.+?)\s*$", line)
        if match:
            headings.append((len(match.group(1)), match.group(2).strip()))
    if not headings:
        return []

    base_level = 1 if any(level == 1 for level, _ in headings) else min(level for level, _ in headings) - 1
    stack: dict[int, str] = {}
    sections: list[str] = []
    for level, title in headings:
        for stale_level in [item for item in stack if item >= level]:
            del stack[stale_level]
        stack[level] = title
        if level > base_level:
            parts = [stack[item] for item in sorted(stack) if base_level < item <= level]
            sections.append(" > ".join(parts))
    return sections


def extract_matrix(path: Path) -> dict[str, str]:
    rows: dict[str, str] = {}
    for line_no, line in enumerate(path.read_text(encoding="utf-8").splitlines(), 1):
        stripped = line.strip()
        if not stripped.startswith("|"):
            continue
        cells = [cell.strip() for cell in stripped.strip("|").split("|")]
        if len(cells) < 2 or cells[0].lower() in {"source section", "---"}:
            continue
        match = re.fullmatch(r"`(.+?)`", cells[0])
        if not match:
            continue
        section = match.group(1)
        status = normalize_status(cells[1])
        if status not in ALLOWED_STATUSES:
            sys.exit(f"{path}:{line_no}: invalid status {cells[1]!r} for {section!r}")
        if section in rows:
            sys.exit(f"{path}:{line_no}: duplicate section {section!r}")
        rows[section] = status
    if not rows:
        sys.exit(f"{path}: no coverage rows found")
    return rows


def main() -> int:
    parser = argparse.ArgumentParser()
    skill_root = Path(__file__).resolve().parents[1]
    parser.add_argument(
        "--matrix",
        type=Path,
        default=skill_root / "references" / "coverage-matrix.md",
        help="Coverage matrix markdown file.",
    )
    parser.add_argument(
        "--source",
        type=Path,
        help="Optional CLAUDE-FABLE-5.md source file. When supplied, headings must match the matrix.",
    )
    args = parser.parse_args()

    matrix_rows = extract_matrix(args.matrix)
    status_counts = Counter(matrix_rows.values())

    if args.source:
        source_sections = extract_source_sections(args.source)
        source_set = set(source_sections)
        matrix_set = set(matrix_rows)
        missing = sorted(source_set - matrix_set)
        extra = sorted(matrix_set - source_set)
        if missing or extra:
            if missing:
                print("Missing source sections:", file=sys.stderr)
                for item in missing:
                    print(f"  - {item}", file=sys.stderr)
            if extra:
                print("Extra matrix sections:", file=sys.stderr)
                for item in extra:
                    print(f"  - {item}", file=sys.stderr)
            return 1
        pct = (len(matrix_rows) / len(source_sections)) * 100 if source_sections else 0
        print(
            f"codex-fable5: source headings {len(source_sections)}, "
            f"matrix rows {len(matrix_rows)}, accounted {len(matrix_rows)}/{len(source_sections)} ({pct:.1f}%)"
        )
    else:
        print(f"codex-fable5: matrix rows {len(matrix_rows)}")

    print("codex-fable5: statuses " + ", ".join(f"{key}={status_counts[key]}" for key in sorted(status_counts)))
    print("codex-fable5: coverage matrix valid")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

#!/usr/bin/env python3
"""Generate a small LiteLLM config for routing a Codex provider to Anthropic."""

from __future__ import annotations

import argparse
from pathlib import Path

DEFAULT_MODEL = "replace-with-current-anthropic-model"


def q(value: str) -> str:
    return '"' + value.replace("\\", "\\\\").replace('"', '\\"') + '"'


def build_config(model: str, alias: str) -> str:
    provider_model = model if model.startswith("anthropic/") else f"anthropic/{model}"
    return "\n".join(
        [
            "# Example only. Replace the model with one that official Anthropic docs",
            "# and your account currently show as available.",
            "model_list:",
            "  - model_name: " + q(alias),
            "    litellm_params:",
            "      model: " + q(provider_model),
            "      api_key: os.environ/ANTHROPIC_API_KEY",
            "",
            "litellm_settings:",
            "  modify_params: true",
            "  drop_params: true",
            "",
        ]
    )


def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument(
        "--model",
        default=DEFAULT_MODEL,
        help="Anthropic model name; verify official availability and account access first.",
    )
    parser.add_argument("--alias", default=None, help="Model name Codex should send to LiteLLM.")
    parser.add_argument("--output", "-o", default="-", help="Output YAML path, or '-' for stdout.")
    args = parser.parse_args()

    alias = args.alias or args.model.removeprefix("anthropic/")
    text = build_config(args.model, alias)

    if args.output == "-":
        print(text, end="")
    else:
        path = Path(args.output)
        path.write_text(text, encoding="utf-8")
        print(f"Wrote {path}")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())