cowork-flow 0.0.47 → 0.0.49

package/template/skills/party-mode/scripts/party_mode_v2.py

@@ -10,11 +10,8 @@ from __future__ import annotations
 
 import argparse
 import json
-import os
 import re
 import sys
-import threading
-from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any
 
@@ -29,13 +26,49 @@ def _add_runtime_scripts_path() -> None:
 
 
 _add_runtime_scripts_path()
+_SCRIPT_DIR = Path(__file__).resolve().parent
+if str(_SCRIPT_DIR) not in sys.path:
+    sys.path.insert(0, str(_SCRIPT_DIR))
+
+from party_board_store import (
+    append_action_history as _append_action_history,
+    append_audit as _append_audit,
+    load_board,
+    read_json as _read_json,
+    save_board,
+    state_lock as _state_lock,
+    write_json as _write_json,
+)
+from party_action_contract import validate_actions_document
+from party_actions import (
+    actions_document as _project_actions_document,
+    child_action as _project_child_action,
+    close_actions as _project_close_actions,
+    empty_actions_document as _project_empty_actions,
+    fallback_actions_document as _project_fallback_actions,
+)
+from party_reports import (
+    action_results_summary as _project_action_results_summary,
+    build_final_report as _project_final_report,
+)
+from party_state_machine import (
+    advance_board_state as _advance_board_state,
+    build_public_round as _project_public_round,
+    current_round as _project_current_round,
+    ensure_finalizable as _ensure_finalizable_state,
+    initial_agents_state as _project_initial_agents_state,
+    initial_board as _project_initial_board,
+)
 from infra.config import get_party_mode_v2_config
 from infra.paths import DIR_WORKFLOW, get_repo_root
+from adapters.host.host_manifest import load_host_manifest
 
 RUNTIME_DIR = ".runtime"
 MODE_DIR = "party-mode-v2"
 SAFE_ID_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]*$")
 CONFIDENCE_VALUES = {"low", "medium", "high"}
