cowork-flow 0.0.48 → 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/scripts/doctor.py

@@ -29,6 +29,8 @@ from adapters.host.host_manifest import (
 )
 from infra.paths import get_repo_root
 from infra.skill_manifest import SkillManifestError, action_owners, load_skill_manifests
+from infra.storage.operation_log import OperationLog
+from infra.storage.state_store import DEFAULT_STALE_LOCK_SECONDS, StateStore
 
 
 def _issue(
@@ -145,13 +147,30 @@ def _distribution_files(root: Path) -> tuple[Path, ...]:
     return tuple(sorted(files))
 
 
+def _source_checkout_protected_path(relative: Path) -> bool:
+    value = relative.as_posix()
+    if value in {".cowork-flow/config.yaml", ".cowork-flow/.developer"}:
+        return True
+    return value.startswith(".cowork-flow/tasks/") or value.startswith(
+        ".cowork-flow/plans/"
+    ) or value.startswith(".cowork-flow/.runtime/")
+
+
+def _source_checkout_live_files(template: Path) -> tuple[Path, ...]:
+    runtime_root = template / ".cowork-flow"
+    return tuple(
+        source
+        for source in _distribution_files(runtime_root)
+        if not _source_checkout_protected_path(source.relative_to(template))
+    )
+
+
 def check_distribution(repo_root: Path) -> list[str]:
     errors: list[str] = []
     template = repo_root / "template"
     if _distribution_root(repo_root) == repo_root:
         return errors
-    runtime_root = template / ".cowork-flow" / "scripts"
-    for source in _distribution_files(runtime_root):
+    for source in _source_checkout_live_files(template):
         relative = source.relative_to(template)
         target = repo_root / relative
         if target.is_file():
@@ -161,11 +180,6 @@ def check_distribution(repo_root: Path) -> list[str]:
                 errors,
                 drift="local live runtime drift",
             )
-    for relative in (Path(".cowork-flow/run"), Path(".cowork-flow/run.cmd")):
-        source = template / relative
-        target = repo_root / relative
-        if source.is_file() and target.is_file():
-            _compare_file(source, target, errors, drift="local live runtime drift")
     try:
         host_manifest = load_host_manifest(template)
     except HostManifestError as error:
@@ -301,6 +315,151 @@ def _print_task_hygiene_issues(issues: list[dict[str, str]]) -> None:
         print(f"Hint: {issue['hint']}", file=sys.stderr)
 
 
