claude-code-conductor 0.2.4__tar.gz → 0.3.0__tar.gz

claude_code_conductor-0.3.0/.claude/commands/develop.md

@@ -0,0 +1,11 @@
+# /develop コマンド
+
+plan-report に基づいて実装フェーズを実行する。
+
+## 必ず守ること
+
+1. **最初に必ず** `.claude/skills/dev-workflow.md` を Read する。記憶・推測で進めない
+2. **フェーズ D（実装）** から実行する
+3. dev-workflow.md の AskUserQuestion・Edit・セッションファイル更新の手順を省略しない
+4. D-0 で plan-report に YAML フロントマター（`po_plan_version`）が検出された場合は、続けて **必ず** `.claude/skills/wave-execution.md` を Read してその手順に従う（C3 メイン + PO スポット並列モード）
+5. フロントマターが無い場合は legacy の D-1〜D-5 ceremony（tester→developer→tester の TDD 逐次実行）にフォールバックする

{claude_code_conductor-0.2.4 → claude_code_conductor-0.3.0}/.claude/skills/dev-workflow.md

@@ -217,39 +217,29 @@ AskUserQuestion ツール:
 
 ---
 
-## フェーズ D: TDD
+## フェーズ D: 実装
 
 **フェーズ C から続いている場合:** plan-report はコンテキスト内にあるため読み直し不要。
 **直接開始の場合:** Glob で `.claude/reports/plan-report-*.md` の最新を Read する。存在しない場合はフェーズ C から始めるよう案内して終了する。
 
+### D-0: 実行モード自動判別
+
+plan-report の冒頭を Read し、YAML フロントマター（`---` で始まり `po_plan_version: "0.1"` を含む）の有無を確認する。
+
+**フロントマターありの場合:**
+1. **最初に必ず** `.claude/skills/wave-execution.md` を Read する（記憶・推測で進めない）
+2. `wave-execution.md` の手順に完全に従って wave 単位で実装を進める
+3. 全 wave 完了後はフェーズ E（レビュー）へ進む（wave に reviewer タスクが含まれていれば E をスキップ可能と案内する）
+
+**フロントマターなしの場合（legacy フォールバック）:**
+
 今日のセッションファイルに以下を追記する（未登録の場合のみ）:
 - `- [ ] tester: Red フェーズ`
 - `- [ ] developer: Green フェーズ`
 - `- [ ] developer: Refactor フェーズ`
 - `- [ ] tester: 最終確認`
 
-### D-0: 実行モード選択
-
-AskUserQuestion ツール:
-```json
-{
-  "questions": [{
-    "question": "TDD サイクルの実行モードを選んでください",
-    "options": [
-      { "label": "TDD 逐次実行", "description": "従来の D-1〜D-5（tester→developer→tester）で1タスクずつ進める" },
-      { "label": "PO 並列実行", "description": "parallel-orchestra で plan-report の独立タスクを git worktree 並列実行する（PO のインストールが必要）" }
-    ]
-  }]
-}
-```
-
-**「TDD 逐次実行」の場合:** D-1 へ進む。
-
-**「PO 並列実行」の場合:**
-1. **最初に必ず** `.claude/skills/parallel-execution.md` を Read する（記憶・推測で進めない）
-2. セッションファイルに `- [ ] PO 並列実行` を追記する
-3. `parallel-execution.md` の手順を完全に守る
-4. 完了後はフェーズ E（レビュー）へ進む
+D-1 へ進む。
 
 ### D-1: tester（Red フェーズ）
 

claude_code_conductor-0.3.0/.claude/skills/wave-execution.md

