regent-cli 0.1.0__tar.gz

regent_cli-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Flavio Alvim
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

regent_cli-0.1.0/PKG-INFO

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: regent-cli
+Version: 0.1.0
+Summary: Autonomous conduction and mediated adversarial deliberation between AI agents, pluggable into any project.
+Author-email: Flavio Alvim <flavioalvim@gmail.com>
+License: MIT
+Project-URL: Repository, https://github.com/flavioalvim/regent
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# regent
+
+Autonomous conduction and mediated adversarial deliberation between AI agents, pluggable
+into any project.
+
+**regent** governs turns between agents (Claude, Codex, human mediators) under a frozen
+protocol: atomic turn mutex, CAS-versioned state, deliberation rounds with versioned
+acceptances, and a conduction daemon that executes production batches with a confined agent,
+test gates and evidence proof.
+
+Extracted from the tool proven end-to-end in the ArtNFT project (IMP-003: first product
+batch fully conducted by the daemon, deliberated, accepted and deployed to production).
+
+- Requirements: [`docs/PRD.md`](docs/PRD.md)
+- Extraction scope and decisions: [`docs/ESCOPO.md`](docs/ESCOPO.md) (PT-BR, pre-rename)
+- Deliberation rounds: [`docs/brainstorm/`](docs/brainstorm/) (mediator's language, PT-BR)
+- Status: **pre-extraction** (scope closed 2026-07-20; code not yet migrated)
+
+## Install
+
+```bash
+pip install <path-to-this-repo>   # package: regent-cli; CLI: regent (not on PyPI yet)
+cd <your-project>
+regent init                        # seeds .regent/ + .claude/skills symlinks (atomic, idempotent)
+regent doctor                      # checks executor (claude) and advisor (codex) CLIs
+```
+
+Then open a Claude Code session in the project — `/regent` and `/regent-stop` are available
+(`/regent brainstorm "<question>"` opens the first round). v0 capability is file-driven
+(rounds under `.regent/brainstorm/rodadas/`); the advisor requires the `codex` CLI.
+
+Development: `PYTHONPATH=src python3 -m unittest discover -s tests`. Canonical skill content
+lives in `src/regent/templates/` (ships inside the wheel); the repo's own `.regent/skills/`
+symlinks into it (dogfood without duplication).
+
+MIT License © 2026 Flavio Alvim.

regent_cli-0.1.0/README.md

@@ -0,0 +1,36 @@
+# regent
+
+Autonomous conduction and mediated adversarial deliberation between AI agents, pluggable
+into any project.
+
+**regent** governs turns between agents (Claude, Codex, human mediators) under a frozen
+protocol: atomic turn mutex, CAS-versioned state, deliberation rounds with versioned
+acceptances, and a conduction daemon that executes production batches with a confined agent,
+test gates and evidence proof.
+
+Extracted from the tool proven end-to-end in the ArtNFT project (IMP-003: first product
+batch fully conducted by the daemon, deliberated, accepted and deployed to production).
+
+- Requirements: [`docs/PRD.md`](docs/PRD.md)
+- Extraction scope and decisions: [`docs/ESCOPO.md`](docs/ESCOPO.md) (PT-BR, pre-rename)
+- Deliberation rounds: [`docs/brainstorm/`](docs/brainstorm/) (mediator's language, PT-BR)
+- Status: **pre-extraction** (scope closed 2026-07-20; code not yet migrated)
+
+## Install
+
+```bash
+pip install <path-to-this-repo>   # package: regent-cli; CLI: regent (not on PyPI yet)
+cd <your-project>
+regent init                        # seeds .regent/ + .claude/skills symlinks (atomic, idempotent)
+regent doctor                      # checks executor (claude) and advisor (codex) CLIs
+```
+
+Then open a Claude Code session in the project — `/regent` and `/regent-stop` are available
+(`/regent brainstorm "<question>"` opens the first round). v0 capability is file-driven
+(rounds under `.regent/brainstorm/rodadas/`); the advisor requires the `codex` CLI.
+
+Development: `PYTHONPATH=src python3 -m unittest discover -s tests`. Canonical skill content
+lives in `src/regent/templates/` (ships inside the wheel); the repo's own `.regent/skills/`
+symlinks into it (dogfood without duplication).
+
+MIT License © 2026 Flavio Alvim.

regent_cli-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "regent-cli"
+version = "0.1.0"
+description = "Autonomous conduction and mediated adversarial deliberation between AI agents, pluggable into any project."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "Flavio Alvim", email = "flavioalvim@gmail.com" }]
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+]
+
+[project.urls]
+Repository = "https://github.com/flavioalvim/regent"
+
+[project.scripts]
+regent = "regent.cli:entrypoint"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+regent = ["templates/**/*"]