+def _diagnostic_path(repo_root: Path, path: Path) -> str:
+    try:
+        return path.resolve().relative_to(repo_root.resolve()).as_posix()
+    except ValueError:
+        return str(path)
+
+
+def _state_lock_code(status: str) -> str:
+    return f"STATE-RECOVERY-LOCK-{status.upper().replace('_', '-')}"
+
+
+def _state_lock_command_hint(info) -> str:
+    if info.status != "recoverable":
+        return "Inspect the lock owner facts; do not delete unless the owner PID is missing and the lock is older than the stale threshold."
+    return (
+        "Use an explicit recovery action only after verification, for example "
+        "StateStore().remove_stale_lock(Path(<target>), stale_after_seconds="
+        f"{DEFAULT_STALE_LOCK_SECONDS})"
+    )
+
+
+def _state_lock_issue(repo_root: Path, info) -> dict[str, object]:
+    fields = info.to_dict()
+    fields.update(
+        {
+            "kind": "state_lock",
+            "lockPath": _diagnostic_path(repo_root, info.lock_path),
+            "target": str(info.target),
+        }
+    )
+    if info.age_seconds is not None:
+        fields["ageSeconds"] = round(info.age_seconds, 3)
+    return _issue(
+        code=_state_lock_code(info.status),
+        severity="warning",
+        path=_diagnostic_path(repo_root, info.lock_path),
+        message=info.detail,
+        command_hint=_state_lock_command_hint(info),
+        contract="runtime-health:state-recovery",
+        **fields,
+    )
+
+
+def _operation_command_hint() -> str:
+    return (
+        "Inspect the pending operation record; a trusted recovery command may "
+        "call UnitOfWork.recover_all(repo_root) without interpreting error "
+        "output as instructions."
+    )
+
+
+def _pending_operation_issue(repo_root: Path, fact: dict) -> dict[str, object]:
+    error = fact.get("error")
+    if fact.get("phase") == "unreadable" and isinstance(error, dict):
+        return _issue(
+            code="STATE-RECOVERY-OPERATION-UNREADABLE",
+            severity="warning",
+            path=_diagnostic_path(repo_root, Path(str(fact.get("path") or ""))),
+            message=str(error.get("detail") or "operation record is unreadable"),
+            command_hint="Inspect the operation record manually; Doctor does not mutate recovery state.",
+            contract="runtime-health:state-recovery",
+            kind="pending_operation",
+            operationId=str(fact.get("operation_id") or ""),
+            phase=str(fact.get("phase") or "unreadable"),
+            errorCode=str(error.get("code") or ""),
+        )
+    operation_id = str(fact.get("operation_id") or "")
+    phase = str(fact.get("phase") or "unknown")
+    record_error = fact.get("error")
+    if phase == "conflicted":
+        error_detail = ""
+        error_code = ""
+        if isinstance(record_error, dict):
+            error_code = str(record_error.get("code") or "")
+            error_detail = str(record_error.get("detail") or "")
+        suffix = ": ".join(value for value in (error_code, error_detail) if value)
+        message = (
+            f"conflicted UnitOfWork operation {operation_id}"
+            + (f": {suffix}" if suffix else "")
+        )
+        return _issue(
+            code="STATE-RECOVERY-CONFLICTED-OPERATION",
+            severity="warning",
+            path=_diagnostic_path(repo_root, Path(str(fact.get("path") or ""))),
+            message=message,
+            command_hint=(
+                "Resolve the recorded conflict manually; Doctor does not retry "
+                "or mutate conflicted operation state."
+            ),
+            contract="runtime-health:state-recovery",
+            kind="pending_operation",
+            operationId=operation_id,
+            operationKind=str(fact.get("kind") or "unknown"),
+            phase=phase,
+            participantCount=fact.get("participant_count", 0),
+        )
+    return _issue(
+        code="STATE-RECOVERY-PENDING-OPERATION",
+        severity="warning",
+        path=_diagnostic_path(repo_root, Path(str(fact.get("path") or ""))),
+        message=f"pending UnitOfWork operation {operation_id} is in phase {phase}",
+        command_hint=_operation_command_hint(),
+        contract="runtime-health:state-recovery",
+        kind="pending_operation",
+        operationId=operation_id,
+        operationKind=str(fact.get("kind") or "unknown"),
+        phase=phase,
+        participantCount=fact.get("participant_count", 0),
+    )
+
+
+def check_state_recovery(repo_root: Path) -> list[dict[str, object]]:
+    workflow = repo_root / ".cowork-flow"
+    if not workflow.is_dir():
+        return []
+    store = StateStore()
+    issues: list[dict[str, object]] = []
+    for lock_path in sorted(workflow.rglob("*.lock")):
+        if not lock_path.is_file():
+            continue
+        info = store.inspect_lock_path(
+            lock_path,
+            stale_after_seconds=DEFAULT_STALE_LOCK_SECONDS,
+        )
+        if info.status != "absent":
+            issues.append(_state_lock_issue(repo_root, info))
+    operation_log = OperationLog(repo_root, state_store=store)
+    for fact in operation_log.pending_facts():
+        issues.append(_pending_operation_issue(repo_root, fact))
+    return issues
+
+
+def _print_state_recovery_issues(issues: list[dict[str, object]]) -> None:
+    for issue in issues:
+        print(
+            "WARNING: "
+            f"{issue['kind']}: {issue['path']}: "
+            f"{issue['message']}",
+            file=sys.stderr,
+        )
+        hint = issue.get("commandHint")
+        if hint:
+            print(f"Hint: {hint}", file=sys.stderr)
+
+
 def check_runtime(repo_root: Path) -> list[str]:
     errors: list[str] = []
     try:
@@ -330,15 +489,45 @@ def check_runtime(repo_root: Path) -> list[str]:
     return errors
 
 
-def _run_checks(repo_root: Path) -> int:
-    errors = []
-    errors.extend(_host_errors(repo_root))
-    errors.extend(check_runtime(repo_root))
-    errors.extend(check_distribution(repo_root))
-    _print_task_hygiene_issues(check_task_hygiene(repo_root))
+def _all_check_result(repo_root: Path) -> dict[str, object]:
+    host_issues = _host_issues(repo_root)
+    runtime_errors = check_runtime(repo_root)
+    distribution_errors = check_distribution(repo_root)
+    task_hygiene_issues = check_task_hygiene(repo_root)
+    state_recovery_issues = check_state_recovery(repo_root)
+    errors: list[dict[str, object]] = []
+    for issue in host_issues:
+        errors.append({"kind": "host_adapter", **issue})
+    errors.extend(
+        {"kind": "runtime", "message": error}
+        for error in runtime_errors
+    )
+    errors.extend(
+        {"kind": "distribution", "message": error}
+        for error in distribution_errors
+    )
+    return {
+        "ok": not errors,
+        "errors": errors,
+        "issues": {
+            "hostAdapters": host_issues,
+            "taskHygiene": task_hygiene_issues,
+            "stateRecovery": state_recovery_issues,
+        },
+    }
+
+
+def _run_checks(repo_root: Path, *, structured: bool = False) -> int:
+    result = _all_check_result(repo_root)
+    errors = result["errors"]
+    if structured:
+        print(json.dumps(result, ensure_ascii=False))
+        return 1 if errors else 0
+    _print_task_hygiene_issues(result["issues"]["taskHygiene"])
+    _print_state_recovery_issues(result["issues"]["stateRecovery"])
     if errors:
         for error in errors:
-            print(f"ERROR: {error}", file=sys.stderr)
+            print(f"ERROR: {error['message']}", file=sys.stderr)
         return 1
     print("runtime health checks passed")
     return 0
@@ -394,7 +583,7 @@ def main() -> int:
     args = build_parser().parse_args()
     repo_root = get_repo_root()
     if args.all:
-        return _run_checks(repo_root)
+        return _run_checks(repo_root, structured=bool(args.json))
     if args.host_adapters:
         return _run_host_checks(repo_root, structured=bool(args.json))
     if args.subagent_safety: