cowork-flow 0.0.22 → 0.0.24

package/README.md

@@ -55,7 +55,9 @@ cowork-flow 是一个用于新项目初始化协作流程的模板仓库。它
 项目级协作入口，包含编码前思考、简单优先、外科手术式改动、验证优先等基础原则。接入项目后，应把项目名称、技术栈、运行命令、测试命令和提交策略补齐。
 
 `template/.agents/skills/`
-本地技能入口，覆盖 start、before-dev、brainstorming、writing-plans、check、finish-work、continue、meta、python-design、update-spec 和 break-loop 等协作动作。这里的 skill 应保持通用，不承载某个业务项目的一次性细节。
+本地技能入口，覆盖 start、before-dev、brainstorming、party-mode、writing-plans、check、finish-work、continue、meta、python-design、update-spec 和 break-loop 等协作动作。这里的 skill 应保持通用，不承载某个业务项目的一次性细节。
+
+`party-mode` 是用户手动调用的 advisory roundtable。它通过当前 Host Adapter 协调真实子代理讨论，而不是模拟人设；默认 `max_agents=3`、`max_rounds=3`，配置优先级为本次调用、task/change、本地配置、skill 默认值。Party Mode 只产出建议、证据、分歧和验收信号，不能推进任务状态，也不能替代 `cowork-implement` 或 `cowork-check`。
 
 `template/.codex/agents/`
 固定角色 agent 定义，包含 `cowork-research`、`cowork-implement` 和 `cowork-check`，以及对 Codex 默认 `worker`、`default`、`explorer` 的项目级防漂移约束。主会话负责计划与收口，并通过 host adapter 派发固定 agent；正式派发必须先创建 runtime context，再把 `cowork_runtime_context_id` 和 `cowork_host_context_key` 传给子代理。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cowork-flow",