@@ -0,0 +1,220 @@
+# Wave Execution
+
+`/develop` のフェーズ D で plan-report に YAML フロントマター（`po_plan_version: "0.1"`）が含まれるときに Read される手順。
+
+C3 の親 Claude が plan-report の DAG を **wave 単位**で歩く。
+- 単独 wave（タスク 1 件） → C3 が直接実行（Agent ツール起動 or ペルソナ採用）
+- 複数 wave（タスク 2 件以上） → parallel-orchestra（PO）にスポット並列委譲
+
+各 wave 完了後にユーザーの承認を取る。
+
+---
+
+## 前提条件
+
+- `claude-code-conductor` がインストール済みで `c3` コマンドが PATH 上にあること
+- plan-report が `.claude/reports/plan-report-*.md` の形式で配置され、YAML フロントマターを持つこと（フロントマターが無ければ `dev-workflow.md` の D-1〜D-5 ceremony へフォールバック）
+
+---
+
+## Step 0: 妥当性チェック
+
+1. Glob で `.claude/reports/plan-report-*.md` の最新ファイルパスを取得する
+2. Read で内容（フロントマター含む）を確認する
+3. Bash で以下を実行する:
+
+   ```
+   c3 po dry-run <plan-report-path>
+   ```
+
+   - 終了コード `0` = マニフェスト妥当 → Step 1 へ
+   - 終了コード `2` = マニフェストエラー（フィールド欠損・agent 不在等）→ stderr のメッセージを整形してユーザーに提示し、`/start` のフェーズ C（計画）を再実行するか手動で plan-report を編集するよう案内してこのスキルを終了する
+   - 終了コード `1` = PO 未インストール → 以下の案内文を**そのまま提示**してこのスキルを終了する:
+
+     > 並列実行を使うには `pip install parallel-orchestra` を実行してください。
+     > 詳細: https://pypi.org/project/parallel-orchestra/
+
+     親 Claude は逐次実行（`dev-workflow.md` の D-1〜D-5）に切り替えるか、PO をインストールして `/develop` を再実行するかをユーザーに選んでもらう。
+
+---
+
+## Step 1: wave 分解
+
+Bash で以下を実行する:
+
+```
+c3 po waves <plan-report-path>
+```
+
+stdout の JSON は以下の形式になる:
+
+```json
+{
+  "waves": [
+    {
+      "index": 0,
+      "tasks": [
+        { "id": "tdd-login", "agent": "tdd-develop", "read_only": false, "writes": ["src/auth/login.py"], "prompt": "..." },
+        { "id": "tdd-logout", "agent": "tdd-develop", "read_only": false, "writes": ["src/auth/logout.py"], "prompt": "..." }
+      ]
+    },
+    {
+      "index": 1,
+      "tasks": [
+        { "id": "review-auth", "agent": "code-reviewer", "read_only": true, "writes": [], "prompt": "..." }
+      ]
+    }
+  ]
+}
+```
+
+- 終了コード `0` = 分解成功 → 親 Claude が JSON をパースして `waves` 配列を取得し Step 2 へ
+- 終了コード `2` = フロントマター不正・循環依存等 → stderr メッセージを提示して終了
+
+セッションファイル（`.claude/memory/sessions/YYYYMMDD.tmp`）に以下を追記する（未登録の場合のみ）:
+- 各 wave につき `- [ ] Wave {N} ({task_count} tasks)` を 1 行ずつ
+
+---
+
+## Step 2: wave ごとに実行する
+
+`waves` 配列を index 順にループする。各 wave で以下を順に行う。
+
+### 2-A: wave 内容を提示する
+
+親 Claude が wave のタスク一覧を Markdown 表で提示する:
+
+| id | agent | read_only | writes |
+|---|---|---|---|
+| tdd-login | tdd-develop | false | src/auth/login.py |
+| tdd-logout | tdd-develop | false | src/auth/logout.py |
+
+### 2-B: 実行可否をユーザーに確認する
+
+AskUserQuestion ツール:
+
+```json
+{
+  "questions": [{
+    "question": "Wave {N} を実行してよいですか？",
+    "options": [
+      { "label": "承認・進む", "description": "この wave を実行する" },
+      { "label": "中断", "description": "ここで wave 実行を停止する。完了済みの wave はそのまま残る" }
+    ]
+  }]
+}
+```
+
+「中断」の場合、セッションファイルの `## 試みたが失敗したアプローチ` に中断理由を追記してスキル終了。
+
+### 2-C: ランナーを選んで実行する
+
+`len(wave.tasks)` で分岐する。
+
+#### case A: 単独 wave（タスク 1 件）
+
+タスクの `agent` フィールドで更に分岐する。
+
+##### A-1: `agent == "tdd-develop"` のとき
+
+**ペルソナ採用パターン**で実行する。Agent ツールで起動するとサブエージェント depth 1 制限により内部の tester/developer サブエージェントが spawn できないため、親 Claude が直接 tdd-develop ペルソナで動く。
+
+1. `.claude/agents/tdd-develop.md` を Read してペルソナを採用する
+2. `.claude/skills/worktree-tdd-workflow.md` を Read して TDD ループ手順（tester→developer→tester）を取得する
+3. タスクの `prompt` を実装内容として、worktree-tdd-workflow.md の Step 1〜4 を **親 Claude が直接** 実行する。tester / developer は Agent ツールでスポーン可能（depth 1 で完結する）
+4. ループ完了後、結果を 2-D の集約に渡す
+
+##### A-2: `agent` がそれ以外（`code-reviewer` / `security-reviewer` / `developer` / `tester` 等）
+
+**Agent ツール起動パターン**で実行する。これらの agent は内部で更に subagent を spawn しないため depth 1 制限に抵触しない。
+
+1. Agent ツールで `subagent_type` は指定せず（カスタム agent は subagent_type 不可）、プロンプトに以下を含める:
+   - 「`.claude/agents/{agent_name}.md` を Read してペルソナを採用すること」
+   - タスクの `prompt` 本文
+2. Agent の返答を 2-D の集約に渡す
+
+##### 将来 agent を追加する場合
+
+「内部で更に subagent を呼ぶ agent」を新たに作る場合は、A-1 のペルソナ採用パターン側に追加する。判断基準: その agent の定義ファイルが「内部で Agent ツールを使う」前提になっているか。tdd-develop が現状の唯一の例。
+
+#### case B: 複数 wave（タスク 2 件以上）
+
+**PO スポット委譲**で実行する。
+
+Bash で以下を実行する:
+
+```
+c3 po run-wave <plan-report-path> --wave-index {N} --report .claude/reports/po-run-report-wave-{N}-{ts}.json
+```
+
+- `{N}` は wave の index
+- `{ts}` は `YYYYMMDD-HHMMSS` 形式。Bash で `python -c "from datetime import datetime; print(datetime.now().strftime('%Y%m%d-%H%M%S'))"` を実行して取得
+- `c3 po run-wave` は `.claude/tmp/po-manifest-wave-{N}-{ts}.md` に ephemeral マニフェストを生成し、PO に subprocess 委譲する。各タスクは PO が `claude -p --agent <name>` を独立 Claude セッション（depth 0）として起動するため、tdd-develop も内部で tester/developer を spawn できる
+
+終了コードと意味:
+
+| exit code | 意味 | 次のアクション |
+|---|---|---|
+| `0` | wave 内全タスク成功 | 2-D へ |
+| `1` | 1件以上のタスクが失敗 | 2-D へ（失敗一覧を含めて提示） |
+| `2` | マニフェストエラー（Step 0 をすり抜けた）| エラー内容を提示しスキル終了 |
+| `3` | runner エラー（claude バイナリ不在等）| `c3 doctor` の結果を提示してスキル終了 |
+
+実行完了後、生成された `po-run-report-wave-{N}-{ts}.json` を Read してタスクごとのステータスを取得する。
+
+### 2-D: 結果を集約してユーザーに提示する
+
+ランナー種別ごとに以下の形式で結果を提示する。
+
+**case A（単独 wave）:**
+- A-1: 親 Claude の TDD ループ結果（tester/developer の Agent 返答の要約、最終 tester の合否）
+- A-2: Agent の返答テキスト（必要なら要約）
+
+**case B（複数 wave / PO 委譲）:**
+- `po-run-report-wave-{N}-*.json` を Markdown 表に整形:
+
+  | id | agent | status | worktree | duration | last_error_summary |
+  |---|---|---|---|---|---|
+  | tdd-login | tdd-develop | success | wt-tdd-login | 124s | - |
+  | tdd-logout | tdd-develop | failure | wt-tdd-logout | 89s | TestLogout::test_csrf failed |
+
+### 2-E: 失敗があったら方針を確認する
+
+case A で TDD ループが不合格のまま終わった、または case B で 1 件以上失敗した場合、AskUserQuestion で次を確認する:
+
+```json
+{
+  "questions": [{
+    "question": "Wave {N} に失敗があります。どうしますか？",
+    "options": [
+      { "label": "リトライ", "description": "同じ wave をもう一度実行する" },
+      { "label": "スキップして次の wave へ", "description": "失敗を残したまま次の wave に進む" },
+      { "label": "中断", "description": "ここで wave 実行を停止する。完了済みの wave はそのまま残る" }
+    ]
+  }]
+}
+```
+
+- 「リトライ」 → 2-A から同じ wave を再実行
+- 「スキップして次の wave へ」 → 失敗内容をセッションファイルの `## 試みたが失敗したアプローチ` に追記して次の wave へ
+- 「中断」 → セッションファイルの該当 wave 行は `- [ ]` のままにしてスキル終了
+
+### 2-F: wave 完了をセッションに記録する
+
+全タスク成功した wave のみ、セッションファイルの `- [ ] Wave {N} (M tasks)` を `- [x] Wave {N} (M tasks)` に Edit する。
+
+---
+
+## Step 3: フェーズ E への遷移
+
+全 wave 完了後、フェーズ E（レビュー）への遷移を案内する。
+
+- plan-report に reviewer タスク（agent が `code-reviewer` / `security-reviewer`）が含まれている場合は wave で既に実行済みなので、二重レビューを避けるためにユーザーへ「wave 内で reviewer タスクが完了済みなので E をスキップしてもよい」と提示する
+- reviewer タスクが含まれていない場合は通常通りフェーズ E へ進む
+
+---
+
+## 知識蓄積
+
+- wave 実行で**特定パターンが詰まりがち**（例: tdd-develop の persona 起動で context が膨らみやすい）と気付いたら、セッションファイルの `## 試みたが失敗したアプローチ` に追記し `patterns` に登録する
+- wave 分解の精度（planner の出力品質）に関する観察も同様に記録する。これは将来 planner 側のルール改善に繋がる

