director-cli 0.3.0__tar.gz → 0.4.0__tar.gz

director_cli-0.4.0/CHANGELOG.md

@@ -0,0 +1,62 @@
+# CHANGELOG
+
+
+## v0.4.0 (2026-06-25)
+
+### Continuous Integration
+
+- Install build in semantic-release build_command (container lacks it)
+  ([`0bdd056`](https://github.com/manziman/director/commit/0bdd05666f86a93ec37cd7738075eea7ac50143a))
+
+Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
+
+- Make releases manual-only (workflow_dispatch, not every push to main)
+  ([`bddcb57`](https://github.com/manziman/director/commit/bddcb5753a66f11059d47e78a4b54168d5f1b4e0))
+
+Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
+
+- Push releases to protected main via a RELEASE_TOKEN PAT
+  ([#4](https://github.com/manziman/director/pull/4),
+  [`776db5b`](https://github.com/manziman/director/commit/776db5b3e2ab23acedd820ebba47b538a823cacf))
+
+main requires PRs, so the default GITHUB_TOKEN can't push semantic-release's version commit + tag.
+  Use a RELEASE_TOKEN secret (a PAT with Contents:write whose owner is on the main ruleset bypass
+  list) for checkout + the semantic-release action. Falls back to GITHUB_TOKEN when unset. PyPI
+  publishing is unaffected (OIDC).
+
+### Features
+
+- Add Claude Code agent-runtime provider
+  ([`71b0819`](https://github.com/manziman/director/commit/71b081998969ec9e0db7f16884eba015cf9fad2f))
+
+Per-role runtime via the tier model-string prefix (claude-code/<model> → claude CLI; anything else →
+  opencode). Includes the live-caught dispatch fix and the prefix-selection refactor from PR review.
+  Tests stub the subprocess — no model/network in CI.
+
+- Add interactive `director init` command
+  ([`8e8ba7d`](https://github.com/manziman/director/commit/8e8ba7da4489ee7da10b70b8d755fb3eb861e440))
+
+`director init` configures .director/config.toml by asking questions instead of copying a static
+  example: it discovers models via `opencode models`, lets the user pick one per role, prompts for
+  the test/lint/typecheck gate commands, and writes a minimal config (with a pointer to
+  config.example.toml for advanced sections). `sync-agents` no longer seeds the config; the "missing
+  config" error now points at `director init`.
+
+Built end-to-end with director dogfooding itself (planner: Opus 4.8, executor: local Qwen3.6-27B):
+  5/5 nodes at the executor tier first attempt, integration gate green.
+
+
+## v0.3.0 (2026-06-24)
+
+### Documentation
+
+- Move design lessons inline; drop the standalone lessons doc
+  ([`134c202`](https://github.com/manziman/director/commit/134c202e9e1df98bc20d1f7a51ab7619dd2a55fe))
+
+The cross-phase lessons now live as comments at their point in the code (gitignore handling in
+  setup/gates/opencode, deterministic-gates in gates/review/opencode, config-as-object in
+  config/bench, non-fatal cleanup in bench, terminal-state scheduling in run). CONTRIBUTING points
+  to those locations; the two process notes (offline-stubs-vs-live, wall-clock cutoffs) live in the
+  tests docstring and CONTRIBUTING. The standalone docs/lessons-learned.md is removed from the repo.
+
+Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

{director_cli-0.3.0 → director_cli-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: director-cli
-Version: 0.3.0
+Version: 0.4.0
 Summary: Model-agnostic decomposition coding harness — a thin orchestrator over OpenCode
 Project-URL: Homepage, https://github.com/manziman/director
 Project-URL: Repository, https://github.com/manziman/director
@@ -78,11 +78,14 @@ director never manages provider keys itself — that lives in your OpenCode conf
 ```bash
 cd your-repo
 
-# 1. Install director's role agents into .opencode/ and seed .director/config.toml
+# 1. Install director's role agents (+ gitignore, starter opencode.json) into .opencode/
 director sync-agents
 
-# 2. Edit .director/config.toml — bind roles to models, set your gate commands.
-#    (sync-agents seeded it from the bundled, fully-commented example.)
+# 2. Create .director/config.toml interactively — director init asks which model to
+#    use per role and what your gate commands are, then writes the config for you.
+director init
+#    (See director/config.example.toml for the full/advanced schema if you want to
+#     hand-tune beyond what init prompts for.)
 $EDITOR .director/config.toml
 
 # 3. Plan: brainstorm → spec → test-gated task DAG (two approval gates)
@@ -117,17 +120,20 @@ director run
 | `director run [--parallel N] [--max-attempts K]` | Execute the DAG: each node in an isolated git worktree, gated by tests/lint/typecheck, auto-merged on pass; escalates a stuck node one tier up. |
 | `director status` | Per-node progress, attempts, cost, and the executor-tier completion rate. |
 | `director bench "<task>" --profiles a,b,c` | Run the **same** task (same frozen acceptance tests) across profile variants and diff cost / quality / wall-time. |
-| `director sync-agents` | (Re)install the role agents into `<repo>/.opencode` and seed `.director/config.toml`. |
+| `director init [--repo .]` | Interactively create `.director/config.toml` — asks which model to use per role and your gate commands. |
+| `director sync-agents` | (Re)install the role agents into `<repo>/.opencode` (plus a gitignore and a starter `opencode.json`). |
 
 All state lives under `.director/` (resumable, debuggable): `plan.json`, `state.json`,
 `costs.jsonl`, `metrics.jsonl`, per-call `logs/`, and `bench/`.
 
 ## Configuration
 
-`director sync-agents` seeds `.director/config.toml` from a complete, commented example
-(also at [`director/config.example.toml`](director/config.example.toml)). A config is
-just roles → `provider/model` strings, the deterministic gate commands, per-model
-pricing, and run limits — the example shows how to bind the executor tier to a local
+`director init` interactively creates `.director/config.toml` — it asks which model
+to use for each role and what your deterministic gate commands are, then writes the
+config for you. A config is just roles → `provider/model` strings, the deterministic
+gate commands, per-model pricing, and run limits. For the full/advanced schema, see
+the complete, commented [`director/config.example.toml`](director/config.example.toml):
+it shows how to bind the executor tier to a local
 model (≈ $0 implementation), a low-cost cloud model (zero local infra), or a frontier
 model (the expensive baseline). See [`director/README.md`](director/README.md) for the
 full architecture (gates, two-stage review, red-green hardening, metrics).

{director_cli-0.3.0 → director_cli-0.4.0}/README.md

@@ -53,11 +53,14 @@ director never manages provider keys itself — that lives in your OpenCode conf
 ```bash
 cd your-repo
 
-# 1. Install director's role agents into .opencode/ and seed .director/config.toml
+# 1. Install director's role agents (+ gitignore, starter opencode.json) into .opencode/
 director sync-agents
 
-# 2. Edit .director/config.toml — bind roles to models, set your gate commands.
-#    (sync-agents seeded it from the bundled, fully-commented example.)
+# 2. Create .director/config.toml interactively — director init asks which model to
+#    use per role and what your gate commands are, then writes the config for you.
+director init
+#    (See director/config.example.toml for the full/advanced schema if you want to
+#     hand-tune beyond what init prompts for.)
 $EDITOR .director/config.toml
 
 # 3. Plan: brainstorm → spec → test-gated task DAG (two approval gates)
@@ -92,17 +95,20 @@ director run
 | `director run [--parallel N] [--max-attempts K]` | Execute the DAG: each node in an isolated git worktree, gated by tests/lint/typecheck, auto-merged on pass; escalates a stuck node one tier up. |
 | `director status` | Per-node progress, attempts, cost, and the executor-tier completion rate. |
 | `director bench "<task>" --profiles a,b,c` | Run the **same** task (same frozen acceptance tests) across profile variants and diff cost / quality / wall-time. |
-| `director sync-agents` | (Re)install the role agents into `<repo>/.opencode` and seed `.director/config.toml`. |
+| `director init [--repo .]` | Interactively create `.director/config.toml` — asks which model to use per role and your gate commands. |
+| `director sync-agents` | (Re)install the role agents into `<repo>/.opencode` (plus a gitignore and a starter `opencode.json`). |
 
 All state lives under `.director/` (resumable, debuggable): `plan.json`, `state.json`,
 `costs.jsonl`, `metrics.jsonl`, per-call `logs/`, and `bench/`.
 
 ## Configuration
 
-`director sync-agents` seeds `.director/config.toml` from a complete, commented example
-(also at [`director/config.example.toml`](director/config.example.toml)). A config is
-just roles → `provider/model` strings, the deterministic gate commands, per-model
-pricing, and run limits — the example shows how to bind the executor tier to a local
+`director init` interactively creates `.director/config.toml` — it asks which model
+to use for each role and what your deterministic gate commands are, then writes the
+config for you. A config is just roles → `provider/model` strings, the deterministic
+gate commands, per-model pricing, and run limits. For the full/advanced schema, see
+the complete, commented [`director/config.example.toml`](director/config.example.toml):
+it shows how to bind the executor tier to a local
 model (≈ $0 implementation), a low-cost cloud model (zero local infra), or a frontier
 model (the expensive baseline). See [`director/README.md`](director/README.md) for the
 full architecture (gates, two-stage review, red-green hardening, metrics).

{director_cli-0.3.0 → director_cli-0.4.0}/director/README.md

@@ -12,7 +12,8 @@ director plan "<task>" --auto --no-critique   # gates auto-pass, fully hands-off
 director run [--repo .] [--parallel N] [--max-attempts K]
 director status [--repo .]
 director bench "<task>" --profiles all-frontier,cheap-cloud,local-first [--plan-profile P]
-director sync-agents [--repo .]               # (re)install role agents into <repo>/.opencode
+director init [--repo .]                      # interactively create .director/config.toml (per-role models + gate commands)
+director sync-agents [--repo .]               # (re)install role agents into <repo>/.opencode (+ gitignore, starter opencode.json)
 ```
 
 ## Flow
@@ -91,8 +92,11 @@ Per-profile metrics streams and a `summary.json` land in `.director/bench/`.
 Roles bind to `provider/model` strings in `.director/config.toml` (`[tiers]`).
 Code/logs name only roles. `director` passes the resolved model via `opencode run
 --agent <role> --model <tier>`, so **switching executor models is a config edit,
-never a code change.** `sync-agents` seeds `.director/config.toml` from the bundled
-`config.example.toml`; edit it to bind roles to models. For `bench`, create
+never a code change.** `director init` interactively creates `.director/config.toml`,
+asking which model to use per role and what your gate commands are; `sync-agents` only
+installs the role agents (plus a gitignore and a starter `opencode.json`) and no longer
+writes the config. See the bundled `config.example.toml` for the full/advanced schema.
+For `bench`, create
 `.director/profiles/<name>.toml` variants (copy `config.toml`, change the executor tier).
 
 ## Deliberate deviations from the spec

{director_cli-0.3.0 → director_cli-0.4.0}/director/__init__.py

@@ -7,4 +7,4 @@ typecheck, exit codes — never an LLM judge) decide what merges. Roles bind to
 model tiers in `.director/config.toml`; nothing here knows "local" vs "cloud".
 """
 
-__version__ = "0.3.0"
+__version__ = "0.4.0"

director_cli-0.4.0/director/claudecode.py

@@ -0,0 +1,269 @@
+"""Headless Claude Code driver.
+
+Wraps `claude -p <message>` with bundled system-prompt templates and parses the
+JSON / NDJSON output into a structured RunResult.  Stdlib only."""
+
+from __future__ import annotations
+
+import contextlib
+import importlib.resources as ir
+import json
+import subprocess
+from pathlib import Path
+
+from director.opencode import _CLEAN_ENV, RunResult
+
+# --------------------------------------------------------------------------- #
+# system_prompt_for
+# --------------------------------------------------------------------------- #
+
+
+def system_prompt_for(agent: str) -> str:
+    """Return the bundled template for *agent* with YAML frontmatter stripped."""
+    filename = agent.replace("_", "-") + ".md"
+    tpl = ir.files("director.agent_templates").joinpath(filename).read_text()
+    stripped_tpl = tpl.lstrip("\n")
+    lines = stripped_tpl.splitlines()
+    if lines and lines[0] == "---":
+        closer = -1
+        for i in range(1, len(lines)):
+            if lines[i] == "---":
+                closer = i
+                break
+        if closer != -1:
+            return "\n".join(lines[closer + 1 :]).strip()
+    return tpl.strip()
+
+
+# --------------------------------------------------------------------------- #
+# run_claude
+# --------------------------------------------------------------------------- #
+
+
+def run_claude(
+    *,
+    agent: str,
+    model: str,
+    message: str,
+    cwd: str | Path,
+    log_path: str | Path,
+    timeout: int,
+) -> RunResult:
+    """Invoke Claude Code headlessly.  Never raises on CLI / model failure."""
+    log_path = Path(log_path)
+    log_path.parent.mkdir(parents=True, exist_ok=True)
+    err_path = log_path.with_suffix(log_path.suffix + ".stderr")
+
+    cmd = [
+        "claude",
+        "-p",
+        message,
+        "--output-format",
+        "json",
+        "--model",
+        model,
+        "--append-system-prompt",
+        system_prompt_for(agent),
+        "--dangerously-skip-permissions",
+    ]
+
+    timed_out = False
+    with open(log_path, "wb") as out, open(err_path, "wb") as err:
+        proc = subprocess.Popen(cmd, cwd=str(cwd), stdout=out, stderr=err, env=_CLEAN_ENV)
+        try:
+            rc = proc.wait(timeout=timeout)
+        except subprocess.TimeoutExpired:
+            with contextlib.suppress(AttributeError, OSError):
+                proc.kill()
+            with contextlib.suppress(Exception):
+                proc.wait()
+            rc = 124
+            timed_out = True
+
+    return _parse_claude(log_path, rc, timed_out)
+
+
+# --------------------------------------------------------------------------- #
+# _parse_claude
+# --------------------------------------------------------------------------- #
+
+
+def _parse_claude(log_path: Path, rc: int, timed_out: bool) -> RunResult:
+    """Shape-tolerant parser for Claude Code JSON / NDJSON output."""
+    text_parts: list[str] = []
+    tokens = {
+        "input": 0,
+        "output": 0,
+        "reasoning": 0,
+        "cache_read": 0,
+        "cache_write": 0,
+        "total": 0,
+    }
+    n_steps: int | None = None
+    tool_calls: list[tuple[str, str]] = []
+    tool_events: list[dict] = []
+    error: str | None = None
+
+    raw = log_path.read_text(errors="replace")
+    stripped = raw.strip()
+
+    # Try single JSON object first.
+    records: list[dict] = []
+    if stripped:
+        try:
+            obj = json.loads(stripped)
+            if isinstance(obj, dict):
+                records.append(obj)
+            elif isinstance(obj, list):
+                for item in obj:
+                    if isinstance(item, dict):
+                        records.append(item)
+        except json.JSONDecodeError:
+            # Fall through to NDJSON line-by-line.
+            pass
+
+    if not records:
+        for line in raw.splitlines():
+            line = line.strip()
+            if not line.startswith("{"):
+                continue
+            try:
+                obj = json.loads(line)
+                if isinstance(obj, dict):
+                    records.append(obj)
+            except json.JSONDecodeError:
+                continue
+
+    # --- aggregate across all parsed records ---------------------------------
+    total_cost = 0.0
+    has_num_turns = False
+    assistant_count = 0
+
+    for rec in records:
+        # -- text -------------------------------------------------------------
+        result_val = rec.get("result")
+        if isinstance(result_val, str):
+            text_parts.append(result_val)
+
+        msg = rec.get("message") or {}
+        content = msg.get("content") if isinstance(msg, dict) else None
+        if isinstance(content, str):
+            text_parts.append(content)
+        elif isinstance(content, list):
+            for seg in content:
+                if isinstance(seg, dict) and seg.get("type") == "text":
+                    t = seg.get("text", "")
+                    if isinstance(t, str):
+                        text_parts.append(t)
+
+        # -- tool calls inside message.content ---------------------------------
+        if isinstance(content, list):
+            for seg in content:
+                if isinstance(seg, dict) and seg.get("type") == "tool_use":
+                    _collect_tool(seg, tool_calls, tool_events)
+
+        # -- top-level tool records -------------------------------------------
+        rec_type = rec.get("type", "")
+        if rec_type in ("tool_use", "tool_result"):
+            name = rec.get("name") or rec.get("tool", "?")
+            status = rec.get("status") or rec.get("state", "?")
+            _collect_tool_entry(str(name), str(status), rec, tool_calls, tool_events)
+
+        # -- tokens -----------------------------------------------------------
+        usage = rec.get("usage")
+        if not isinstance(usage, dict):
+            msg_usage = (msg if isinstance(msg, dict) else {}).get("usage")
+            if isinstance(msg_usage, dict):
+                usage = msg_usage
+        if isinstance(usage, dict):
+            tokens["input"] += int(usage.get("input_tokens") or 0)
+            tokens["output"] += int(usage.get("output_tokens") or 0)
+            cr = usage.get("cache_read_input_tokens")
+            if cr is not None:
+                tokens["cache_read"] += int(cr)
+            cw = usage.get("cache_creation_input_tokens")
+            if cw is not None:
+                tokens["cache_write"] += int(cw)
+            reasoning_val = usage.get("reasoning") or usage.get("reasoning_tokens")
+            if reasoning_val is not None:
+                tokens["reasoning"] += int(reasoning_val)
+
+        # -- cost -------------------------------------------------------------
+        tc = rec.get("total_cost_usd")
+        if tc is not None:
+            total_cost += float(tc)
+
+        # -- n_steps ----------------------------------------------------------
+        nt = rec.get("num_turns")
+        if nt is not None and not has_num_turns:
+            n_steps = int(nt)
+            has_num_turns = True
+
+        if rec_type == "assistant":
+            assistant_count += 1
+
+        # -- error ------------------------------------------------------------
+        if rec.get("is_error"):
+            error = str(rec.get("error") or rec.get("subtype") or "error occurred")
+        elif rec_type in ("error",) and (rec.get("error") or rec.get("subtype")):
+            error = str(rec.get("error") or rec.get("subtype"))
+
+    # -- finalize tokens ------------------------------------------------------
+    if tokens["total"] == 0:
+        total_tok = None
+        for rec in records:
+            usage = rec.get("usage")
+            if not isinstance(usage, dict):
+                msg_usage = (
+                    rec.get("message", {}) if isinstance(rec.get("message"), dict) else {}
+                ).get("usage")
+                if isinstance(msg_usage, dict):
+                    usage = msg_usage
+            if isinstance(usage, dict):
+                tt = usage.get("total_tokens")
+                if tt is not None:
+                    total_tok = int(tt)
+        if total_tok is not None:
+            tokens["total"] = total_tok
+        else:
+            tokens["total"] = tokens["input"] + tokens["output"]
+
+    # -- finalize n_steps -----------------------------------------------------
+    if n_steps is None:
+        n_steps = assistant_count if assistant_count > 0 else 0
+
+    # -- finalize error -------------------------------------------------------
+    text = "".join(text_parts).strip()
+    if rc != 0 and not text and error is None:
+        error = f"non-zero exit code {rc}"
+
+    return RunResult(
+        returncode=rc,
+        text=text,
+        tokens=tokens,
+        cost_reported=total_cost,
+        n_steps=n_steps,
+        tool_calls=tool_calls,
+        tool_events=tool_events,
+        error=error,
+        timed_out=timed_out,
+        log_path=str(log_path),
+    )
+
+
+def _collect_tool(seg: dict, tool_calls: list[tuple[str, str]], tool_events: list[dict]) -> None:
+    name = seg.get("name", "?")
+    status = "?"
+    _collect_tool_entry(str(name), status, seg, tool_calls, tool_events)
+
+
+def _collect_tool_entry(
+    name: str,
+    status: str,
+    record: dict,
+    tool_calls: list[tuple[str, str]],
+    tool_events: list[dict],
+) -> None:
+    tool_calls.append((name, status))
+    blob = json.dumps(record, default=str)[:2000].lower()
+    tool_events.append({"name": name.lower(), "status": status, "blob": blob})

{director_cli-0.3.0 → director_cli-0.4.0}/director/cli.py

@@ -1,4 +1,4 @@
-"""director CLI — plan | run | status | bench | sync-agents."""
+"""director CLI — plan | run | status | bench | sync-agents | init."""
 
 from __future__ import annotations
 
@@ -78,6 +78,14 @@ def cmd_sync_agents(args) -> int:
     return 0
 
 
+def cmd_init(args) -> int:
+    from director.init import run_init
+
+    path = run_init(args.repo)
+    print(f"Wrote {path}")
+    return 0
+
+
 def build_parser() -> argparse.ArgumentParser:
     p = argparse.ArgumentParser(prog="director", description=__doc__)
     p.add_argument("--version", action="version", version=f"director {__version__}")
@@ -150,6 +158,10 @@ def build_parser() -> argparse.ArgumentParser:
     psa = sub.add_parser("sync-agents", help="(re)install role agents into <repo>/.opencode")
     psa.add_argument("--repo", default=".")
     psa.set_defaults(func=cmd_sync_agents)
+
+    pi = sub.add_parser("init", help="interactively configure .director/config.toml")
+    pi.add_argument("--repo", default=".")
+    pi.set_defaults(func=cmd_init)
     return p
 
 

{director_cli-0.3.0 → director_cli-0.4.0}/director/config.example.toml

@@ -9,8 +9,13 @@
 # turn it into a zero-local-infra "cheap-cloud" setup or an "all-frontier" baseline.
 
 [tiers]
-# Roles bound to resolved OpenCode model strings ("provider/model"). Code, prompts,
-# and logs refer ONLY to these role names — never to a specific model.
+# Each role is bound to a "<provider>/<model>" string. The provider segment also
+# selects the agent runtime:
+#   - any OpenCode provider (lmstudio, openrouter, amazon-bedrock, …) → OpenCode (default)
+#   - "claude-code/<model>"  → the Claude Code CLI (`claude`); <model> is passed to
+#                              `claude --model` (e.g. "claude-code/opus", "claude-code/sonnet")
+# Mix freely per role — e.g. a claude-code planner alongside a local-opencode executor.
+# Code, prompts, and logs refer ONLY to role names — never to a specific model.
 planner     = "amazon-bedrock/us.anthropic.claude-opus-4-7"   # decomposition + DAG (use your strongest model)
 test_author = "amazon-bedrock/us.anthropic.claude-opus-4-7"   # tests are the contract → strongest
 executor    = "lmstudio/qwen3.6-27b-mtp"                      # implements each node. The cheap tier.
@@ -23,6 +28,7 @@ escalation  = "amazon-bedrock/anthropic.claude-sonnet-4-6"    # per-task fallbac
 #     executor = "openrouter/deepseek/deepseek-v4-pro"
 # all-frontier baseline (expensive control): set executor = reviewer = escalation
 #   to the same frontier model as the planner.
+# Claude Code: e.g.  planner = "claude-code/opus"   (drive planning via the `claude` CLI)
 
 # Only needed if a tier above points at a local OpenAI-compatible endpoint.
 [providers.local]

{director_cli-0.3.0 → director_cli-0.4.0}/director/config.py

@@ -77,8 +77,7 @@ def load(repo: Path) -> Config:
     path = Path(repo) / ".director" / "config.toml"
     if not path.exists():
         raise FileNotFoundError(
-            f"{path} not found. Run `director sync-agents` to seed it from the bundled "
-            f"example, then edit it."
+            f"{path} not found. Run `director init` to create it interactively."
         )
     return load_file(path)
 

director_cli-0.4.0/director/init.py

@@ -0,0 +1,134 @@
+"""Interactive `director init`: discover models, prompt for tiers/gates, render TOML.
+
+This module wires the interactive `director init` flow. It discovers available
+models by shelling out to `opencode models`, prompts the user to bind each role
+to a model (or falls back to free-text entry when discovery is unavailable),
+prompts for the deterministic gate commands, and renders a minimal
+`.director/config.toml`. The renderer is pure and its output round-trips through
+`director.config.load_file`.
+"""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+from director.config import ROLES
+
+
+def parse_models(text: str) -> list[str]:
+    """Parse `opencode models` output into a deduped, ordered list of model ids.
+
+    Lines are stripped; blank lines and lines without a `/` are dropped. The
+    first occurrence of each model id is kept and later duplicates discarded.
+    """
+    seen: set[str] = set()
+    models: list[str] = []
+    for line in text.split("\n"):
+        stripped = line.strip()
+        if not stripped:
+            continue
+        if "/" not in stripped:
+            continue
+        if stripped in seen:
+            continue
+        seen.add(stripped)
+        models.append(stripped)
+    return models
+
+
+def discover_models() -> list[str]:
+    """Run `opencode models` and parse its output; return [] on any failure."""
+    try:
+        result = subprocess.run(
+            ["opencode", "models"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+    except FileNotFoundError:
+        return []
+    if result.returncode != 0:
+        return []
+    return parse_models(result.stdout)
+
+
+def prompt_model(role: str, models: list[str]) -> str:
+    """Prompt the user to bind `role` to a model, looping until a valid choice."""
+    if models:
+        for i, model in enumerate(models, start=1):
+            print(f"  {i}) {model}")
+        while True:
+            answer = input(f"select model for {role}: ").strip()
+            if not answer:
+                continue
+            try:
+                n = int(answer)
+            except ValueError:
+                print("invalid selection")
+                continue
+            if 1 <= n <= len(models):
+                return models[n - 1]
+            print("invalid selection")
+    else:
+        while True:
+            answer = input(f"enter model for {role}: ").strip()
+            if answer:
+                return answer
+
+
+def prompt_gate(name: str) -> str:
+    """Prompt once for the `name` gate command; blank means skip and is valid."""
+    return input(f"command for {name} gate (blank to skip): ").strip()
+
+
+def render_config(tiers: dict[str, str], gates: dict[str, str]) -> str:
+    """Render a minimal `.director/config.toml` text from tiers and gates."""
+
+    def emit(table: dict[str, str]) -> list[str]:
+        lines = []
+        for key, value in table.items():
+            escaped = value.replace("\\", "\\\\").replace('"', '\\"')
+            lines.append(f'{key} = "{escaped}"')
+        return lines
+
+    parts: list[str] = []
+    parts.append("[tiers]")
+    parts.extend(emit(tiers))
+    parts.append("")
+    parts.append("[gates]")
+    parts.extend(emit(gates))
+    parts.append("")
+    parts.append("# Advanced options (pricing, limits, review) are omitted here.")
+    parts.append("# See the bundled config.example.toml for the full schema.")
+    return "\n".join(parts) + "\n"
+
+
+def run_init(repo: str) -> Path:
+    """Orchestrate the interactive init flow and write `.director/config.toml`."""
+    cfg_path = Path(repo) / ".director" / "config.toml"
+
+    if cfg_path.exists():
+        answer = input("config.toml exists; overwrite? [y/N] ").strip().lower()
+        if answer not in ("y", "yes"):
+            print("aborted; nothing was written.")
+            return cfg_path
+
+    models = discover_models()
+    if not models:
+        print(
+            "warning: `opencode models` was unavailable or returned no models; "
+            "falling back to free-text entry."
+        )
+
+    tiers: dict[str, str] = {}
+    for role in ROLES:
+        tiers[role] = prompt_model(role, models)
+
+    gates: dict[str, str] = {}
+    for name in ("test", "lint", "typecheck"):
+        gates[name] = prompt_gate(name)
+
+    cfg_path.parent.mkdir(parents=True, exist_ok=True)
+    cfg_path.write_text(render_config(tiers, gates))
+    return cfg_path

{director_cli-0.3.0 → director_cli-0.4.0}/director/opencode.py

@@ -19,6 +19,11 @@ from pathlib import Path
 # changed-file count. Suppressing it at the source keeps every worktree clean.
 _CLEAN_ENV = {**os.environ, "PYTHONDONTWRITEBYTECODE": "1"}
 
+# A tier model string prefixed with this routes to the Claude Code runtime; the
+# remainder is the `claude --model` value (e.g. "claude-code/opus" → claude --model
+# opus). Everything else is an OpenCode "provider/model" string (the default).
+CLAUDE_PREFIX = "claude-code/"
+
 
 @dataclass
 class RunResult:
@@ -38,7 +43,7 @@ class RunResult:
         return self.returncode == 0 and self.error is None and not self.timed_out
 
 
-def run_agent(
+def _run_opencode(
     *,
     agent: str,
     model: str,
@@ -47,17 +52,11 @@ def run_agent(
     log_path: str | Path,
     timeout: int,
 ) -> RunResult:
-    """Invoke an OpenCode agent headlessly in `cwd`. NDJSON events go to
-    `log_path`; OpenCode logs go to `log_path + '.stderr'`. Never raises on a
-    model/agent failure — inspect RunResult.ok / .error / .timed_out."""
+    """Run the opencode CLI for a single agent invocation."""
     log_path = Path(log_path)
     log_path.parent.mkdir(parents=True, exist_ok=True)
     err_path = log_path.with_suffix(log_path.suffix + ".stderr")
 
-    # --dir pins the project/worktree explicitly. Without it, `opencode run`
-    # resolves the project root by walking up for a .git and can land on an
-    # ENCLOSING repo (so edits leak out of an isolated worktree). Worktrees are
-    # also placed outside the repo tree (see run.py) to make this airtight.
     cmd = [
         "opencode",
         "run",
@@ -87,6 +86,40 @@ def run_agent(
     return _parse(log_path, rc, timed_out)
 
 
+def run_agent(
+    *,
+    agent: str,
+    model: str,
+    message: str,
+    cwd: str | Path,
+    log_path: str | Path,
+    timeout: int,
+) -> RunResult:
+    """Invoke an agent headlessly in `cwd`. The runtime is chosen by the `model`
+    string: a `claude-code/<model>` tier routes to the Claude Code runtime (with
+    the prefix stripped), anything else to OpenCode (the default). Never raises on
+    a failure — inspect RunResult.ok / .error / .timed_out."""
+    if model.startswith(CLAUDE_PREFIX):
+        from director.claudecode import run_claude
+
+        return run_claude(
+            agent=agent,
+            model=model[len(CLAUDE_PREFIX) :],
+            message=message,
+            cwd=cwd,
+            log_path=log_path,
+            timeout=timeout,
+        )
+    return _run_opencode(
+        agent=agent,
+        model=model,
+        message=message,
+        cwd=cwd,
+        log_path=log_path,
+        timeout=timeout,
+    )
+
+
 def _parse(log_path: Path, rc: int, timed_out: bool) -> RunResult:
     text_parts: list[str] = []
     tokens = {"input": 0, "output": 0, "reasoning": 0, "total": 0}

{director_cli-0.3.0 → director_cli-0.4.0}/director/setup.py

@@ -7,8 +7,7 @@ into <repo>/.opencode/agents/ (a.k.a. the `director sync-agents` step).
 
 Provider auth (Bedrock/OpenRouter keys, the LM Studio endpoint) is the operator's
 responsibility — it lives in the user's *global* OpenCode config. We add the
-project-local agent files, a starter opencode.json if the repo has none, and seed
-a ready-to-edit .director/config.toml from the bundled example (if none exists).
+project-local agent files, a starter opencode.json if the repo has none.
 """
 
 from __future__ import annotations
@@ -25,11 +24,6 @@ AGENT_FILES = (
     "reviewer.md",
 )
 
-# A complete, commented example config ships inside the package. sync-agents seeds
-# it to <repo>/.director/config.toml (if missing) so a pip-installed user has a
-# ready-to-edit config rather than nothing.
-CONFIG_EXAMPLE = "config.example.toml"
-
 # Runtime artifacts director writes into <repo>/.director/. These must never be
 # committed: director's own commits use `git add -A` (to capture whatever the
 # executor created in the allowlist), which in a repo without this ignore file
@@ -55,10 +49,6 @@ def _template(name: str) -> str:
     return ir.files("director.agent_templates").joinpath(name).read_text()
 
 
-def _example_config() -> str:
-    return ir.files("director").joinpath(CONFIG_EXAMPLE).read_text()
-
-
 def ensure_director_gitignore(repo: str | Path) -> None:
     """Seed <repo>/.director/.gitignore so director's `git add -A` commits never
     sweep its own runtime files into the repo. Idempotent; safe to call on every
@@ -90,12 +80,4 @@ def sync_agents(repo: str | Path) -> list[str]:
     if not oc.exists():
         oc.write_text(_template("opencode.json"))
         written.append(str(oc.relative_to(repo)))
-
-    # Seed a ready-to-edit config from the bundled example — but never clobber an
-    # existing config the user may have edited.
-    cfg = repo / ".director" / "config.toml"
-    if not cfg.exists():
-        cfg.parent.mkdir(parents=True, exist_ok=True)
-        cfg.write_text(_example_config())
-        written.append(str(cfg.relative_to(repo)))
     return written

{director_cli-0.3.0 → director_cli-0.4.0}/pyproject.toml

@@ -74,7 +74,7 @@ quote-style = "double"
 [tool.semantic_release]
 version_variables = ["director/__init__.py:__version__"]
 commit_parser = "conventional"
-build_command = "python -m build"
+build_command = "python -m pip install build && python -m build"
 commit_message = "chore(release): {version} [skip ci]\n\nAutomated release."
 tag_format = "v{version}"
 

director_cli-0.3.0/CHANGELOG.md

@@ -1,25 +0,0 @@
-# Changelog
-
-All notable changes to this project are documented here. This file is maintained
-automatically by [python-semantic-release](https://python-semantic-release.readthedocs.io/)
-from [Conventional Commits](https://www.conventionalcommits.org/); the entry below is the
-pre-automation baseline.
-
-<!-- version list -->
-
-## v0.3.0 (2026-06-24)
-
-Initial public baseline (project renamed from its `foreman` codename to **director**).
-
-### Features
-
-- **plan / run / status orchestrator** over OpenCode: a strong planner decomposes a task
-  into an atomic DAG with acceptance tests written first; a cheaper executor implements
-  each node in an isolated git worktree; deterministic gates (tests/lint/typecheck) decide
-  merges, with a per-task escalation ladder.
-- **Approval gates + methodology** (brainstorm/spec gate, plan gate; `--auto` self-critique),
-  two-stage cost-gated code review, and red-green test-hash hardening.
-- **TDD hardening & measurement:** watch-it-fail transcript verification, flake control
-  (re-run node tests on success), a `.director/metrics.jsonl` stream, and `director bench`
-  to compare cost/quality/wall-time across profiles on identical acceptance tests.
-- Three shipped profiles: `local-first`, `cheap-cloud`, `all-frontier`.