-  "version": "0.0.22",
+  "version": "0.0.24",
   "description": "CLI for installing and maintaining cowork-flow collaboration templates.",
   "type": "module",
   "bin": {

package/template/.agents/skills/party-mode/SKILL.md

@@ -0,0 +1,120 @@
+---
+name: party-mode
+description: Use when the user manually requests Party Mode or a real multi-agent roundtable for advisory discussion, option review, risk review, or decision convergence.
+---
+
+# Party Mode
+
+Use this skill as a manual advisory roundtable. Coordinate true child agents, not simulated personas, through the current Host Adapter.
+
+## Boundaries
+
+- Party Mode is advisory only.
+- It cannot mutate task status, start/review/complete/archive tasks, add sessions, commit, push, or satisfy formal workflow gates.
+- It cannot satisfy formal Implement or Check completion. Use `cowork-implement` and `cowork-check` for formal phases.
+- Discussion children are leaf executors. They do not dispatch, wait for, list, or close other agents.
+- Generic `worker`, `default`, or `explorer` agents may provide advisory views, but their output never proves implementation or checking done.
+
+## Defaults And Config
+
+Built-in defaults:
+
+- `max_agents=3`
+- `max_rounds=3`
+
+These defaults are configurable values, not hard-coded constants. Effective config order:
+
+```text
+call arguments > task/change config > `.cowork-flow/config.yaml` > skill defaults
+```
+
+Configurable fields:
+
+- `max_agents`
+- `max_rounds`
+- agent roster or review lenses
+- report enabled
+- report path
+- whether round 2 or round 3 is allowed
+
+Safety gates:
+
+- continue conditions can be tightened but not removed
+- stop conditions can be tightened but not removed
+- schema core fields can be extended but not removed
+- exceeding effective limits requires explicit user approval
+
+## Round Model
+
+1. Frame the question, decision needed, scope, and evidence packet.
+2. Round 1 uses fresh child contexts. Send each child the same packet and one lens. Child agents cannot see each other.
+3. Synthesize only evidence-backed positions, disagreements, rejected options, and acceptance signals.
+4. Continue only when a continue condition is met. Send narrow follow-up prompts to the smallest useful set of children.
+5. Stop when any stop condition is met. Close all live children through the Host Adapter close primitive.
+
+Round intent:
+
+- Opening round: independent first judgments.
+- Challenge rounds: rebuttal, risk drilldown, or evidence repair on specific disagreements.
+- Convergence rounds: decision check only. Verify, narrow, or choose. Do not open new directions.
+
+Default mapping:
+
+- Round 1 = Opening.
+- Round 2 = Challenge.
+- Round 3+ = Convergence.
+
+Only the user can restart exploration after convergence begins.
+
+## Continue Conditions
+
+Run another round only if at least one condition holds:
+
+- A disagreement could change the recommended decision.
+- A high risk lacks enough evidence.
+- Acceptance criteria are still not testable.
+- A child found new file, command, rule, or user-scenario evidence.
+- The coordinator cannot write one recommended direction.
+
+## Stop Conditions
+
+Stop when any condition holds:
+
+- Recommendation, rejected options, and measurable acceptance criteria are clear.
+- Remaining issue is user value preference, not missing evidence.
+- A full round adds no evidence and does not narrow scope.
+- Effective `max_rounds` is reached.
+- Output fails schema, and one repair prompt does not fix it.
+
+## Child Output Schema
+
+Each child must return these core fields. Extra fields are allowed only after them.
+
+```text
+position:
+evidence:
+risk:
+tradeoff:
+rejected_option:
+acceptance_signal:
+what_would_change_my_mind:
+```
+
+Reject unsupported opinion. Evidence should name files, commands, rules, observed behavior, user scenarios, or concrete assumptions.
+
+## Coordinator Output Schema
+
+Final synthesis must return these core fields. Extra fields are allowed only after them.
+
+```text
+consensus:
+disagreements:
+evidence:
+decision:
+rejected_options:
+acceptance_criteria:
+open_questions:
+stop_reason:
+```
+
+Keep the final decision traceable to child evidence. Do not count votes as validation.

package/template/.claude/skills/party-mode/SKILL.md

@@ -0,0 +1,120 @@
+---
+name: party-mode
+description: Use when the user manually requests Party Mode or a real multi-agent roundtable for advisory discussion, option review, risk review, or decision convergence.
+---
+
+# Party Mode
+
+Use this skill as a manual advisory roundtable. Coordinate true child agents, not simulated personas, through the current Host Adapter.
+
+## Boundaries
+
+- Party Mode is advisory only.
+- It cannot mutate task status, start/review/complete/archive tasks, add sessions, commit, push, or satisfy formal workflow gates.
+- It cannot satisfy formal Implement or Check completion. Use `cowork-implement` and `cowork-check` for formal phases.
+- Discussion children are leaf executors. They do not dispatch, wait for, list, or close other agents.
+- Generic `worker`, `default`, or `explorer` agents may provide advisory views, but their output never proves implementation or checking done.
+
+## Defaults And Config
+
+Built-in defaults:
+
+- `max_agents=3`
+- `max_rounds=3`
+
+These defaults are configurable values, not hard-coded constants. Effective config order:
+
+```text
+call arguments > task/change config > `.cowork-flow/config.yaml` > skill defaults
+```
+
+Configurable fields:
+
+- `max_agents`
+- `max_rounds`
+- agent roster or review lenses
+- report enabled
+- report path
+- whether round 2 or round 3 is allowed
+
+Safety gates:
+
+- continue conditions can be tightened but not removed
+- stop conditions can be tightened but not removed
+- schema core fields can be extended but not removed
+- exceeding effective limits requires explicit user approval
+
+## Round Model
+
+1. Frame the question, decision needed, scope, and evidence packet.
+2. Round 1 uses fresh child contexts. Send each child the same packet and one lens. Child agents cannot see each other.
+3. Synthesize only evidence-backed positions, disagreements, rejected options, and acceptance signals.
+4. Continue only when a continue condition is met. Send narrow follow-up prompts to the smallest useful set of children.
+5. Stop when any stop condition is met. Close all live children through the Host Adapter close primitive.
+
+Round intent:
+
+- Opening round: independent first judgments.
+- Challenge rounds: rebuttal, risk drilldown, or evidence repair on specific disagreements.
+- Convergence rounds: decision check only. Verify, narrow, or choose. Do not open new directions.
+
+Default mapping:
+
+- Round 1 = Opening.
+- Round 2 = Challenge.
+- Round 3+ = Convergence.
+
+Only the user can restart exploration after convergence begins.
+
+## Continue Conditions
+
+Run another round only if at least one condition holds:
+
+- A disagreement could change the recommended decision.
+- A high risk lacks enough evidence.
+- Acceptance criteria are still not testable.
+- A child found new file, command, rule, or user-scenario evidence.
+- The coordinator cannot write one recommended direction.
+
+## Stop Conditions
+
+Stop when any condition holds:
+
+- Recommendation, rejected options, and measurable acceptance criteria are clear.
+- Remaining issue is user value preference, not missing evidence.
+- A full round adds no evidence and does not narrow scope.
+- Effective `max_rounds` is reached.
+- Output fails schema, and one repair prompt does not fix it.
+
+## Child Output Schema
+
+Each child must return these core fields. Extra fields are allowed only after them.
+
+```text
+position:
+evidence:
+risk:
+tradeoff:
+rejected_option:
+acceptance_signal:
+what_would_change_my_mind:
+```
+
+Reject unsupported opinion. Evidence should name files, commands, rules, observed behavior, user scenarios, or concrete assumptions.
+
+## Coordinator Output Schema
+
+Final synthesis must return these core fields. Extra fields are allowed only after them.
+
+```text
+consensus:
+disagreements:
+evidence:
+decision:
+rejected_options:
+acceptance_criteria:
+open_questions:
+stop_reason:
+```
+
+Keep the final decision traceable to child evidence. Do not count votes as validation.

package/template/.cowork-flow/.version

@@ -1 +1 @@
-0.0.22
+0.0.24

package/template/.cowork-flow/scripts/change.py

@@ -9,6 +9,7 @@ import re
 import sys
 from datetime import datetime
 from pathlib import Path
+from typing import Iterable
 
 from common.archive_utils import archive_directory_resumable
 from common.paths import (
@@ -161,6 +162,63 @@ def _normalize_archive_metadata(repo_root: Path, change_dir: Path) -> None:
         _write_metadata(change_dir, metadata)
 
 
+def _same_path(left: Path, right: Path) -> bool:
+    try:
+        return left.resolve() == right.resolve()
+    except OSError:
+        return left.absolute() == right.absolute()
+
+
+def _task_link_matches(repo_root: Path, value: object, task_paths: Iterable[Path]) -> bool:
+    resolved = _resolve_link(repo_root, "tasks", value)
+    if resolved is None:
+        return False
+    return any(_same_path(resolved, task_path) for task_path in task_paths)
+
+
+def linked_active_changes_for_task(repo_root: Path, task_paths: Iterable[Path]) -> list[str]:
+    """Return active change slugs whose metadata points at one of the task paths."""
+    changes_dir = _changes_dir(repo_root)
+    if not changes_dir.is_dir():
+        return []
+
+    paths = tuple(task_paths)
+    slugs: list[str] = []
+    for change_dir in sorted(changes_dir.iterdir()):
+        if not change_dir.is_dir() or change_dir.name == DIR_ARCHIVE:
+            continue
+        metadata = _read_metadata(change_dir)
+        if metadata.get("status") == "archived":
+            continue
+        if _task_link_matches(repo_root, metadata.get("task"), paths):
+            slugs.append(change_dir.name)
+    return slugs
+
+
+def archive_change_by_slug(repo_root: Path, slug: str) -> Path | None:
+    source = _change_dir(repo_root, slug)
+    if source.is_dir():
+        _normalize_archive_metadata(repo_root, source)
+
+    if not validate_change(repo_root, slug, quiet=True):
+        return None
+
+    month = datetime.now().astimezone().strftime("%Y-%m")
+    destination = _archive_dir(repo_root) / month / slug
+    result = archive_directory_resumable(source, destination)
+    if not result.ok:
+        level = "Warning" if result.partial else "Error"
+        print(f"{level}: {result.message}", file=sys.stderr)
+        return None
+
+    metadata = _read_metadata(destination)
+    metadata["status"] = "archived"
+    metadata["archived_at"] = _now_iso()
+    metadata["task"] = _normalize_task_link(repo_root, metadata.get("task"))
+    _write_metadata(destination, metadata)
+    return destination
+
+
 
 def _display_path(repo_root: Path, path: Path) -> str:
     try:
@@ -272,27 +330,9 @@ def validate_command(args: argparse.Namespace) -> int:
 def archive_change(args: argparse.Namespace) -> int:
     repo_root = get_repo_root()
     slug = args.slug
-    source = _change_dir(repo_root, slug)
-    if source.is_dir():
-        _normalize_archive_metadata(repo_root, source)
-
-    if not validate_change(repo_root, slug, quiet=True):
+    if archive_change_by_slug(repo_root, slug) is None:
         return 1
 
-    month = datetime.now().astimezone().strftime("%Y-%m")
-    destination = _archive_dir(repo_root) / month / slug
-    result = archive_directory_resumable(source, destination)
-    if not result.ok:
-        level = "Warning" if result.partial else "Error"
-        print(f"{level}: {result.message}", file=sys.stderr)
-        return 1
-
-    metadata = _read_metadata(destination)
-    metadata["status"] = "archived"
-    metadata["archived_at"] = _now_iso()
-    metadata["task"] = _normalize_task_link(repo_root, metadata.get("task"))
-    _write_metadata(destination, metadata)
-
     print(f"archived {slug}")
     return 0
 

package/template/.cowork-flow/scripts/task.py

@@ -14,7 +14,7 @@ Usage:
     ./.cowork-flow/run task complete [dir]              # Mark task completed
     ./.cowork-flow/run task current                     # Show active session task
     ./.cowork-flow/run task finish                      # Clear active session task
-    ./.cowork-flow/run task archive <task-name>         # Archive completed task
+    ./.cowork-flow/run task archive <task-name>         # Archive completed task and linked changes
     ./.cowork-flow/run task list                        # List active tasks
     ./.cowork-flow/run task list-archive [month]        # List archived tasks
     ./.cowork-flow/run task add-subtask <parent-dir> <child-dir>     # Link child to parent
@@ -47,6 +47,7 @@ from common.active_task import (
 from common.paths import (
     DIR_WORKFLOW,
     DIR_AGENTS,
+    DIR_CHANGES,
     DIR_TASKS,
     DIR_SPEC,
     DIR_ARCHIVE,
@@ -1120,6 +1121,40 @@ def _print_blockers(blockers: list[str]) -> None:
         print(f"  - {blocker}")
 
 
+def _linked_active_changes_for_task(repo_root: Path, task_dir: Path) -> list[str]:
+    from change import linked_active_changes_for_task
+
+    return linked_active_changes_for_task(repo_root, (task_dir,))
+
+
+def _linked_changes_ready_for_archive(repo_root: Path, slugs: list[str]) -> bool:
+    from change import validate_change
+
+    ready = True
+    for slug in slugs:
+        if not validate_change(repo_root, slug, quiet=True):
+            print(
+                colored(f"Error: Linked change is not ready to archive: {slug}", Colors.RED),
+                file=sys.stderr,
+            )
+            ready = False
+    return ready
+
+
+def _archive_linked_changes(repo_root: Path, slugs: list[str]) -> bool:
+    from change import archive_change_by_slug
+
+    for slug in slugs:
+        if archive_change_by_slug(repo_root, slug) is None:
+            print(
+                colored(f"Error: Failed to archive linked change: {slug}", Colors.RED),
+                file=sys.stderr,
+            )
+            return False
+        print(colored(f"Archived linked change: {slug}", Colors.GREEN), file=sys.stderr)
+    return True
+
+
 def cmd_next(args: argparse.Namespace) -> int:
     """Print the next safe workflow action without mutating state."""
     repo_root = get_repo_root()
@@ -1216,7 +1251,10 @@ def cmd_next(args: argparse.Namespace) -> int:
     if status in DONE_STATUSES:
         print("Next action: finalize, commit, archive, and record session")
         print("Command: git status --short")
+        linked_changes = _linked_active_changes_for_task(repo_root, task_dir)
         print(f"Then: ./.cowork-flow/run task archive {Path(task_path).name}")
+        for slug in linked_changes:
+            print(f"Then: ./.cowork-flow/run change archive {slug} (handled by task archive)")
         _print_blockers(blockers)
         return 0
 
@@ -1231,7 +1269,7 @@ def cmd_next(args: argparse.Namespace) -> int:
 # =============================================================================
 
 def cmd_archive(args: argparse.Namespace) -> int:
-    """Archive completed task."""
+    """Archive completed task and linked changes."""
     repo_root = get_repo_root()
     task_name = args.name
 
@@ -1258,6 +1296,10 @@ def cmd_archive(args: argparse.Namespace) -> int:
     if task_json_path.is_file():
         task_data = _read_json_file(task_json_path)
 
+    linked_changes = _linked_active_changes_for_task(repo_root, task_dir)
+    if linked_changes and not _linked_changes_ready_for_archive(repo_root, linked_changes):
+        return 1
+
     # Archive
     result = archive_task_complete(task_dir, repo_root)
     if "archived_to" not in result:
@@ -1284,6 +1326,9 @@ def cmd_archive(args: argparse.Namespace) -> int:
     year_month = archive_dest.parent.name
     print(colored(f"Archived: {dir_name} -> archive/{year_month}/", Colors.GREEN), file=sys.stderr)
 
+    if linked_changes and not _archive_linked_changes(repo_root, linked_changes):
+        return 1
+
     # Auto-commit only when explicitly requested.
     if getattr(args, "commit", False) and not getattr(args, "no_commit", False):
         _auto_commit_archive(dir_name, repo_root)
@@ -1297,13 +1342,19 @@ def cmd_archive(args: argparse.Namespace) -> int:
 
 
 def _auto_commit_archive(task_name: str, repo_root: Path) -> None:
-    """Stage .cowork-flow/tasks/ changes and commit after archive."""
+    """Stage task/change archive changes and commit after archive."""
     tasks_rel = f"{DIR_WORKFLOW}/{DIR_TASKS}"
-    _run_git_command(["add", "-A", tasks_rel], cwd=repo_root)
+    changes_rel = f"{DIR_WORKFLOW}/{DIR_CHANGES}"
+    archive_rels = [
+        rel
+        for rel in (tasks_rel, changes_rel)
+        if (repo_root / rel).exists()
+    ]
+    _run_git_command(["add", "-A", *archive_rels], cwd=repo_root)
 
     # Check if there are staged changes
     rc, _, _ = _run_git_command(
-        ["diff", "--cached", "--quiet", "--", tasks_rel], cwd=repo_root
+        ["diff", "--cached", "--quiet", "--", *archive_rels], cwd=repo_root
     )
     if rc == 0:
         print("[OK] No task changes to commit.", file=sys.stderr)
@@ -1564,7 +1615,7 @@ Usage:
   ./.cowork-flow/run task complete [dir]                     Mark task completed
   ./.cowork-flow/run task finish                             Clear active session task
   ./.cowork-flow/run task next [dir]                         Show next safe workflow action
-  ./.cowork-flow/run task archive <task-name>                Archive completed task
+  ./.cowork-flow/run task archive <task-name>                Archive completed task and linked changes
   ./.cowork-flow/run task add-subtask <parent> <child>       Link child task to parent
   ./.cowork-flow/run task remove-subtask <parent> <child>    Unlink child from parent
   ./.cowork-flow/run task list [--mine] [--status <status>]  List tasks

package/template/.cowork-flow/spec/subagent-dispatch.md

@@ -12,6 +12,12 @@ classification or a prompt handshake.
 - Generic `worker`, `default`, or `explorer` dispatch is advisory only and
   cannot satisfy formal Implement or Check completion.
 
+## Advisory Party Mode
+
+Party Mode discussion children are advisory leaf executors. They use fresh child contexts for evidence gathering, disagreement surfacing, risk review, and acceptance-signal review. They cannot mutate task status, write code, archive, commit, or coordinate other agents. Their output cannot satisfy formal Implement or Check completion.
+
+The `party-mode` skill owns round limits, continuation gates, stop gates, and output schemas. This document remains the formal `cowork-*` dispatch protocol source.
+
 ## Runtime Context
 
 Before spawning a formal child, the main session creates:

package/template/.cowork-flow/workflow.md

@@ -92,27 +92,33 @@ changes -> brainstorming -> read spec -> plan -> tasks -> implement -> check ->
 - 固定 `cowork-*` 代理是叶子执行者；不得再派发、等待、列出或取消其他代理。
 - 通用 `worker`、`default` 或 `explorer` 只能作为 advisory work，不能满足正式实现或检查完成条件。
 
-## 3.2 并行会话
+## 3.2 手动 Party Mode
+
+Party Mode 是用户手动触发的 advisory roundtable。主会话可通过当前宿主适配器创建 fresh child contexts，收集真实讨论子代理的证据、分歧、风险和可测验收信号，再由主会话综合结论。
+
+Party Mode 不能推进任务状态，不能满足正式实现或检查完成条件，也不能替代 `cowork-implement` 或 `cowork-check`。轮次上限、继续/停止条件、输出 schema 和可配置默认值由 party-mode skill 定义；正式子代理协议仍以 `.cowork-flow/spec/subagent-dispatch.md` 为准。
+
+## 3.3 并行会话
 
 并行执行采用干净隔离的并行会话模型。并行只是执行策略，不改变固定代理叶子边界。
 
-### 3.2.1 并行决策
+### 3.3.1 并行决策
 
 - 用户无需在需求输入时声明是否并行；计划阶段由主会话评估并行可行性。
 - 开发计划必须明确执行策略：串行执行，或列出可并行的低冲突切片。
 - 同一文件、同一行为链、依赖未合并或验收标准不清的工作不得并行，改为串行。
 
-### 3.2.2 隔离方式
+### 3.3.2 隔离方式
 
 - 多个独立任务优先拆成多个 cowork-flow 会话。
 - 只要存在写入冲突风险，就用独立 `git worktree` 隔离。
 
-### 3.2.3 单任务内切片
+### 3.3.3 单任务内切片
 
 - 单个任务内只允许低冲突切片并行。
 - 每个切片必须写清文件归属、依赖关系、预期产物和验证命令。
 
-### 3.2.4 协调与验收
+### 3.3.4 协调与验收
 
 - 主会话是唯一协调者：派发所有子代理后逐个等待，核对子代理汇报的文件、命令和产物，再用适配器列表/取消原语收口。
 - 多个实现切片合并后必须再执行最终集成验证；不能把各子代理的局部通过当成整体通过。
@@ -214,6 +220,8 @@ L2 任务在 `task start` 前必须通过 readiness gate；同一 blocker 列表
     git add <expected files>
     git commit -m "<message>"
     ```
+   `task archive <task-name>` 会归档 task，并自动归档 `change.yaml.task`
+   指向该 task 的 active change；无法通过 `change validate` 的 change 不会被自动归档。
 
 ## 9. 恢复规则