{claude_code_conductor-0.2.4 → claude_code_conductor-0.3.0}/CHANGELOG.md

@@ -1,5 +1,47 @@
 # Changelog
 
+## [0.3.0] - 2026-04-30
+
+### Changed (breaking)
+- `/develop` now auto-detects YAML frontmatter on the latest plan-report and
+  switches between two modes:
+  - **frontmatter present** → new "C3 main + PO spot" workflow. C3 walks the
+    DAG wave-by-wave, asks for user approval before each wave, and dispatches
+    each wave to the right runner: solo waves run on the C3 host (Agent-tool
+    spawn for `code-reviewer` / `developer` / `tester`, parent-Claude persona
+    adoption for `tdd-develop` to avoid the depth-1 nested-spawn limit), and
+    multi-task waves are delegated to parallel-orchestra via an ephemeral
+    wave-only manifest under `.claude/tmp/`.
+  - **no frontmatter** → legacy D-1〜D-5 sequential TDD ceremony, unchanged.
+- The previous "PO 全委譲" model (D-0 two-choice prompt) and
+  `.claude/skills/parallel-execution.md` are removed. The new flow is
+  documented in `.claude/skills/wave-execution.md`.
+
+### Added
+- `c3 po waves <plan-report>` — prints the topological wave decomposition of
+  a manifest as JSON. Used by `wave-execution.md` to drive the per-wave loop.
+- `c3 po run-wave <plan-report> --wave-index N` — generates a wave-only
+  ephemeral manifest under `.claude/tmp/po-manifest-wave-{N}-{ts}.md` and
+  hands it to parallel-orchestra.
+- `c3.po.manifest.compute_waves(frontmatter)` — Kahn's-algorithm topological
+  wave decomposition. Detects cycles, unknown dependency ids, and duplicate
+  task ids.
+- `c3.po.manifest.build_wave_manifest_text(frontmatter, wave_index)` —
+  emits a parseable plan-report Markdown for one wave, dropping `depends_on`
+  and webhook fields and decorating the manifest name with ` - wave N`.
+- `tests/test_po_waves.py` (16 tests) and `tests/test_cli_po.py` (5 tests)
+  covering wave decomposition, ephemeral-manifest generation, CLI exit
+  codes, and frontmatter round-trip.
+
+### Notes
+- The persona-adoption pattern for `tdd-develop` in solo waves is the direct
+  consequence of Claude Code's depth-1 nested-spawn limit (a sub-agent
+  spawned via the Agent tool cannot itself spawn another sub-agent). For
+  agents that internally spawn sub-agents (today: `tdd-develop`), the parent
+  Claude reads the agent definition and adopts its persona instead. Other
+  agents (`code-reviewer`, `security-reviewer`, `developer`, `tester`) keep
+  using the standard Agent-tool spawn path.
+
 ## [0.2.4] - 2026-05-01
 
 ### Changed