regent_cli-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

regent_cli-0.1.0/src/regent/__init__.py

@@ -0,0 +1,3 @@
+"""regent — autonomous conduction and mediated adversarial deliberation between AI agents."""
+
+__version__ = "0.1.0"

regent_cli-0.1.0/src/regent/cli.py

@@ -0,0 +1,40 @@
+"""regent CLI entry point: init and doctor subcommands."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from . import __version__
+from .doctor import run_doctor
+from .initcmd import run_init
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="regent",
+        description="Autonomous conduction and mediated adversarial deliberation "
+                    "between AI agents, pluggable into any project.")
+    parser.add_argument("--version", action="version", version=f"regent {__version__}")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    p_init = sub.add_parser("init", help="seed .regent/ and managed integrations here")
+    p_init.add_argument("--project", default=".", help="host project root (default: cwd)")
+
+    p_doctor = sub.add_parser("doctor", help="diagnose agent CLI capabilities")
+    p_doctor.add_argument("--project", default=".", help="host project root (default: cwd)")
+
+    args = parser.parse_args(argv)
+    root = Path(args.project)
+    if args.command == "init":
+        return run_init(root)
+    return run_doctor(root)
+
+
+def entrypoint() -> None:
+    sys.exit(main())
+
+
+if __name__ == "__main__":
+    entrypoint()

regent_cli-0.1.0/src/regent/doctor.py

@@ -0,0 +1,47 @@
+"""regent doctor — capability diagnostics via safe non-interactive probes.
+
+Contract (PRD REQ-003 §6): exit 0 iff every capability is usable; structured
+per-capability report. Probes never open interactive sessions.
+"""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+EXIT_OK = 0
+EXIT_UNAVAILABLE = 1
+
+CAPABILITIES = (
+    ("executor", "claude", ["claude", "--version"]),
+    ("advisor", "codex", ["codex", "--version"]),
+)
+
+
+def _default_probe(argv: list[str]) -> tuple[str, str]:
+    """Returns (status, detail): OK, MISSING or BROKEN."""
+    if shutil.which(argv[0]) is None:
+        return "MISSING", f"'{argv[0]}' not found on PATH"
+    try:
+        proc = subprocess.run(argv, capture_output=True, text=True, timeout=30)
+    except (subprocess.TimeoutExpired, OSError) as exc:
+        return "BROKEN", f"probe failed: {exc}"
+    if proc.returncode != 0:
+        return "BROKEN", f"exit {proc.returncode}: {proc.stderr.strip()[:200]}"
+    return "OK", proc.stdout.strip().splitlines()[0] if proc.stdout.strip() else "ok"
+
+
+def run_doctor(project_root: Path, out=sys.stdout, probe=_default_probe) -> int:
+    all_ok = True
+    for role, _cli, argv in CAPABILITIES:
+        status, detail = probe(argv)
+        all_ok = all_ok and status == "OK"
+        print(f"{role:<9} {status:<8} {detail}", file=out)
+
+    initialized = (project_root / ".regent").is_dir()
+    print(f"project   {'INITIALIZED' if initialized else 'NOT-INITIALIZED':<8} "
+          f"{project_root}", file=out)
+
+    return EXIT_OK if all_ok else EXIT_UNAVAILABLE

regent_cli-0.1.0/src/regent/initcmd.py

@@ -0,0 +1,135 @@
+"""regent init — seed .regent/ and managed integrations into a host project.
+
+Contract (PRD REQ-003 §6, REQ-004): installation is atomic — exit 0 only on
+complete seeding; any failure rolls back every path this run created, leaving
+no partial state. A missing agent CLI is a warning, never an init failure.
+Pre-existing content that diverges from what would be seeded is a conflict:
+nothing is touched. Re-running over an identical installation is a no-op.
+"""
+
+from __future__ import annotations
+
+import shutil
+import sys
+from importlib import resources
+from pathlib import Path
+
+SKILL_NAMES = ("regent", "regent-stop")
+AGENT_CLIS = ("claude", "codex")
+
+EXIT_OK = 0
+EXIT_CONFLICT = 2
+EXIT_FAILURE = 1
+
+
+class SeedConflict(Exception):
+    """Pre-existing host content diverges from what init would seed."""
+
+
+def _template_skill(name: str) -> str:
+    ref = resources.files("regent").joinpath(f"templates/skills/{name}/SKILL.md")
+    return ref.read_text(encoding="utf-8")
+
+
+def _plan(project_root: Path) -> list[tuple[str, Path, str]]:
+    """Returns [(kind, path, payload)] where kind is 'file' or 'symlink'.
+
+    payload = file content, or the symlink target (relative)."""
+    plan: list[tuple[str, Path, str]] = []
+    for name in SKILL_NAMES:
+        plan.append(("file", project_root / ".regent" / "skills" / name / "SKILL.md",
+                     _template_skill(name)))
+        plan.append(("symlink", project_root / ".claude" / "skills" / name,
+                     f"../../.regent/skills/{name}"))
+    plan.append(("file", project_root / ".regent" / "brainstorm" / "rodadas" / ".gitkeep", ""))
+    return plan
+
+
+def _existing_state(kind: str, path: Path, payload: str) -> str:
+    """'absent' | 'identical' | 'divergent' for one planned entry."""
+    if kind == "symlink":
+        if not path.is_symlink():
+            return "absent" if not path.exists() else "divergent"
+        import os
+        return "identical" if os.readlink(path) == payload else "divergent"
+    if not path.exists():
+        return "absent"
+    if path.is_file() and path.read_text(encoding="utf-8") == payload:
+        return "identical"
+    return "divergent"
+
+
+def run_init(project_root: Path, out=sys.stdout) -> int:
+    project_root = project_root.resolve()
+    try:
+        plan = _plan(project_root)
+    except (FileNotFoundError, ModuleNotFoundError) as exc:
+        print(f"error: packaged templates unavailable: {exc}", file=out)
+        return EXIT_FAILURE
+
+    states = {path: _existing_state(kind, path, payload) for kind, path, payload in plan}
+    divergent = [p for p, s in states.items() if s == "divergent"]
+    if divergent:
+        print("error: conflict — pre-existing content differs from what regent would seed:",
+              file=out)
+        for p in divergent:
+            print(f"  {p.relative_to(project_root)}", file=out)
+        print("nothing was changed. Resolve the conflicts and re-run.", file=out)
+        return EXIT_CONFLICT
+
+    todo = [(kind, path, payload) for kind, path, payload in plan
+            if states[path] == "absent"]
+    if not todo:
+        print("already initialized — nothing to do.", file=out)
+        _warn_missing_clis(out)
+        return EXIT_OK
+
+    created: list[Path] = []
+    try:
+        for kind, path, payload in todo:
+            for parent in _missing_parents(path):
+                parent.mkdir()
+                created.append(parent)
+            if kind == "file":
+                path.write_text(payload, encoding="utf-8")
+            else:
+                path.symlink_to(payload)
+            created.append(path)
+    except OSError as exc:
+        _rollback(created)
+        print(f"error: seeding failed ({exc}); all changes rolled back.", file=out)
+        return EXIT_FAILURE
+
+    for kind, path, _ in todo:
+        print(f"seeded {path.relative_to(project_root)}"
+              + (" (symlink)" if kind == "symlink" else ""), file=out)
+    _warn_missing_clis(out)
+    print("regent initialized. Open a Claude Code session here and use /regent.", file=out)
+    return EXIT_OK
+
+
+def _missing_parents(path: Path) -> list[Path]:
+    missing = []
+    for parent in path.parents:
+        if parent.exists():
+            break
+        missing.append(parent)
+    return list(reversed(missing))
+
+
+def _rollback(created: list[Path]) -> None:
+    for path in reversed(created):
+        try:
+            if path.is_symlink() or path.is_file():
+                path.unlink()
+            elif path.is_dir():
+                path.rmdir()
+        except OSError:
+            pass  # best effort; leftover paths are reported by the failure message
+
+
+def _warn_missing_clis(out) -> None:
+    for cli in AGENT_CLIS:
+        if shutil.which(cli) is None:
+            print(f"warning: agent CLI '{cli}' not found on PATH "
+                  f"(run 'regent doctor' for capability diagnostics)", file=out)

regent_cli-0.1.0/src/regent/templates/skills/regent/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: regent
+description: Start or resume the regent activity in this repo (brainstorm round, planning, implementation). Single state-driven entry point — detects what is open and drives the next step. Use when the owner says /regent, "retome o brainstorm", "próxima rodada", or asks to continue regent work.
+---
+
+# /regent — start or resume the current activity
+
+> **Capability level: v0 (file-driven).** State detection is based on round files only.
+> There is no `control.json`, no turn lock, no daemon, no atomic abort and no structured
+> checkpoint yet — those arrive with REQ-004's full implementation. Do not claim
+> capabilities beyond this file.
+
+## 0. Locate the rounds directory (deterministic, never guess)
+
+- Host projects: `ROUNDS = .regent/brainstorm/rodadas/` (created on first use).
+- The regent product repo itself keeps its own deliberation in `docs/brainstorm/rodadas/`
+  (legacy dogfood location).
+- Resolution: if `.regent/brainstorm/` exists use it; else if `docs/brainstorm/` exists use
+  that; if BOTH exist, report the ambiguity and STOP; if neither, this is a fresh host —
+  `ROUNDS = .regent/brainstorm/rodadas/`.
+
+## 1. Detect state (never guess)
+
+- Open round = a `ROUNDS/RODADA-NNN/` directory WITHOUT `DECISAO.md`.
+- Suspended round = an open round containing `SUSPENSAO.md`.
+- If the state is ambiguous or corrupted (two open rounds, missing PERGUNTA.md), REPORT the
+  anomaly and STOP. Default-deny: never repair silently, never pick one arbitrarily.
+
+## 2. Decide by command argument × state
+
+- **No argument + exactly one open/suspended round** → resume it (step 3).
+- **No argument + nothing open** → report the state (last closed round, PRD requirement log)
+  and ask what to start. Never start anything implicitly.
+- **`brainstorm "<question>"` + nothing open** → create the next `ROUNDS/RODADA-NNN/` with
+  `PERGUNTA.md` (owner's question verbatim) and proceed to step 3.
+- **`brainstorm ...` + a DIFFERENT round already open** → error explaining the open state.
+  Never ignore the argument silently; never create a second activity.
+- **`plan` / `build`** → not available at v0; say so explicitly and point to REQ-004.
+
+## 3. Drive the round (the loop protocol is THIS section — self-contained)
+
+Loop: owner asks → Claude responds → Codex (advisor) opines with an explicit
+CONCORDA/DISCORDA verdict → if CONCORDA, Claude executes; if DISCORDA, one rebuttal cycle;
+persistent divergence → the owner arbitrates. Round language: the mediator's (REQ-002).
+
+Resume at the first missing artifact, in order:
+1. `RESPOSTA-CLAUDE.md` — Claude's reasoned position + concrete proposal.
+2. `OPINIAO-CODEX-1.md` — headless advisor consultation, saved verbatim:
+   `codex --ask-for-approval never --sandbox read-only exec --cd <repo> -o <tmpfile> "<prompt>"`
+   (prompt tells Codex which files to read and to end with a line containing only
+   CONCORDA or DISCORDA).
+3. If DISCORDA → `REPLICA-CLAUDE.md` then `OPINIAO-CODEX-2.md` (one rebuttal cycle max).
+4. Persistent divergence → the owner arbitrates (they are mediating live).
+5. `DECISAO.md` — what was decided, who closed it, what was executed. Then execute it and
+   commit ONLY regent-owned paths (`.regent/`, the `.claude/` symlink integrations, and —
+   in the regent repo only — `docs/`) — never unrelated host content. A failed commit does
+   not undo the round; report it and leave it pending.
+
+If resuming a suspended round, read `SUSPENSAO.md` first, delete it after resuming, and
+continue from the recorded pending step.

regent_cli-0.1.0/src/regent/templates/skills/regent-stop/SKILL.md

@@ -0,0 +1,27 @@
+---
+name: regent-stop
+description: Safely stop/suspend the regent activity in progress (brainstorm round, planning, implementation) so it can be resumed later with /regent. Use when the owner says /regent-stop, "para o brainstorm", "suspende a rodada", or asks to stop regent work.
+---
+
+# /regent-stop — safe stop of the current activity
+
+> **Capability level: v0 (file-driven).** There is no daemon, lock or in-flight abort yet:
+> stopping means recording a durable suspension marker at the next message boundary. Do not
+> claim atomic cancellation — immediate interruption of a running step is the user's Esc,
+> not this command.
+
+## Steps
+
+1. Locate the rounds directory exactly as `/regent` does (step 0 of its skill: host =
+   `.regent/brainstorm/rodadas/`; the regent repo itself = `docs/brainstorm/rodadas/`; both
+   present = ambiguity, stop). Then detect the open round: `RODADA-NNN/` without `DECISAO.md`.
+   - Nothing open → report that the state is clean (nothing to stop) and stop.
+   - Ambiguous state → report the anomaly; do not modify anything.
+2. Write `SUSPENSAO.md` in the open round with: timestamp, reason given by the owner (ask if
+   not stated), which artifact/step was pending (the resume checkpoint), and any partial
+   output worth keeping (e.g. an advisor consultation already saved).
+3. Persist everything already produced — never delete partial artifacts; they are evidence.
+4. Commit ONLY regent-owned paths (`.regent/`, the `.claude/` symlink integrations, and —
+   in the regent repo only — `docs/`). A failed commit does NOT prevent the suspension —
+   report it and leave the commit pending.
+5. Confirm to the owner: what was suspended, where it will resume from (`/regent`).

regent_cli-0.1.0/src/regent_cli.egg-info/PKG-INFO

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: regent-cli
+Version: 0.1.0
+Summary: Autonomous conduction and mediated adversarial deliberation between AI agents, pluggable into any project.
+Author-email: Flavio Alvim <flavioalvim@gmail.com>
+License: MIT
+Project-URL: Repository, https://github.com/flavioalvim/regent
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# regent
+
+Autonomous conduction and mediated adversarial deliberation between AI agents, pluggable
+into any project.
+
+**regent** governs turns between agents (Claude, Codex, human mediators) under a frozen
+protocol: atomic turn mutex, CAS-versioned state, deliberation rounds with versioned
+acceptances, and a conduction daemon that executes production batches with a confined agent,
+test gates and evidence proof.
+
+Extracted from the tool proven end-to-end in the ArtNFT project (IMP-003: first product
+batch fully conducted by the daemon, deliberated, accepted and deployed to production).
+
+- Requirements: [`docs/PRD.md`](docs/PRD.md)
+- Extraction scope and decisions: [`docs/ESCOPO.md`](docs/ESCOPO.md) (PT-BR, pre-rename)
+- Deliberation rounds: [`docs/brainstorm/`](docs/brainstorm/) (mediator's language, PT-BR)
+- Status: **pre-extraction** (scope closed 2026-07-20; code not yet migrated)
+
+## Install
+
+```bash
+pip install <path-to-this-repo>   # package: regent-cli; CLI: regent (not on PyPI yet)
+cd <your-project>
+regent init                        # seeds .regent/ + .claude/skills symlinks (atomic, idempotent)
+regent doctor                      # checks executor (claude) and advisor (codex) CLIs
+```
+
+Then open a Claude Code session in the project — `/regent` and `/regent-stop` are available
+(`/regent brainstorm "<question>"` opens the first round). v0 capability is file-driven
+(rounds under `.regent/brainstorm/rodadas/`); the advisor requires the `codex` CLI.
+
+Development: `PYTHONPATH=src python3 -m unittest discover -s tests`. Canonical skill content
+lives in `src/regent/templates/` (ships inside the wheel); the repo's own `.regent/skills/`
+symlinks into it (dogfood without duplication).
+
+MIT License © 2026 Flavio Alvim.

regent_cli-0.1.0/src/regent_cli.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+README.md
+pyproject.toml
+src/regent/__init__.py
+src/regent/cli.py
+src/regent/doctor.py
+src/regent/initcmd.py
+src/regent/templates/skills/regent/SKILL.md
+src/regent/templates/skills/regent-stop/SKILL.md
+src/regent_cli.egg-info/PKG-INFO
+src/regent_cli.egg-info/SOURCES.txt
+src/regent_cli.egg-info/dependency_links.txt
+src/regent_cli.egg-info/entry_points.txt
+src/regent_cli.egg-info/top_level.txt
+tests/test_doctor.py
+tests/test_initcmd.py

regent_cli-0.1.0/src/regent_cli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

regent_cli-0.1.0/src/regent_cli.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+regent = regent.cli:entrypoint

regent_cli-0.1.0/src/regent_cli.egg-info/top_level.txt

@@ -0,0 +1 @@
+regent

regent_cli-0.1.0/tests/test_doctor.py

@@ -0,0 +1,52 @@
+"""Tests for regent doctor: exit codes and per-capability report."""
+
+import io
+import tempfile
+import unittest
+from pathlib import Path
+
+from regent.doctor import EXIT_OK, EXIT_UNAVAILABLE, run_doctor
+
+
+def probe_all_ok(argv):
+    return "OK", f"{argv[0]} 1.0.0"
+
+
+def probe_advisor_missing(argv):
+    if argv[0] == "codex":
+        return "MISSING", "'codex' not found on PATH"
+    return "OK", "claude 1.0.0"
+
+
+class DoctorTest(unittest.TestCase):
+    def setUp(self):
+        self._tmp = tempfile.TemporaryDirectory()
+        self.root = Path(self._tmp.name)
+        self.addCleanup(self._tmp.cleanup)
+
+    def _doctor(self, probe):
+        out = io.StringIO()
+        code = run_doctor(self.root, out=out, probe=probe)
+        return code, out.getvalue()
+
+    def test_all_capabilities_ok(self):
+        code, output = self._doctor(probe_all_ok)
+        self.assertEqual(code, EXIT_OK)
+        self.assertIn("executor", output)
+        self.assertIn("advisor", output)
+        self.assertIn("NOT-INITIALIZED", output)
+
+    def test_missing_capability_fails(self):
+        code, output = self._doctor(probe_advisor_missing)
+        self.assertEqual(code, EXIT_UNAVAILABLE)
+        self.assertIn("MISSING", output)
+
+    def test_initialized_project_is_reported(self):
+        (self.root / ".regent").mkdir()
+        code, output = self._doctor(probe_all_ok)
+        self.assertEqual(code, EXIT_OK)
+        self.assertIn("INITIALIZED", output)
+
+
+if __name__ == "__main__":
+    unittest.main()

regent_cli-0.1.0/tests/test_initcmd.py

@@ -0,0 +1,72 @@
+"""Tests for regent init: seeding, idempotency, conflict detection, rollback."""
+
+import io
+import os
+import tempfile
+import unittest
+from pathlib import Path
+
+from regent.initcmd import EXIT_CONFLICT, EXIT_FAILURE, EXIT_OK, run_init
+
+
+class InitTest(unittest.TestCase):
+    def setUp(self):
+        self._tmp = tempfile.TemporaryDirectory()
+        self.root = Path(self._tmp.name)
+        self.addCleanup(self._tmp.cleanup)
+
+    def _init(self):
+        out = io.StringIO()
+        code = run_init(self.root, out=out)
+        return code, out.getvalue()
+
+    def test_fresh_project_seeds_everything(self):
+        code, output = self._init()
+        self.assertEqual(code, EXIT_OK, output)
+        for name in ("regent", "regent-stop"):
+            skill = self.root / ".regent" / "skills" / name / "SKILL.md"
+            self.assertTrue(skill.is_file())
+            self.assertIn(f"name: {name}", skill.read_text())
+            link = self.root / ".claude" / "skills" / name
+            self.assertTrue(link.is_symlink())
+            self.assertEqual(os.readlink(link), f"../../.regent/skills/{name}")
+            self.assertTrue((link / "SKILL.md").is_file())  # symlink resolves
+        self.assertTrue((self.root / ".regent" / "brainstorm" / "rodadas").is_dir())
+
+    def test_rerun_is_noop(self):
+        self.assertEqual(self._init()[0], EXIT_OK)
+        code, output = self._init()
+        self.assertEqual(code, EXIT_OK)
+        self.assertIn("already initialized", output)
+
+    def test_divergent_content_is_conflict_and_untouched(self):
+        skill = self.root / ".regent" / "skills" / "regent" / "SKILL.md"
+        skill.parent.mkdir(parents=True)
+        skill.write_text("host content that differs")
+        code, output = self._init()
+        self.assertEqual(code, EXIT_CONFLICT)
+        self.assertIn("conflict", output)
+        self.assertEqual(skill.read_text(), "host content that differs")
+        self.assertFalse((self.root / ".claude").exists())  # nothing else was created
+
+    def test_failure_rolls_back_everything(self):
+        # A FILE at .claude/skills makes the symlink parent creation fail mid-run.
+        (self.root / ".claude").mkdir()
+        (self.root / ".claude" / "skills").write_text("not a directory")
+        code, output = self._init()
+        self.assertEqual(code, EXIT_FAILURE)
+        self.assertIn("rolled back", output)
+        self.assertFalse((self.root / ".regent").exists())
+
+    def test_missing_seed_completes_partial_prior_state(self):
+        # An identical prior artifact is kept; only the absent ones are seeded.
+        self.assertEqual(self._init()[0], EXIT_OK)
+        link = self.root / ".claude" / "skills" / "regent"
+        link.unlink()
+        code, output = self._init()
+        self.assertEqual(code, EXIT_OK)
+        self.assertTrue(link.is_symlink())
+
+
+if __name__ == "__main__":
+    unittest.main()