+PARTY_BOARD_ACTION_CAPABILITY = "party_board_action"
+SUPPORTED_HOST_CAPABILITY_STATUSES = {"native", "shim", "plugin", "external", "experimental"}
 HOST_FORBIDDEN_TERMS = (
     "spawn_agent",
     "wait_agent",
@@ -44,12 +77,6 @@ HOST_FORBIDDEN_TERMS = (
     "Claude Task",
     "OpenCode task",
 )
-_LOCKS_GUARD = threading.Lock()
-_STATE_LOCKS: dict[str, dict[str, Any]] = {}
-
-
-def _now() -> str:
-    return datetime.now(timezone.utc).isoformat()
 
 
 def _validate_identifier(value: str, *, label: str) -> str:
@@ -71,117 +98,6 @@ def discussion_dir(repo_root: Path, discussion_id: str) -> Path:
     return path
 
 
-def _lock_file(handle: Any) -> None:
-    if os.name == "nt":
-        import msvcrt
-
-        handle.seek(0)
-        msvcrt.locking(handle.fileno(), msvcrt.LK_LOCK, 1)
-        return
-
-    import fcntl
-
-    fcntl.flock(handle.fileno(), fcntl.LOCK_EX)
-
-
-def _unlock_file(handle: Any) -> None:
-    if os.name == "nt":
-        import msvcrt
-
-        handle.seek(0)
-        msvcrt.locking(handle.fileno(), msvcrt.LK_UNLCK, 1)
-        return
-
-    import fcntl
-
-    fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
-
-
-class _StateLock:
-    def __init__(self, base_dir: Path, state: dict[str, Any]) -> None:
-        self.base_dir = base_dir
-        self.state = state
-
-    def __enter__(self) -> "_StateLock":
-        thread_lock = self.state["thread_lock"]
-        thread_lock.acquire()
-        current_thread = threading.get_ident()
-        if self.state.get("owner_thread") == current_thread:
-            self.state["depth"] += 1
-            return self
-
-        self.base_dir.mkdir(parents=True, exist_ok=True)
-        lock_path = self.base_dir / ".state.lock"
-        handle = lock_path.open("a+b")
-        handle.seek(0)
-        handle.write(b"0")
-        handle.flush()
-        _lock_file(handle)
-        self.state["owner_thread"] = current_thread
-        self.state["depth"] = 1
-        self.state["handle"] = handle
-        return self
-
-    def __exit__(self, exc_type: Any, exc: Any, traceback: Any) -> None:
-        thread_lock = self.state["thread_lock"]
-        try:
-            current_thread = threading.get_ident()
-            if self.state.get("owner_thread") == current_thread:
-                self.state["depth"] -= 1
-                if self.state["depth"] == 0:
-                    handle = self.state.pop("handle", None)
-                    self.state["owner_thread"] = None
-                    if handle is not None:
-                        try:
-                            _unlock_file(handle)
-                        finally:
-                            handle.close()
-        finally:
-            thread_lock.release()
-
-
-def _state_lock(base_dir: Path) -> _StateLock:
-    key = str(base_dir.resolve())
-    with _LOCKS_GUARD:
-        state = _STATE_LOCKS.get(key)
-        if state is None:
-            state = {
-                "thread_lock": threading.RLock(),
-                "owner_thread": None,
-                "depth": 0,
-            }
-            _STATE_LOCKS[key] = state
-        return _StateLock(base_dir, state)
-
-
-def _write_json(path: Path, data: dict[str, Any]) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    temp_path = path.with_name(f".{path.name}.{threading.get_ident()}.tmp")
-    temp_path.write_text(
-        json.dumps(data, ensure_ascii=False, indent=2) + "\n",
-        encoding="utf-8",
-    )
-    os.replace(temp_path, path)
-
-
-def _read_json(path: Path) -> dict[str, Any]:
-    return json.loads(path.read_text(encoding="utf-8"))
-
-
-def _append_audit(base_dir: Path, event: str, payload: dict[str, Any]) -> None:
-    audit_path = base_dir / "audit.jsonl"
-    entry = {"timestamp": _now(), "event": event, "payload": payload}
-    with audit_path.open("a", encoding="utf-8") as handle:
-        handle.write(json.dumps(entry, ensure_ascii=False) + "\n")
-
-
-def _append_action_history(base_dir: Path, event: str, payload: dict[str, Any]) -> None:
-    history_path = base_dir / "action_history.jsonl"
-    entry = {"timestamp": _now(), "event": event, "payload": payload}
-    with history_path.open("a", encoding="utf-8") as handle:
-        handle.write(json.dumps(entry, ensure_ascii=False) + "\n")
-
-
 def _parse_agent_spec(spec: str) -> dict[str, str]:
     agent_id, separator, lens = spec.partition(":")
     agent_id = agent_id.strip()
@@ -309,40 +225,7 @@ def _round_empty_state(items: list[Any], phase: str, *, item_type: str) -> str |
 
 
 def _build_public_round(board: dict[str, Any]) -> dict[str, Any]:
-    current_round = int(board["round"]["current"])
-    current = next(
-        (
-            item
-            for item in board.get("rounds", [])
-            if int(item.get("round", -1)) == current_round
-        ),
-        {"round": current_round, "posts": [], "responses": [], "moderator_events": []},
-    )
-    posts = list(current.get("posts", []))
-    responses = list(current.get("responses", []))
-    phase = board["round"]["phase"]
-    expected_next_action = {
-        "publish": "post",
-        "respond": "respond",
-        "closed": "finalized",
-    }.get(str(phase), "monitor")
-    return {
-        "schema_version": 1,
-        "discussion_id": board["discussion_id"],
-        "round": current_round,
-        "phase": phase,
-        "topic": board["topic"],
-        "visible_posts": posts,
-        "visible_responses": responses,
-        "moderator_events": list(current.get("moderator_events", [])),
-        "empty_state": {
-            "visible_posts": _round_empty_state(posts, phase, item_type="posts"),
-            "visible_responses": _round_empty_state(responses, phase, item_type="responses"),
-        },
-        "expected_next_action": expected_next_action,
-    }
-
-
+    return _project_public_round(board)
 def _agent_prompt_file(
     base_dir: Path,
     discussion_id: str,
@@ -362,6 +245,81 @@ def _agent_prompt_file(
     return prompt_name, str(prompt_file)
 
 
+def _host_manifest_root(repo_root: Path) -> Path:
+    repo_manifest = repo_root / DIR_WORKFLOW / "spec" / "runtime" / "host-assets.json"
+    if repo_manifest.is_file():
+        return repo_root
+    for parent in _SCRIPT_DIR.parents:
+        if (parent / DIR_WORKFLOW / "spec" / "runtime" / "host-assets.json").is_file():
+            return parent
+    return repo_root
+
+
+def _normalize_host_id(host_id: str | None) -> str | None:
+    if host_id is None or not str(host_id).strip():
+        return None
+    return _validate_identifier(str(host_id).strip(), label="host_id")
+
+
+def _party_board_capability(repo_root: Path, host_id: str | None) -> Any | None:
+    if host_id is None:
+        return None
+    manifest = load_host_manifest(_host_manifest_root(repo_root))
+    return manifest.host_capability(host_id, PARTY_BOARD_ACTION_CAPABILITY)
+
+
+def _party_board_action_is_supported(repo_root: Path, host_id: str | None) -> bool:
+    capability = _party_board_capability(repo_root, host_id)
+    if capability is None:
+        return True
+    return capability.status in SUPPORTED_HOST_CAPABILITY_STATUSES
+
+
+def _party_board_fallback_actions(
+    repo_root: Path,
+    base_dir: Path,
+    discussion_id: str,
+    agents: list[dict[str, str]],
+    *,
+    round_number: int,
+    phase: str,
+    host_id: str,
+) -> dict[str, Any]:
+    capability = _party_board_capability(repo_root, host_id)
+    fallback = capability.fallback if capability is not None else "inline_or_manual"
+    (base_dir / "prompts").mkdir(parents=True, exist_ok=True)
+    prompt_files: list[str] = []
+    for agent in agents:
+        _prompt_name, prompt_file = _agent_prompt_file(
+            base_dir,
+            discussion_id,
+            agent,
+            round_number=round_number,
+            phase=phase,
+        )
+        prompt_files.append(prompt_file)
+    document = _project_fallback_actions(
+        discussion_id,
+        round_number=round_number,
+        phase=phase,
+        host_id=host_id,
+        fallback=fallback,
+    )
+    action = document["next_actions"][0]
+    _append_action_history(base_dir, "action-issued", action)
+    _append_audit(
+        base_dir,
+        "fallback",
+        {
+            "host_id": host_id,
+            "capability": PARTY_BOARD_ACTION_CAPABILITY,
+            "fallback": fallback,
+            "round": round_number,
+            "phase": phase,
+            "prompt_files": prompt_files,
+        },
+    )
+    return document
 def _child_action(
     base_dir: Path,
     discussion_id: str,
@@ -370,7 +328,6 @@ def _child_action(
     round_number: int,
     phase: str,
 ) -> dict[str, Any]:
-    agent_id = agent["agent_id"]
     _prompt_name, prompt_file = _agent_prompt_file(
         base_dir,
         discussion_id,
@@ -378,48 +335,55 @@ def _child_action(
         round_number=round_number,
         phase=phase,
     )
-    return {
-        "action_id": f"r{round_number}-{phase}-{agent_id}",
-        "type": "dispatch_child" if phase == "publish" else "send_control_message",
-        "agent_id": agent_id,
-        "agent_kind": "advisory",
-        "lens": agent["lens"],
-        "message_kind": f"board_{phase}",
-        "prompt_file": prompt_file,
-    }
-
-
+    return _project_child_action(
+        agent=agent,
+        round_number=round_number,
+        phase=phase,
+        prompt_file=prompt_file,
+    )
 def _build_actions(
+    repo_root: Path,
     base_dir: Path,
     discussion_id: str,
     agents: list[dict[str, str]],
     *,
     round_number: int,
     phase: str,
+    host_id: str | None = None,
 ) -> dict[str, Any]:
-    actions = []
+    host_id = _normalize_host_id(host_id)
+    if host_id is not None and not _party_board_action_is_supported(repo_root, host_id):
+        return _party_board_fallback_actions(
+            repo_root,
+            base_dir,
+            discussion_id,
+            agents,
+            round_number=round_number,
+            phase=phase,
+            host_id=host_id,
+        )
     prompts_dir = base_dir / "prompts"
     prompts_dir.mkdir(parents=True, exist_ok=True)
-    for agent in agents:
-        action = _child_action(
+    child_actions = [
+        _child_action(
             base_dir,
             discussion_id,
             agent,
             round_number=round_number,
             phase=phase,
         )
-        actions.append(action)
+        for agent in agents
+    ]
+    document = _project_actions_document(
+        discussion_id,
+        child_actions=child_actions,
+        agent_ids=[agent["agent_id"] for agent in agents],
+        round_number=round_number,
+        phase=phase,
+    )
+    for action in document["next_actions"]:
         _append_action_history(base_dir, "action-issued", action)
-    wait_action = {
-        "action_id": f"r{round_number}-{phase}-wait",
-        "type": "wait_children",
-        "agent_ids": [agent["agent_id"] for agent in agents],
-    }
-    actions.append(wait_action)
-    _append_action_history(base_dir, "action-issued", wait_action)
-    return {"schema_version": 1, "discussion_id": discussion_id, "next_actions": actions}
-
-
+    return document
 def _build_close_actions(
     base_dir: Path,
     agents: list[dict[str, str]],
@@ -427,30 +391,27 @@ def _build_close_actions(
     round_number: int,
     reason: str,
 ) -> list[dict[str, Any]]:
-    actions = []
-    for agent in agents:
-        action = {
-            "action_id": f"r{round_number}-close-{agent['agent_id']}",
-            "type": "close_child",
-            "agent_id": agent["agent_id"],
-            "reason": reason,
-        }
-        actions.append(action)
+    actions = _project_close_actions(
+        agents,
+        round_number=round_number,
+        reason=reason,
+    )
+    for action in actions:
         _append_action_history(base_dir, "action-issued", action)
         _append_audit(
             base_dir,
             "close",
             {
-                "agent_id": agent["agent_id"],
+                "agent_id": action["agent_id"],
                 "round": round_number,
                 "reason": reason,
             },
         )
     return actions
-
-
 def _empty_actions(discussion_id: str) -> dict[str, Any]:
-    return {"schema_version": 1, "discussion_id": discussion_id, "next_actions": []}
+    return _project_empty_actions(discussion_id)
+def _write_actions_json(base_dir: Path, actions: dict[str, Any]) -> None:
+    _write_json(base_dir / "actions.json", validate_actions_document(actions))
 
 
 def _with_terminal_state(data: dict[str, Any], terminal: bool) -> dict[str, Any]:
@@ -458,55 +419,52 @@ def _with_terminal_state(data: dict[str, Any], terminal: bool) -> dict[str, Any]
     return data
 
 
-def _initial_board(discussion_id: str, topic: str, max_rounds: int) -> dict[str, Any]:
-    return {
-        "schema_version": 1,
-        "discussion_id": discussion_id,
-        "topic": topic,
-        "round": {"current": 1, "max": max_rounds, "phase": "publish"},
-        "rounds": [{"round": 1, "posts": [], "responses": [], "moderator_events": []}],
-        "termination": {"reason": None},
-    }
-
-
+def _initial_board(
+    discussion_id: str,
+    topic: str,
+    max_rounds: int,
+    *,
+    host_id: str | None = None,
+) -> dict[str, Any]:
+    return _project_initial_board(
+        discussion_id,
+        topic,
+        max_rounds,
+        host_id=host_id,
+    )
 def _initial_agents_state(discussion_id: str, agents: list[dict[str, str]]) -> dict[str, Any]:
-    return {
-        "schema_version": 1,
-        "discussion_id": discussion_id,
-        "agents": [
-            {
-                "agent_id": agent["agent_id"],
-                "lens": agent["lens"],
-                "status": "pending",
-                "drift_warnings": 0,
-                "host_child_id": None,
-            }
-            for agent in agents
-        ],
-    }
-
-
+    return _project_initial_agents_state(discussion_id, agents)
 def init_discussion(
     repo_root: Path,
     *,
     discussion_id: str,
     topic: str,
     agent_specs: list[str],
+    host_id: str | None = None,
 ) -> dict[str, Any]:
     _validate_identifier(discussion_id, label="discussion_id")
     config = get_party_mode_v2_config(repo_root)
     agents = [_parse_agent_spec(spec) for spec in agent_specs]
     _validate_agents(agents, config)
+    host_id = _normalize_host_id(host_id)
     base_dir = discussion_dir(repo_root, discussion_id)
     with _state_lock(base_dir):
         max_rounds = int(config["max_rounds"])
-        board = _initial_board(discussion_id, topic, max_rounds)
+        board = _initial_board(discussion_id, topic, max_rounds, host_id=host_id)
         agents_state = _initial_agents_state(discussion_id, agents)
-        actions = _build_actions(base_dir, discussion_id, agents, round_number=1, phase="publish")
+        actions = _build_actions(
+            repo_root,
+            base_dir,
+            discussion_id,
+            agents,
+            round_number=1,
+            phase="publish",
+            host_id=host_id,
+        )
         public_round = _build_public_round(board)
-        _write_json(base_dir / "board.json", board)
+        save_board(base_dir, board)
         _write_json(base_dir / "agents.json", agents_state)
-        _write_json(base_dir / "actions.json", actions)
+        _write_actions_json(base_dir, actions)
         _write_json(base_dir / "public_round.json", public_round)
         _append_audit(
             base_dir,
@@ -530,7 +488,7 @@ def view_discussion(
     if agent_id:
         _validate_identifier(agent_id, label="agent_id")
     with _state_lock(base_dir):
-        board = _read_json(base_dir / "board.json")
+        board = load_board(base_dir)
         public_round = _build_public_round(board)
         if agent_id:
             public_round["agent_id"] = agent_id
@@ -545,9 +503,9 @@ def view_discussion(
 
 def monitor_discussion(repo_root: Path, *, discussion_id: str) -> dict[str, Any]:
     base_dir = discussion_dir(repo_root, discussion_id)
-    board = _read_json(base_dir / "board.json")
+    board = load_board(base_dir)
     agents = _read_json(base_dir / "agents.json")
-    actions = _read_json(base_dir / "actions.json")
+    actions = validate_actions_document(_read_json(base_dir / "actions.json"))
     active_agents = [
         agent
         for agent in agents.get("agents", [])
@@ -569,15 +527,7 @@ def monitor_discussion(repo_root: Path, *, discussion_id: str) -> dict[str, Any]
 
 
 def _current_round(board: dict[str, Any]) -> dict[str, Any]:
-    current_round = int(board["round"]["current"])
-    for item in board.get("rounds", []):
-        if int(item.get("round", -1)) == current_round:
-            return item
-    item = {"round": current_round, "posts": [], "responses": [], "moderator_events": []}
-    board.setdefault("rounds", []).append(item)
-    return item
-
-
+    return _project_current_round(board)
 def _active_agent_ids(base_dir: Path) -> list[str]:
     agents = _read_json(base_dir / "agents.json")
     return [
@@ -638,7 +588,7 @@ def _build_post_payload(
 
 
 def _write_runtime_state(base_dir: Path, board: dict[str, Any]) -> None:
-    _write_json(base_dir / "board.json", board)
+    save_board(base_dir, board)
     _write_json(base_dir / "public_round.json", _build_public_round(board))
 
 
@@ -653,7 +603,7 @@ def post_submission(
     base_dir = discussion_dir(repo_root, discussion_id)
     config = get_party_mode_v2_config(repo_root)
     with _state_lock(base_dir):
-        board = _read_json(base_dir / "board.json")
+        board = load_board(base_dir)
         if board["round"]["phase"] != "publish":
             raise ValueError("phase_not_publish")
         if agent_id not in _active_agent_ids(base_dir):
@@ -869,7 +819,7 @@ def respond_submission(
     base_dir = discussion_dir(repo_root, discussion_id)
     config = get_party_mode_v2_config(repo_root)
     with _state_lock(base_dir):
-        board = _read_json(base_dir / "board.json")
+        board = load_board(base_dir)
         if board["round"]["phase"] != "respond":
             raise ValueError("phase_not_respond")
         if agent_id not in _active_agent_ids(base_dir):
@@ -905,23 +855,27 @@ def respond_submission(
 
 
 def _write_actions_for_phase(
+    repo_root: Path,
     base_dir: Path,
     discussion_id: str,
     round_number: int,
     phase: str,
     *,
+    host_id: str | None = None,
     leading_actions: list[dict[str, Any]] | None = None,
 ) -> None:
     actions = _build_actions(
+        repo_root,
         base_dir,
         discussion_id,
         _agent_lenses(base_dir),
         round_number=round_number,
         phase=phase,
+        host_id=host_id,
     )
     if leading_actions:
         actions["next_actions"] = leading_actions + actions["next_actions"]
-    _write_json(base_dir / "actions.json", actions)
+    _write_actions_json(base_dir, actions)
 
 
 def _advance_publish_phase(
@@ -934,21 +888,26 @@ def _advance_publish_phase(
     active_agents: list[str],
     current_round: int,
 ) -> dict[str, Any]:
-    posted_agents = {str(post["agent_id"]) for post in current.get("posts", [])}
-    missing = sorted(set(active_agents) - posted_agents)
-    if missing:
-        raise ValueError(f"publish_incomplete:{','.join(missing)}")
-    board["round"]["phase"] = "respond"
+    transition = _advance_board_state(
+        board,
+        active_agent_ids=active_agents,
+        fresh_context_per_round=True,
+    )
     _write_runtime_state(base_dir, board)
-    _write_actions_for_phase(base_dir, discussion_id, current_round, "respond")
+    _write_actions_for_phase(
+        repo_root,
+        base_dir,
+        discussion_id,
+        transition["next_actions"]["round"],
+        transition["next_actions"]["phase"],
+        host_id=board.get("host_id"),
+    )
     _append_audit(
         base_dir,
         "advance",
-        {"round": current_round, "from": "publish", "to": "respond"},
+        {"round": current_round, "from": transition["from"], "to": transition["to"]},
     )
     return monitor_discussion(repo_root, discussion_id=discussion_id)
-
-
 def _close_discussion(
     repo_root: Path,
     *,
@@ -961,7 +920,7 @@ def _close_discussion(
     board["round"]["phase"] = "closed"
     board["termination"] = {"reason": reason}
     _write_runtime_state(base_dir, board)
-    _write_json(base_dir / "actions.json", _empty_actions(discussion_id))
+    _write_actions_json(base_dir, _empty_actions(discussion_id))
     _append_audit(
         base_dir,
         "advance",
@@ -994,10 +953,12 @@ def _advance_next_round(
     )
     _write_runtime_state(base_dir, board)
     _write_actions_for_phase(
+        repo_root,
         base_dir,
         discussion_id,
         next_round,
         "publish",
+        host_id=board.get("host_id"),
         leading_actions=close_actions,
     )
     _append_audit(
@@ -1018,41 +979,63 @@ def _advance_respond_phase(
     active_agents: list[str],
     current_round: int,
 ) -> dict[str, Any]:
-    responded_agents = {str(response["agent_id"]) for response in current.get("responses", [])}
-    missing = sorted(set(active_agents) - responded_agents)
-    if missing:
-        raise ValueError(f"respond_incomplete:{','.join(missing)}")
-    if not any(bool(response.get("still_disagree")) for response in current.get("responses", [])):
-        return _close_discussion(
-            repo_root,
-            base_dir=base_dir,
-            discussion_id=discussion_id,
-            board=board,
-            current_round=current_round,
-            reason="converged",
+    config = get_party_mode_v2_config(repo_root)
+    transition = _advance_board_state(
+        board,
+        active_agent_ids=active_agents,
+        fresh_context_per_round=bool(config.get("fresh_context_per_round", True)),
+    )
+    if transition["to"] == "closed":
+        _write_runtime_state(base_dir, board)
+        _write_actions_json(base_dir, _empty_actions(discussion_id))
+        _append_audit(
+            base_dir,
+            "advance",
+            {
+                "round": current_round,
+                "from": transition["from"],
+                "to": transition["to"],
+                "reason": transition["reason"],
+            },
         )
-    if current_round >= int(board["round"]["max"]):
-        return _close_discussion(
-            repo_root,
-            base_dir=base_dir,
-            discussion_id=discussion_id,
-            board=board,
-            current_round=current_round,
-            reason="max_rounds_unconverged",
+        return finalize_discussion(repo_root, discussion_id=discussion_id)
+
+    if transition["to"] != "publish":
+        raise ValueError("phase_not_advanceable")
+    close_actions = []
+    close_reason = transition.get("close_children_reason")
+    if close_reason:
+        close_actions = _build_close_actions(
+            base_dir,
+            _agent_lenses(base_dir),
+            round_number=current_round,
+            reason=str(close_reason),
         )
-    return _advance_next_round(
+    _write_runtime_state(base_dir, board)
+    _write_actions_for_phase(
         repo_root,
-        base_dir=base_dir,
-        discussion_id=discussion_id,
-        board=board,
-        current_round=current_round,
+        base_dir,
+        discussion_id,
+        transition["next_actions"]["round"],
+        transition["next_actions"]["phase"],
+        host_id=board.get("host_id"),
+        leading_actions=close_actions,
     )
-
-
+    _append_audit(
+        base_dir,
+        "advance",
+        {
+            "round": current_round,
+            "from": transition["from"],
+            "to": transition["to"],
+            "next_round": transition["next_round"],
+        },
+    )
+    return monitor_discussion(repo_root, discussion_id=discussion_id)
 def advance_discussion(repo_root: Path, *, discussion_id: str) -> dict[str, Any]:
     base_dir = discussion_dir(repo_root, discussion_id)
     with _state_lock(base_dir):
-        board = _read_json(base_dir / "board.json")
+        board = load_board(base_dir)
         current = _current_round(board)
         active_agents = _active_agent_ids(base_dir)
         current_round = int(board["round"]["current"])
@@ -1103,16 +1086,13 @@ def _ensure_finalizable(
     *,
     manual_termination: bool,
 ) -> None:
-    if board["round"]["phase"] == "closed":
-        return
-    if not manual_termination:
-        raise ValueError("finalize_requires_closed_discussion")
-    board["round"]["phase"] = "closed"
-    board["termination"] = {"reason": "manual_terminated"}
-    _write_runtime_state(base_dir, board)
-    _write_json(base_dir / "actions.json", _empty_actions(discussion_id))
-
-
+    changed = _ensure_finalizable_state(
+        board,
+        manual_termination=manual_termination,
+    )
+    if changed:
+        _write_runtime_state(base_dir, board)
+        _write_actions_json(base_dir, _empty_actions(discussion_id))
 def _discussion_posts(board: dict[str, Any]) -> list[dict[str, Any]]:
     return [post for item in board.get("rounds", []) for post in item.get("posts", [])]
 
@@ -1147,8 +1127,75 @@ def _historical_disagreements(
     ]
 
 
+def _round_summary_phase(board: dict[str, Any], round_number: int) -> str:
+    if round_number == int(board["round"]["current"]):
+        return str(board["round"]["phase"])
+    return "completed"
+
+
+def _rounds_summary(board: dict[str, Any]) -> list[dict[str, Any]]:
+    summaries: list[dict[str, Any]] = []
+    for item in board.get("rounds", []):
+        round_number = int(item.get("round", 0))
+        posts = item.get("posts", [])
+        responses = item.get("responses", [])
+        unresolved = [r for r in responses if r.get("still_disagree")]
+        summaries.append(
+            {
+                "round": round_number,
+                "phase": _round_summary_phase(board, round_number),
+                "post_count": len(posts),
+                "response_count": len(responses),
+                "unresolved_count": len(unresolved),
+            }
+        )
+    return summaries
+
+
+def _action_results_summary(base_dir: Path) -> list[dict[str, Any]]:
+    history_path = base_dir / "action_history.jsonl"
+    if not history_path.is_file():
+        return []
+    results: list[dict[str, Any]] = []
+    with history_path.open("r", encoding="utf-8") as handle:
+        for line in handle:
+            if not line.strip():
+                continue
+            entry = json.loads(line)
+            if entry.get("event") != "action-result":
+                continue
+            payload = entry.get("payload", {})
+            summary: dict[str, Any] = {
+                "action_id": payload.get("action_id"),
+                "type": payload.get("type"),
+                "outcome": payload.get("outcome"),
+            }
+            if payload.get("agent_id"):
+                summary["agent_id"] = payload["agent_id"]
+            results.append(summary)
+    return results
+
+
+def _accepted_evidence_summary(responses: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    summaries: list[dict[str, Any]] = []
+    for response in responses:
+        if response.get("decision") != "concede":
+            continue
+        evidence = response.get("accepted_evidence", [])
+        if not evidence:
+            continue
+        summaries.append(
+            {
+                "agent_id": response.get("agent_id"),
+                "target_post_id": response.get("target_post_id"),
+                "accepted_evidence": evidence,
+            }
+        )
+    return summaries
+
 def _build_final_report(
     *,
+    base_dir: Path,
     discussion_id: str,
     board: dict[str, Any],
     posts: list[dict[str, Any]],
@@ -1157,34 +1204,12 @@ def _build_final_report(
     historical_disagreements: list[dict[str, Any]],
     stop_reason: str,
 ) -> dict[str, Any]:
-    current_round = int(board["round"]["current"])
-    current_unresolved = [
-        response for response in current_responses if response.get("still_disagree")
-    ]
-    board_status = {
-        "round": current_round,
-        "phase": board["round"]["phase"],
-        "max_rounds": board["round"]["max"],
-        "termination_reason": stop_reason,
-    }
-    return {
-        "schema_version": 1,
-        "discussion_id": discussion_id,
-        "terminal": True,
-        "stop_reason": stop_reason,
-        "board_status": board_status,
-        "next_actions": [],
-        "pro": _report_pro_posts(posts),
-        "con": _report_con_responses(responses),
-        "changed_positions": _responses_with_delta(responses, "changed"),
-        "maintained_positions": _responses_with_delta(responses, "unchanged"),
-        "revised_positions": _responses_with_decision(responses, "revise"),
-        "current_unresolved_disagreements": current_unresolved,
-        "historical_disagreements": historical_disagreements,
-        "unresolved_disagreements": current_unresolved,
-    }
-
-
+    return _project_final_report(
+        discussion_id=discussion_id,
+        board=board,
+        action_results=_project_action_results_summary(base_dir),
+        stop_reason=stop_reason,
+    )
 def _report_pro_posts(posts: list[dict[str, Any]]) -> list[dict[str, Any]]:
     return [
         {"agent_id": post["agent_id"], "claim": post["claim"], "evidence": post["evidence"]}
@@ -1230,7 +1255,7 @@ def finalize_discussion(
 ) -> dict[str, Any]:
     base_dir = discussion_dir(repo_root, discussion_id)
     with _state_lock(base_dir):
-        board = _read_json(base_dir / "board.json")
+        board = load_board(base_dir)
         _ensure_finalizable(
             base_dir,
             discussion_id,
@@ -1241,6 +1266,7 @@ def finalize_discussion(
         current_round = int(board["round"]["current"])
         stop_reason = board.get("termination", {}).get("reason") or "manual_finalize"
         report = _build_final_report(
+            base_dir=base_dir,
             discussion_id=discussion_id,
             board=board,
             posts=_discussion_posts(board),
@@ -1312,6 +1338,7 @@ def build_parser() -> argparse.ArgumentParser:
     init_parser.add_argument("--discussion-id", required=True)
     init_parser.add_argument("--topic", required=True)
     init_parser.add_argument("--agent", action="append", required=True)
+    init_parser.add_argument("--host-id", default=None)
 
     view_parser = subcommands.add_parser("view")
     view_parser.add_argument("--discussion-id", required=True)
@@ -1358,6 +1385,7 @@ def _command_result(repo_root: Path, args: argparse.Namespace) -> dict[str, Any]
             discussion_id=args.discussion_id,
             topic=args.topic,
             agent_specs=args.agent,
+            host_id=args.host_id,
         )
     if args.command == "view":
         return view_discussion(