{claude_code_conductor-0.2.4 → claude_code_conductor-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-conductor
-Version: 0.2.4
+Version: 0.3.0
 Summary: Multi-agent orchestration framework for Claude Code (C3)
 Project-URL: Homepage, https://github.com/satoh-y-0323/claude-code-conductor
 Project-URL: Repository, https://github.com/satoh-y-0323/claude-code-conductor

{claude_code_conductor-0.2.4 → claude_code_conductor-0.3.0}/src/c3/__init__.py

@@ -1,3 +1,3 @@
 """Claude Code Conductor (C3) - multi-agent orchestration framework for Claude Code."""
 
-__version__ = "0.2.4"
+__version__ = "0.3.0"

claude_code_conductor-0.3.0/src/c3/cli_po.py

@@ -0,0 +1,208 @@
+"""``c3 po`` - thin wrapper around the parallel-orchestra CLI."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from datetime import datetime
+from pathlib import Path
+
+from c3.paths import claude_root_for
+from c3.po.detect import detect_po
+from c3.po.manifest import (
+    build_wave_manifest_text,
+    compute_waves,
+    extract_frontmatter,
+    validate_manifest,
+)
+from c3.po.run import run_manifest
+
+
+_NOT_INSTALLED_MSG = (
+    "parallel-orchestra is not installed. "
+    "並列実行を使うには `pip install parallel-orchestra` を実行してください。"
+    "詳細: https://pypi.org/project/parallel-orchestra/"
+)
+
+
+def register(subparsers: argparse._SubParsersAction) -> None:
+    parser = subparsers.add_parser(
+        "po",
+        help="Run a plan-report as a parallel-orchestra manifest",
+    )
+    inner = parser.add_subparsers(dest="po_command", metavar="<subcommand>")
+    inner.required = True
+
+    dry = inner.add_parser(
+        "dry-run",
+        help="Validate the manifest without executing tasks",
+    )
+    dry.add_argument("manifest", type=Path)
+    dry.set_defaults(handler=_handle_dry_run)
+
+    run = inner.add_parser(
+        "run",
+        help="Execute the full manifest in one PO invocation",
+    )
+    run.add_argument("manifest", type=Path)
+    run.add_argument("--max-workers", type=int, default=None)
+    run.add_argument("--report", type=Path, default=None)
+    run.add_argument("--quiet", action="store_true")
+    run.add_argument("--claude-exe", default=None)
+    run.set_defaults(handler=_handle_run)
+
+    waves = inner.add_parser(
+        "waves",
+        help="Print the topological-wave decomposition of the manifest as JSON",
+    )
+    waves.add_argument("manifest", type=Path)
+    waves.set_defaults(handler=_handle_waves)
+
+    run_wave = inner.add_parser(
+        "run-wave",
+        help="Execute only the wave at the given index via PO",
+    )
+    run_wave.add_argument("manifest", type=Path)
+    run_wave.add_argument("--wave-index", type=int, required=True)
+    run_wave.add_argument("--max-workers", type=int, default=None)
+    run_wave.add_argument("--report", type=Path, default=None)
+    run_wave.add_argument("--quiet", action="store_true")
+    run_wave.add_argument("--claude-exe", default=None)
+    run_wave.set_defaults(handler=_handle_run_wave)
+
+
+def _ensure_po_available() -> int:
+    available, _, _ = detect_po()
+    if not available:
+        print(_NOT_INSTALLED_MSG, file=sys.stderr)
+        return 1
+    return 0
+
+
+def _preflight(manifest: Path) -> int:
+    if not manifest.is_file():
+        print(f"manifest not found: {manifest}", file=sys.stderr)
+        return 2
+    root = claude_root_for(manifest.parent) or claude_root_for(Path.cwd())
+    if root is None:
+        print("could not locate .claude/ directory for agent lookup", file=sys.stderr)
+        return 2
+    errors = validate_manifest(manifest, root)
+    if errors:
+        for err in errors:
+            print(err, file=sys.stderr)
+        return 2
+    return 0
+
+
+def _handle_dry_run(args: argparse.Namespace) -> int:
+    rc = _preflight(args.manifest)
+    if rc != 0:
+        return rc
+    if (rc := _ensure_po_available()) != 0:
+        return rc
+    result = run_manifest(args.manifest, dry_run=True)
+    if result.status == "not_installed":
+        print(_NOT_INSTALLED_MSG, file=sys.stderr)
+        return 1
+    return result.exit_code if result.exit_code >= 0 else 1
+
+
+def _handle_run(args: argparse.Namespace) -> int:
+    rc = _preflight(args.manifest)
+    if rc != 0:
+        return rc
+    if (rc := _ensure_po_available()) != 0:
+        return rc
+    result = run_manifest(
+        args.manifest,
+        max_workers=args.max_workers,
+        report=args.report,
+        quiet=args.quiet,
+        claude_exe=args.claude_exe,
+    )
+    if result.status == "not_installed":
+        print(_NOT_INSTALLED_MSG, file=sys.stderr)
+        return 1
+    return result.exit_code if result.exit_code >= 0 else 1
+
+
+def _handle_waves(args: argparse.Namespace) -> int:
+    rc = _preflight(args.manifest)
+    if rc != 0:
+        return rc
+    fm = extract_frontmatter(args.manifest)
+    if fm is None:
+        # Should not happen after _preflight passed, but be defensive.
+        print("could not parse frontmatter", file=sys.stderr)
+        return 2
+    try:
+        waves = compute_waves(fm)
+    except ValueError as exc:
+        print(str(exc), file=sys.stderr)
+        return 2
+    output = {
+        "waves": [
+            {
+                "index": index,
+                "tasks": [
+                    {
+                        "id": task["id"],
+                        "agent": task.get("agent"),
+                        "read_only": task.get("read_only"),
+                        "writes": task.get("writes") or [],
+                        "prompt": task.get("prompt", ""),
+                    }
+                    for task in wave_tasks
+                ],
+            }
+            for index, wave_tasks in enumerate(waves)
+        ]
+    }
+    json.dump(output, sys.stdout, ensure_ascii=False, indent=2)
+    sys.stdout.write("\n")
+    return 0
+
+
+def _handle_run_wave(args: argparse.Namespace) -> int:
+    rc = _preflight(args.manifest)
+    if rc != 0:
+        return rc
+    if (rc := _ensure_po_available()) != 0:
+        return rc
+
+    fm = extract_frontmatter(args.manifest)
+    if fm is None:
+        print("could not parse frontmatter", file=sys.stderr)
+        return 2
+    try:
+        wave_text = build_wave_manifest_text(fm, args.wave_index)
+    except (IndexError, ValueError) as exc:
+        print(str(exc), file=sys.stderr)
+        return 2
+
+    root = claude_root_for(args.manifest.parent) or claude_root_for(Path.cwd())
+    if root is None:
+        print(
+            "could not locate .claude/ directory to materialise the wave manifest",
+            file=sys.stderr,
+        )
+        return 2
+    tmp_dir = root / ".claude" / "tmp"
+    tmp_dir.mkdir(parents=True, exist_ok=True)
+    timestamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+    wave_path = tmp_dir / f"po-manifest-wave-{args.wave_index}-{timestamp}.md"
+    wave_path.write_text(wave_text, encoding="utf-8")
+
+    result = run_manifest(
+        wave_path,
+        max_workers=args.max_workers,
+        report=args.report,
+        quiet=args.quiet,
+        claude_exe=args.claude_exe,
+    )
+    if result.status == "not_installed":
+        print(_NOT_INSTALLED_MSG, file=sys.stderr)
+        return 1
+    return result.exit_code if result.exit_code >= 0 else 1

{claude_code_conductor-0.2.4 → claude_code_conductor-0.3.0}/src/c3/po/manifest.py

@@ -23,6 +23,152 @@ from typing import Any
 _FRONTMATTER_RE = re.compile(r"^---\s*\n(.*?)\n---\s*(?:\n|\Z)", re.DOTALL)
 
 
+# ---------------------------------------------------------------------------
+# Topological wave decomposition
+# ---------------------------------------------------------------------------
+
+
+def compute_waves(frontmatter: dict) -> list[list[dict]]:
+    """Group ``frontmatter['tasks']`` into topological waves.
+
+    Wave 0 contains tasks with no ``depends_on`` references that are still
+    pending. Wave N contains tasks whose ``depends_on`` are all in waves
+    < N. Within each wave, tasks are independent and may execute in
+    parallel.
+
+    Wave order is deterministic: tasks within a wave are sorted by ``id``.
+
+    Raises:
+        ValueError: a cycle exists or a ``depends_on`` references an
+            unknown task id.
+    """
+    tasks = frontmatter.get("tasks") or []
+    if not isinstance(tasks, list) or not tasks:
+        return []
+
+    by_id: dict[str, dict] = {}
+    for task in tasks:
+        if not isinstance(task, dict):
+            raise ValueError("each task must be a mapping")
+        task_id = task.get("id")
+        if not isinstance(task_id, str) or not task_id:
+            raise ValueError("each task must have a string `id`")
+        if task_id in by_id:
+            raise ValueError(f"duplicate task id: {task_id!r}")
+        by_id[task_id] = task
+
+    for task in by_id.values():
+        for dep in task.get("depends_on", []) or []:
+            if dep not in by_id:
+                raise ValueError(
+                    f"task {task['id']!r} depends_on unknown id {dep!r}"
+                )
+
+    remaining = dict(by_id)
+    waves: list[list[dict]] = []
+    while remaining:
+        ready = [
+            t for t in remaining.values()
+            if all(d not in remaining for d in t.get("depends_on", []) or [])
+        ]
+        if not ready:
+            raise ValueError(
+                f"cycle detected among tasks: {sorted(remaining)}"
+            )
+        waves.append(sorted(ready, key=lambda t: t["id"]))
+        for t in ready:
+            del remaining[t["id"]]
+    return waves
+
+
+def build_wave_manifest_text(
+    frontmatter: dict, wave_index: int, *, body: str = ""
+) -> str:
+    """Render an ephemeral PO manifest containing only the wave's tasks.
+
+    All ``depends_on`` references are dropped (tasks within a single wave are
+    independent by construction). Top-level fields ``po_plan_version`` /
+    ``name`` / ``cwd`` / ``defaults`` / ``concurrency_limits`` are preserved;
+    ``on_complete`` / ``on_failure`` webhooks are dropped because they are
+    plan-level (not per-wave) lifecycle hooks.
+
+    Raises:
+        IndexError: ``wave_index`` is out of range.
+    """
+    waves = compute_waves(frontmatter)
+    if wave_index < 0 or wave_index >= len(waves):
+        raise IndexError(
+            f"wave_index {wave_index} out of range (have {len(waves)} waves)"
+        )
+    wave_tasks = waves[wave_index]
+
+    lines: list[str] = ["---"]
+    lines.append(f'po_plan_version: "{frontmatter.get("po_plan_version", "0.1")}"')
+    base_name = frontmatter.get("name", "wave")
+    lines.append(f"name: {_yaml_quote(f'{base_name} - wave {wave_index}')}")
+    lines.append(f"cwd: {_yaml_quote(frontmatter['cwd'])}")
+    defaults = frontmatter.get("defaults")
+    if isinstance(defaults, dict) and defaults:
+        lines.append("defaults:")
+        for k, v in defaults.items():
+            lines.append(f"  {k}: {_yaml_scalar(v)}")
+    cgroups = frontmatter.get("concurrency_limits")
+    if isinstance(cgroups, dict) and cgroups:
+        lines.append("concurrency_limits:")
+        for k, v in cgroups.items():
+            lines.append(f"  {k}: {_yaml_scalar(v)}")
+    lines.append("")
+    lines.append("tasks:")
+    for task in wave_tasks:
+        lines.append(f"  - id: {task['id']}")
+        lines.append(f"    agent: {task['agent']}")
+        lines.append(f"    read_only: {'true' if task['read_only'] else 'false'}")
+        prompt = task.get("prompt", "")
+        if "\n" in prompt or len(prompt) > 80:
+            lines.append("    prompt: |")
+            for pline in prompt.rstrip("\n").splitlines():
+                lines.append(f"      {pline}")
+        else:
+            lines.append(f"    prompt: {_yaml_quote(prompt)}")
+        writes = task.get("writes")
+        if isinstance(writes, list) and writes:
+            lines.append("    writes:")
+            for w in writes:
+                lines.append(f"      - {w}")
+        max_retries = task.get("max_retries")
+        if isinstance(max_retries, int):
+            lines.append(f"    max_retries: {max_retries}")
+        cgroup = task.get("concurrency_group")
+        if isinstance(cgroup, str) and cgroup:
+            lines.append(f"    concurrency_group: {cgroup}")
+        # Intentionally no depends_on: wave is internally independent.
+    lines.append("---")
+    lines.append("")
+    if body:
+        lines.append(body.rstrip("\n"))
+    else:
+        lines.append(f"# Wave {wave_index} manifest (generated by c3 po run-wave)")
+    return "\n".join(lines) + "\n"
+
+
+def _yaml_quote(s: str) -> str:
+    if s == "":
+        return '""'
+    return '"' + s.replace("\\", "\\\\").replace('"', '\\"') + '"'
+
+
+def _yaml_scalar(v: Any) -> str:
+    if v is None:
+        return "null"
+    if isinstance(v, bool):
+        return "true" if v else "false"
+    if isinstance(v, (int, float)):
+        return str(v)
+    if isinstance(v, str):
+        return _yaml_quote(v)
+    raise TypeError(f"unsupported scalar type: {type(v)}")
+
+
 # ---------------------------------------------------------------------------
 # Frontmatter extraction
 # ---------------------------------------------------------------------------

claude_code_conductor-0.2.4/.claude/commands/develop.md

@@ -1,10 +0,0 @@
-# /develop コマンド
-
-plan-report に基づき TDD サイクルで実装を進める。
-
-## 必ず守ること
-
-1. **最初に必ず** `.claude/skills/dev-workflow.md` を Read する。記憶・推測で進めない
-2. **フェーズ D（TDD）** から実行する
-3. dev-workflow.md の AskUserQuestion・Edit・セッションファイル更新の手順を省略しない
-4. D-0 で「PO 並列実行」が選ばれた場合は、続けて **必ず** `.claude/skills/parallel-execution.md` を Read してその手順に従う

claude_code_conductor-0.2.4/.claude/skills/parallel-execution.md

@@ -1,121 +0,0 @@
-# Parallel Execution (parallel-orchestra)
-
-`/develop` の **D-0** で「PO 並列実行」が選ばれたときに Read される手順。
-parallel-orchestra (PO) を subprocess で起動し、plan-report を YAML フロントマター付きマニフェストとして並列実行する。
-
----
-
-## 前提条件
-
-- `.claude/reports/plan-report-*.md` の最新ファイルに YAML フロントマター（`po_plan_version: "0.1"` を含む）が付いていること
-- `claude-code-conductor` がインストール済みで `c3` コマンドが PATH 上にあること
-
----
-
-## Step 0: PO の利用可否を確認する
-
-Bash ツールで以下を実行する:
-
-```
-c3 doctor --check po-only --quiet
-```
-
-- 終了コード `0`（出力なし）= PO 利用可能 → Step 1 へ
-- 終了コード `1` = PO 未インストール → 以下の案内文を**そのまま提示**してこのスキルを終了する:
-
-> 並列実行を使うには `pip install parallel-orchestra` を実行してください。
-> 詳細: https://pypi.org/project/parallel-orchestra/
-
-**注意:** 案内はエラーではなく **情報メッセージ**として出すこと。`/develop` 全体は失敗扱いにせず、ユーザーに「逐次実行（D-0 の選択肢 [A]）に切り替える」または「PO をインストールして再実行する」のいずれかを選んでもらう。
-
----
-
-## Step 1: マニフェストの妥当性確認
-
-1. Glob で `.claude/reports/plan-report-*.md` の最新ファイルパスを取得
-2. Read で内容（フロントマター含む）を確認
-3. Bash で以下を実行:
-
-```
-c3 po dry-run <plan-report-path>
-```
-
-- 終了コード `0` = マニフェスト妥当 → Step 2 へ
-- 終了コード `2` = マニフェストエラー（フィールド欠損・agent 不在等）→ stderr のメッセージを整形してユーザーに提示し、`/start` の **フェーズ C（計画）** を再実行するか手動で plan-report を編集するよう案内してこのスキルを終了する
-- 終了コード `1` = PO 未インストール（Step 0 をすり抜けた場合のフォールバック）→ Step 0 と同じ案内文を出して終了
-
----
-
-## Step 2: ユーザー承認
-
-承認なしで先に進まない。並列実行は git worktree を作って auto-commit するため副作用が大きい。
-
-1. 親 Claude が plan-report の **フロントマター** を Read で再パースし、以下を要約してテキストで提示:
-   - タスク総数
-   - うち `read_only: false` のタスク数（= 作成される worktree 数）
-   - 各タスクの `id` / `agent` / `writes`（あれば）の表
-2. AskUserQuestion ツールで実行可否を確認:
-
-```json
-{
-  "questions": [{
-    "question": "並列実行を開始してよいですか？",
-    "options": [
-      { "label": "承認", "description": "parallel-orchestra で実行を開始する" },
-      { "label": "max_workers を変更して承認", "description": "次の入力で並列度を指定する（デフォルトは PO 側で 3）" },
-      { "label": "キャンセル", "description": "並列実行を中止する。/develop の D-0 から逐次実行に切り替えられる" }
-    ]
-  }]
-}
-```
-
-- 「max_workers を変更して承認」が選ばれた場合、追加 AskUserQuestion で並列度（整数）を聞く
-- 「キャンセル」の場合、セッションファイルに `## 試みたが失敗したアプローチ` として理由を追記してスキル終了
-
----
-
-## Step 3: parallel-orchestra を起動する
-
-Bash で以下を実行:
-
-```
-c3 po run <plan-report-path> --report .claude/reports/po-run-report-{timestamp}.json [--max-workers N]
-```
-
-- `{timestamp}` は `YYYYMMDD-HHMMSS` 形式。Bash で `python -c "from datetime import datetime; print(datetime.now().strftime('%Y%m%d-%H%M%S'))"` を実行して取得
-- `--max-workers` は Step 2 でユーザーが指定した場合のみ付与
-- 進捗ダッシュボードはターミナルに直接出力される（親 Claude のコンテキストには末尾の状態のみ流れる）
-
-終了コードと意味:
-
-| exit code | 意味 | 次のアクション |
-|---|---|---|
-| `0` | 全タスク成功 | Step 4 へ |
-| `1` | 1件以上のタスクが失敗 | Step 4 へ（失敗タスクの再実行案内を出す） |
-| `2` | マニフェストエラー（Step 1 をすり抜けた） | エラー内容を提示し計画フェーズへ戻るよう案内してスキル終了 |
-| `3` | runner エラー（claude バイナリ不在等） | `c3 doctor` の結果を提示してスキル終了 |
-
----
-
-## Step 4: レポートの要約とセッション更新
-
-1. Step 3 で生成された `.claude/reports/po-run-report-{timestamp}.json` を Read
-2. 親 Claude がタスクごとのステータスを Markdown 表に整形してユーザーに提示する:
-   - 列: `id` / `agent` / `status` / `worktree` / `duration` / 失敗時は `last_error_summary`
-3. 失敗タスクがある場合、該当タスクのみ `/develop` の D-A 経路（逐次実行）で再実行する選択肢を AskUserQuestion で提示:
-
-```json
-{
-  "questions": [{
-    "question": "失敗タスクをどうしますか？",
-    "options": [
-      { "label": "逐次実行で再修正する", "description": "失敗タスクのみ /develop の D-A（TDD 逐次）で再実行する" },
-      { "label": "計画フェーズへ戻る", "description": "失敗の原因が設計レベルなら /start のフェーズ C で再計画する" },
-      { "label": "ここで終わる", "description": "現状で停止し、フェーズ E（レビュー）には進まない" }
-    ]
-  }]
-}
-```
-
-4. セッションファイル（`.claude/memory/sessions/YYYYMMDD.tmp`）の `- [ ] PO 並列実行` を `- [x]` に Edit する。失敗タスクが残った場合は `- [ ]` のままにし、失敗内容を `## 試みたが失敗したアプローチ` に追記する
-5. 全タスク成功した場合のみ、フェーズ E（レビュー）へ進む案内を出す

claude_code_conductor-0.2.4/src/c3/cli_po.py

@@ -1,102 +0,0 @@
-"""``c3 po`` - thin wrapper around the parallel-orchestra CLI."""
-
-from __future__ import annotations
-
-import argparse
-import sys
-from pathlib import Path
-
-from c3.paths import claude_root_for
-from c3.po.detect import detect_po
-from c3.po.manifest import validate_manifest
-from c3.po.run import run_manifest
-
-
-_NOT_INSTALLED_MSG = (
-    "parallel-orchestra is not installed. "
-    "並列実行を使うには `pip install parallel-orchestra` を実行してください。"
-    "詳細: https://pypi.org/project/parallel-orchestra/"
-)
-
-
-def register(subparsers: argparse._SubParsersAction) -> None:
-    parser = subparsers.add_parser(
-        "po",
-        help="Run a plan-report as a parallel-orchestra manifest",
-    )
-    inner = parser.add_subparsers(dest="po_command", metavar="<subcommand>")
-    inner.required = True
-
-    dry = inner.add_parser(
-        "dry-run",
-        help="Validate the manifest without executing tasks",
-    )
-    dry.add_argument("manifest", type=Path)
-    dry.set_defaults(handler=_handle_dry_run)
-
-    run = inner.add_parser(
-        "run",
-        help="Execute the manifest",
-    )
-    run.add_argument("manifest", type=Path)
-    run.add_argument("--max-workers", type=int, default=None)
-    run.add_argument("--report", type=Path, default=None)
-    run.add_argument("--quiet", action="store_true")
-    run.add_argument("--claude-exe", default=None)
-    run.set_defaults(handler=_handle_run)
-
-
-def _ensure_po_available() -> int:
-    available, _, _ = detect_po()
-    if not available:
-        print(_NOT_INSTALLED_MSG, file=sys.stderr)
-        return 1
-    return 0
-
-
-def _preflight(manifest: Path) -> int:
-    if not manifest.is_file():
-        print(f"manifest not found: {manifest}", file=sys.stderr)
-        return 2
-    root = claude_root_for(manifest.parent) or claude_root_for(Path.cwd())
-    if root is None:
-        print("could not locate .claude/ directory for agent lookup", file=sys.stderr)
-        return 2
-    errors = validate_manifest(manifest, root)
-    if errors:
-        for err in errors:
-            print(err, file=sys.stderr)
-        return 2
-    return 0
-
-
-def _handle_dry_run(args: argparse.Namespace) -> int:
-    rc = _preflight(args.manifest)
-    if rc != 0:
-        return rc
-    if (rc := _ensure_po_available()) != 0:
-        return rc
-    result = run_manifest(args.manifest, dry_run=True)
-    if result.status == "not_installed":
-        print(_NOT_INSTALLED_MSG, file=sys.stderr)
-        return 1
-    return result.exit_code if result.exit_code >= 0 else 1
-
-
-def _handle_run(args: argparse.Namespace) -> int:
-    rc = _preflight(args.manifest)
-    if rc != 0:
-        return rc
-    if (rc := _ensure_po_available()) != 0:
-        return rc
-    result = run_manifest(
-        args.manifest,
-        max_workers=args.max_workers,
-        report=args.report,
-        quiet=args.quiet,
-        claude_exe=args.claude_exe,
-    )
-    if result.status == "not_installed":
-        print(_NOT_INSTALLED_MSG, file=sys.stderr)
-        return 1
-    return result.exit_code if result.exit_code >= 0 else 1