cowork-flow 0.0.47 → 0.0.49

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

@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Pure Party Mode V2 final report projection helpers."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+
+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", [])]
+
+
+def discussion_responses(board: dict[str, Any]) -> list[dict[str, Any]]:
+    return [
+        response
+        for item in board.get("rounds", [])
+        for response in item.get("responses", [])
+    ]
+
+
+def round_responses(board: dict[str, Any], round_number: int) -> list[dict[str, Any]]:
+    return [
+        response
+        for item in board.get("rounds", [])
+        if int(item.get("round", -1)) == round_number
+        for response in item.get("responses", [])
+    ]
+
+
+def historical_disagreements(board: dict[str, Any], current_round: int) -> list[dict[str, Any]]:
+    return [
+        response
+        for item in board.get("rounds", [])
+        if int(item.get("round", -1)) < current_round
+        for response in item.get("responses", [])
+        if response.get("still_disagree")
+    ]
+
+
+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 = [response for response in responses if response.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 report_pro_posts(posts: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    return [
+        {"agent_id": post["agent_id"], "claim": post["claim"], "evidence": post["evidence"]}
+        for post in posts
+    ]
+
+
+def report_con_responses(responses: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    return [
+        {
+            "agent_id": response["agent_id"],
+            "target_post_id": response["target_post_id"],
+            "reasoning": response["reasoning"],
+        }
+        for response in responses
+        if response.get("decision") == "maintain"
+    ]
+
+
+def responses_with_delta(responses: list[dict[str, Any]], position_delta: str) -> list[dict[str, Any]]:
+    return [response for response in responses if response.get("position_delta") == position_delta]
+
+
+def responses_with_decision(responses: list[dict[str, Any]], decision: str) -> list[dict[str, Any]]:
+    return [response for response in responses if response.get("decision") == decision]
+
+
+def build_final_report(
+    *,
+    discussion_id: str,
+    board: dict[str, Any],
+    action_results: list[dict[str, Any]],
+    stop_reason: str,
+) -> dict[str, Any]:
+    """Build a final advisory report from board facts without file writes."""
+
+    current_round = int(board["round"]["current"])
+    posts = discussion_posts(board)
+    responses = discussion_responses(board)
+    current_responses = round_responses(board, current_round)
+    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,
+        "rounds_summary": rounds_summary(board),
+        "action_results": list(action_results),
+        "accepted_evidence": accepted_evidence_summary(responses),
+        "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(board, current_round),
+        "unresolved_disagreements": current_unresolved,
+    }

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

@@ -0,0 +1,189 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Pure Party Mode V2 board state transitions and projections."""
+
+from __future__ import annotations
+
+from typing import Any
+
+CONFIDENCE_VALUES = {"low", "medium", "high"}
+
+
+def round_empty_state(items: list[Any], phase: str, *, item_type: str) -> str | None:
+    if items:
+        return None
+    if item_type == "posts":
+        if phase == "publish":
+            return "waiting_for_current_round_posts"
+        if phase == "closed":
+            return "discussion_closed"
+        return "no_current_round_posts"
+    if phase == "publish":
+        return "responses_not_open_yet"
+    if phase == "respond":
+        return "waiting_for_current_round_responses"
+    if phase == "closed":
+        return "discussion_closed"
+    return "no_current_round_responses"
+
+
+def build_public_round(board: dict[str, Any]) -> dict[str, Any]:
+    """Project the public current-round board without file IO."""
+
+    current_round_number = int(board["round"]["current"])
+    current = next(
+        (
+            item
+            for item in board.get("rounds", [])
+            if int(item.get("round", -1)) == current_round_number
+        ),
+        {"round": current_round_number, "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_number,
+        "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,
+    }
+
+
+def initial_board(
+    discussion_id: str,
+    topic: str,
+    max_rounds: int,
+    *,
+    host_id: str | None = None,
+) -> dict[str, Any]:
+    board: dict[str, Any] = {
+        "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},
+    }
+    if host_id is not None:
+        board["host_id"] = host_id
+    return board
+
+
+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
+        ],
+    }
+
+
+def current_round(board: dict[str, Any]) -> dict[str, Any]:
+    current_round_number = int(board["round"]["current"])
+    for item in board.get("rounds", []):
+        if int(item.get("round", -1)) == current_round_number:
+            return item
+    item = {"round": current_round_number, "posts": [], "responses": [], "moderator_events": []}
+    board.setdefault("rounds", []).append(item)
+    return item
+
+
+def advance_board_state(
+    board: dict[str, Any],
+    *,
+    active_agent_ids: list[str],
+    fresh_context_per_round: bool,
+) -> dict[str, Any]:
+    """Advance the Party board in memory and return action/report facts."""
+
+    current = current_round(board)
+    current_round_number = int(board["round"]["current"])
+    phase = board["round"]["phase"]
+    if phase == "publish":
+        posted_agents = {str(post["agent_id"]) for post in current.get("posts", [])}
+        missing = sorted(set(active_agent_ids) - posted_agents)
+        if missing:
+            raise ValueError(f"publish_incomplete:{','.join(missing)}")
+        board["round"]["phase"] = "respond"
+        return {
+            "round": current_round_number,
+            "from": "publish",
+            "to": "respond",
+            "next_actions": {"round": current_round_number, "phase": "respond"},
+        }
+
+    if phase != "respond":
+        raise ValueError("phase_not_advanceable")
+
+    responded_agents = {str(response["agent_id"]) for response in current.get("responses", [])}
+    missing = sorted(set(active_agent_ids) - 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", [])):
+        board["round"]["phase"] = "closed"
+        board["termination"] = {"reason": "converged"}
+        return {"round": current_round_number, "from": "respond", "to": "closed", "reason": "converged"}
+    if current_round_number >= int(board["round"]["max"]):
+        board["round"]["phase"] = "closed"
+        board["termination"] = {"reason": "max_rounds_unconverged"}
+        return {
+            "round": current_round_number,
+            "from": "respond",
+            "to": "closed",
+            "reason": "max_rounds_unconverged",
+        }
+
+    next_round_number = current_round_number + 1
+    board["round"] = {
+        "current": next_round_number,
+        "max": board["round"]["max"],
+        "phase": "publish",
+    }
+    board.setdefault("rounds", []).append(
+        {"round": next_round_number, "posts": [], "responses": [], "moderator_events": []}
+    )
+    transition: dict[str, Any] = {
+        "round": current_round_number,
+        "from": "respond",
+        "to": "publish",
+        "next_round": next_round_number,
+        "next_actions": {"round": next_round_number, "phase": "publish"},
+    }
+    if fresh_context_per_round:
+        transition["close_children_reason"] = "fresh_context_per_round"
+    return transition
+
+
+def ensure_finalizable(board: dict[str, Any], *, manual_termination: bool) -> bool:
+    """Close a board in memory for manual finalization when allowed."""
+
+    if board["round"]["phase"] == "closed":
+        return False
+    if not manual_termination:
+        raise ValueError("finalize_requires_closed_discussion")
+    board["round"]["phase"] = "closed"
+    board["termination"] = {"reason": "manual_terminated"}
+    return True

package/template/skills/runtime-health/SKILL.md

@@ -20,12 +20,24 @@ Run diagnostics through the common runner:
 .cowork-flow/run doctor --task-hygiene --json
 ```
 
+## Support Triage
+
+Use runtime-health when the user reports host asset drift, hook drift, fixed-agent
+binding failures, stale completed tasks, missing task context, or template/source
+checkout health issues. Start with the narrowest doctor command that matches the
+symptom, then broaden to `doctor --all` only when the focused result is
+insufficient.
+
+Runtime-health output is diagnostic evidence. It may provide command hints, but
+it must not replace `task next --json` as the workflow router and must not mutate
+lifecycle state.
+
 ## Boundaries
 
 - Diagnostics may inspect runtime contracts, host assets, hooks, and template files.
 - Installed projects validate only detected host platforms and do not require a source `template/` tree.
-- Source checkouts distinguish tracked source checkout bootstrap files, ignored local live runtime, and the template distribution source.
-- Source checkout health must not force-track the whole `.cowork-flow/` tree; ignored local live runtime files are checked only when present.
+- Source checkouts distinguish ignored local live runtime from the template distribution source.
+- Source checkout health must not force-track `.cowork-flow/` runtime files; ignored local live runtime files are checked only when present.
 - Source checkouts also validate Skill replica parity for detected installed host targets.
 - stale task hygiene reports completed-unarchived tasks, active-unbound tasks, and missing task context with command hints only.
 - Diagnostics must not mutate task lifecycle state.