cowork-flow 0.0.20 → 0.0.21

package/template/.cowork-flow/scripts/common/active_task.py

@@ -13,7 +13,18 @@ from .paths import DIR_WORKFLOW
 
 DIR_RUNTIME = ".runtime"
 DIR_SESSIONS = "sessions"
+DIR_SUBAGENTS = "subagents"
 FIELD_ACTIVE_TASK_PATH = "active_task_path"
+FIELD_RUNTIME_CONTEXT_ID = "runtime_context_id"
+FIELD_SCOPE = "scope"
+SCOPE_MAIN = "main"
+SCOPE_SUBAGENT = "subagent"
+RUNTIME_CONTEXT_PROMPT_RE = re.compile(
+    r"(?im)^\s*cowork_runtime_context_id\s*:\s*([A-Za-z0-9._-]+)\s*$"
+)
+HOST_CONTEXT_PROMPT_RE = re.compile(
+    r"(?im)^\s*cowork_host_context_key\s*:\s*([A-Za-z0-9._-]+)\s*$"
+)
 
 
 @dataclass(frozen=True)
@@ -38,11 +49,23 @@ def _first_input_value(values: Mapping[str, object] | None, names: tuple[str, ..
     return None
 
 
+def _first_prompt_value(values: Mapping[str, object] | None) -> str | None:
+    return _first_input_value(values, ("prompt", "user_prompt", "userPrompt", "message", "input"))
+
+
 def resolve_context_key(values: Mapping[str, object] | None = None) -> str | None:
     explicit = os.environ.get("COWORK_FLOW_CONTEXT_ID")
     if explicit and explicit.strip():
         return _sanitize(explicit)
 
+    opencode_session = os.environ.get("OPENCODE_SESSION_ID")
+    if opencode_session and opencode_session.strip():
+        return f"opencode_{_sanitize(opencode_session)}"
+
+    claude_session = os.environ.get("CLAUDE_SESSION_ID")
+    if claude_session and claude_session.strip():
+        return f"claude_{_sanitize(claude_session)}"
+
     codex_session = os.environ.get("CODEX_SESSION_ID")
     if codex_session and codex_session.strip():
         return f"codex_{_sanitize(codex_session)}"
@@ -62,6 +85,26 @@ def resolve_context_key(values: Mapping[str, object] | None = None) -> str | Non
     if input_explicit:
         return _sanitize(input_explicit)
 
+    input_opencode_session = _first_input_value(
+        values,
+        (
+            "OPENCODE_SESSION_ID",
+            "opencode_session_id",
+        ),
+    )
+    if input_opencode_session:
+        return f"opencode_{_sanitize(input_opencode_session)}"
+
+    input_claude_session = _first_input_value(
+        values,
+        (
+            "CLAUDE_SESSION_ID",
+            "claude_session_id",
+        ),
+    )
+    if input_claude_session:
+        return f"claude_{_sanitize(input_claude_session)}"
+
     input_session = _first_input_value(
         values,
         (
@@ -92,6 +135,10 @@ def sessions_dir(repo_root: Path) -> Path:
     return repo_root / DIR_WORKFLOW / DIR_RUNTIME / DIR_SESSIONS
 
 
+def subagent_contexts_dir(repo_root: Path) -> Path:
+    return repo_root / DIR_WORKFLOW / DIR_RUNTIME / DIR_SUBAGENTS
+
+
 def _now() -> str:
     return datetime.now(timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z")
 
@@ -100,6 +147,14 @@ def _session_path(repo_root: Path, context_key: str) -> Path:
     return sessions_dir(repo_root) / f"{context_key}.json"
 
 
+def logical_subagent_context_key(runtime_context_id: str) -> str:
+    return f"subagent_{_sanitize(runtime_context_id)}"
+
+
+def runtime_context_path(repo_root: Path, runtime_context_id: str) -> Path:
+    return subagent_contexts_dir(repo_root) / f"{_sanitize(runtime_context_id)}.json"
+
+
 def _read_json(path: Path) -> dict:
     try:
         data = json.loads(path.read_text(encoding="utf-8"))
@@ -113,6 +168,161 @@ def _write_json(path: Path, data: dict) -> None:
     path.write_text(json.dumps(data, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
 
 
+def _platform_from_context_key(context_key: str) -> str:
+    if context_key.startswith("codex_"):
+        return "codex"
+    if context_key.startswith("opencode_"):
+        return "opencode"
+    if context_key.startswith("claude_"):
+        return "claude-code"
+    return "manual"
+
+
+def resolve_runtime_context_id(values: Mapping[str, object] | None = None) -> str | None:
+    explicit = os.environ.get("COWORK_FLOW_RUNTIME_CONTEXT_ID")
+    if explicit and explicit.strip():
+        return _sanitize(explicit)
+
+    input_explicit = _first_input_value(
+        values,
+        (
+            "COWORK_FLOW_RUNTIME_CONTEXT_ID",
+            "cowork_runtime_context_id",
+            "runtime_context_id",
+        ),
+    )
+    if input_explicit:
+        return _sanitize(input_explicit)
+
+    prompt = _first_prompt_value(values)
+    if prompt:
+        match = RUNTIME_CONTEXT_PROMPT_RE.search(prompt)
+        if match:
+            return _sanitize(match.group(1))
+
+    return None
+
+def resolve_host_context_key(values: Mapping[str, object] | None = None) -> str | None:
+    explicit = os.environ.get("COWORK_FLOW_HOST_CONTEXT_KEY")
+    if explicit and explicit.strip():
+        return _sanitize(explicit)
+
+    input_explicit = _first_input_value(
+        values,
+        (
+            "cowork_host_context_key",
+            "host_context_key",
+            "COWORK_FLOW_HOST_CONTEXT_KEY",
+        ),
+    )
+    if input_explicit:
+        return _sanitize(input_explicit)
+
+    prompt = _first_prompt_value(values)
+    if prompt:
+        match = HOST_CONTEXT_PROMPT_RE.search(prompt)
+        if match:
+            return _sanitize(match.group(1))
+
+    return None
+
+
+def read_runtime_context(repo_root: Path, runtime_context_id: str) -> dict:
+    return _read_json(runtime_context_path(repo_root, runtime_context_id))
+
+
+def write_runtime_context(repo_root: Path, runtime_context_id: str, data: dict) -> None:
+    _write_json(runtime_context_path(repo_root, runtime_context_id), data)
+
+
+def write_subagent_logical_session(
+    repo_root: Path,
+    runtime_context_id: str,
+    task_path: str | None,
+    platform: str,
+    status: str = "pending_bind",
+) -> str:
+    context_key = logical_subagent_context_key(runtime_context_id)
+    data: dict[str, object] = {
+        "schema_version": 2,
+        FIELD_SCOPE: SCOPE_SUBAGENT,
+        FIELD_RUNTIME_CONTEXT_ID: runtime_context_id,
+        "platform": platform,
+        "status": status,
+        "last_seen_at": _now(),
+    }
+    if task_path:
+        data[FIELD_ACTIVE_TASK_PATH] = task_path.replace("\\", "/")
+    _write_json(_session_path(repo_root, context_key), data)
+    return context_key
+
+
+def bind_runtime_context(
+    repo_root: Path,
+    runtime_context_id: str,
+    host_context_key: str | None = None,
+    values: Mapping[str, object] | None = None,
+) -> dict | None:
+    context = read_runtime_context(repo_root, runtime_context_id)
+    if not context or context.get(FIELD_SCOPE) != SCOPE_SUBAGENT:
+        return None
+    if context.get("status") == "closed":
+        return None
+
+    resolved_key = (
+        _sanitize(host_context_key)
+        if host_context_key
+        else resolve_host_context_key(values) or resolve_context_key(values)
+    )
+    if not resolved_key:
+        return None
+
+    existing_key = context.get("bound_context_key")
+    if isinstance(existing_key, str) and existing_key.strip() and existing_key != resolved_key:
+        return None
+
+    task_path = context.get("task_dir")
+    session: dict[str, object] = {
+        "schema_version": 2,
+        FIELD_SCOPE: SCOPE_SUBAGENT,
+        FIELD_RUNTIME_CONTEXT_ID: runtime_context_id,
+        "platform": _platform_from_context_key(resolved_key),
+        "status": "bound",
+        "last_seen_at": _now(),
+    }
+    if isinstance(task_path, str) and task_path.strip():
+        session[FIELD_ACTIVE_TASK_PATH] = task_path.strip()
+    _write_json(_session_path(repo_root, resolved_key), session)
+
+    context["status"] = "bound"
+    context["bound_context_key"] = resolved_key
+    if not context.get("bound_at"):
+        context["bound_at"] = _now()
+    context["last_seen_at"] = _now()
+    write_runtime_context(repo_root, runtime_context_id, context)
+    return context
+
+
+def close_runtime_context(repo_root: Path, runtime_context_id: str) -> bool:
+    context = read_runtime_context(repo_root, runtime_context_id)
+    if not context:
+        return False
+
+    bound_context_key = context.get("bound_context_key")
+    for context_key in (bound_context_key, logical_subagent_context_key(runtime_context_id)):
+        if isinstance(context_key, str) and context_key.strip():
+            try:
+                _session_path(repo_root, context_key).unlink()
+            except FileNotFoundError:
+                pass
+
+    context["status"] = "closed"
+    context["closed_at"] = _now()
+    context["last_seen_at"] = _now()
+    write_runtime_context(repo_root, runtime_context_id, context)
+    return True
+
+
 def set_active_task(repo_root: Path, task_path: str) -> ActiveTask | None:
     context_key = resolve_context_key()
     if not context_key:
@@ -125,7 +335,8 @@ def set_active_task(repo_root: Path, task_path: str) -> ActiveTask | None:
         _session_path(repo_root, context_key),
         {
             FIELD_ACTIVE_TASK_PATH: normalized,
-            "platform": "codex" if context_key.startswith("codex_") else "manual",
+            FIELD_SCOPE: SCOPE_MAIN,
+            "platform": _platform_from_context_key(context_key),
             "last_seen_at": _now(),
         },
     )

package/template/.cowork-flow/scripts/common/config.py

@@ -16,7 +16,6 @@ from .paths import DIR_WORKFLOW, get_repo_root
 DEFAULT_SESSION_COMMIT_MESSAGE = "chore: record journal"
 DEFAULT_MAX_JOURNAL_LINES = 2000
 DEFAULT_CODEX_DISPATCH_MODE = "sub-agent"
-DEFAULT_CODEX_POST_ACK_EXECUTION_GRACE_MS = 300000
 
 CONFIG_FILE = "config.yaml"
 
@@ -140,19 +139,3 @@ def get_codex_dispatch_mode(repo_root: Path | None = None) -> str:
     if mode in {"sub-agent", "inline"}:
         return str(mode)
     return DEFAULT_CODEX_DISPATCH_MODE
-
-
-def get_codex_post_ack_execution_grace_ms(repo_root: Path | None = None) -> int:
-    """Get the post-ACK execution grace duration for Codex subagent dispatch."""
-    config = _load_config(repo_root)
-    codex = config.get("codex")
-    if not isinstance(codex, dict):
-        return DEFAULT_CODEX_POST_ACK_EXECUTION_GRACE_MS
-    value = codex.get("post_ack_execution_grace_ms", DEFAULT_CODEX_POST_ACK_EXECUTION_GRACE_MS)
-    try:
-        parsed = int(value)
-    except (ValueError, TypeError):
-        return DEFAULT_CODEX_POST_ACK_EXECUTION_GRACE_MS
-    if parsed <= 0:
-        return DEFAULT_CODEX_POST_ACK_EXECUTION_GRACE_MS
-    return parsed

package/template/.cowork-flow/scripts/common/entry_classifier.py

@@ -0,0 +1,122 @@
+"""Classify cowork-flow hook entries before workflow-state injection."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+class EntryKind:
+    MAIN_SESSION = "MAIN_SESSION"
+    READ_ONLY = "READ_ONLY"
+    COMMAND_ONLY = "COMMAND_ONLY"
+    UNKNOWN = "UNKNOWN"
+
+
+@dataclass(frozen=True)
+class Classification:
+    entry_kind: str
+    confidence: float
+    source: str
+
+
+PROMPT_KEYS = ("prompt", "user_prompt", "userPrompt", "message", "input")
+
+TASK_TERMS = (
+    "task:",
+    "topic:",
+    "focus:",
+    "任务：",
+    "任务:",
+    "主题：",
+    "目标：",
+    "审视",
+    "讨论",
+    "review",
+    "inspect",
+)
+
+READ_ONLY_TERMS = (
+    "explain",
+    "what does",
+    "what is",
+    "why does",
+    "为什么",
+    "原因",
+    "解释",
+    "说明",
+    "read-only",
+    "inspect only",
+    "analysis only",
+    "只看",
+    "只读",
+    "分析一下",
+)
+
+COMMAND_ONLY_TERMS = (
+    "git status",
+    "git diff",
+    "npm run",
+    ".cowork-flow/run",
+    ".cowork-flow\\run.cmd",
+)
+
+MAIN_SESSION_TERMS = (
+    "main session",
+    "main agent",
+    "not a subagent",
+    "not a sub-agent",
+    "run full cowork-flow start",
+    "run full project start",
+    "继续",
+    "实现",
+    "提交",
+    "归档",
+    "修复",
+    "主会话",
+    "主 agent",
+    "主代理",
+    "不是子代理",
+    "不是子任务",
+    "start task",
+    "resume",
+    "implement",
+    "commit",
+    "archive",
+    "fix",
+)
+
+
+def extract_prompt(hook_input: dict) -> str:
+    values: list[str] = []
+    for key in PROMPT_KEYS:
+        value = hook_input.get(key)
+        if isinstance(value, str) and value.strip():
+            values.append(value)
+    return "\n".join(values)
+
+
+def _contains_any(text: str, terms: tuple[str, ...]) -> bool:
+    return any(term in text for term in terms)
+
+
+def classify_entry(hook_input: dict) -> Classification:
+    prompt = extract_prompt(hook_input)
+    if not prompt.strip():
+        return Classification(EntryKind.UNKNOWN, 0.0, "empty_prompt")
+
+    lowered = prompt.lower()
+    has_task = _contains_any(lowered, TASK_TERMS)
+
+    if _contains_any(lowered, READ_ONLY_TERMS) and not _contains_any(lowered, MAIN_SESSION_TERMS):
+        return Classification(EntryKind.READ_ONLY, 0.6, "read_only")
+
+    if _contains_any(lowered, COMMAND_ONLY_TERMS) and not has_task:
+        return Classification(EntryKind.COMMAND_ONLY, 0.6, "command_only")
+
+    if _contains_any(lowered, MAIN_SESSION_TERMS):
+        return Classification(EntryKind.MAIN_SESSION, 0.55, "main_session_heuristic")
+
+    if has_task:
+        return Classification(EntryKind.UNKNOWN, 0.35, "task_prompt_unbound")
+
+    return Classification(EntryKind.UNKNOWN, 0.3, "unclassified")

package/template/.cowork-flow/scripts/common/execution_context.py

@@ -309,17 +309,15 @@ def build_subagent_resume_text(
     forbidden_actions = context_data.get("forbiddenActions")
     status_file = context_data.get("statusFile")
     events_file = context_data.get("eventsFile")
-    dispatch_id = context_data.get("dispatchId")
-    ack_token = context_data.get("ackToken")
-    dispatch_status = context_data.get("dispatchStatus")
+    runtime_context_id = context_data.get("runtimeContextId") or context_data.get("runtime_context_id")
+    runtime_context_status = context_data.get("runtimeContextStatus")
     agent_type = context_data.get("agentType")
     dispatch_reliability = context_data.get("dispatchReliability")
-    expected_ack = context_data.get("expectedAck")
     lines = [
         "========================================",
         "COWORK-FLOW SUBAGENT RESUME",
         "========================================",
-        "Use this only for a delegated subagent's own scoped recovery.",
+        "Use this only for a runtime-context subagent's own scoped recovery.",
         "Do not switch back into the coordinator workflow from this entrypoint.",
         "",
         "## SUBAGENT CONTEXT",
@@ -328,18 +326,14 @@ def build_subagent_resume_text(
         f"Role: {context.role or 'unknown'}",
         f"Goal: {context.goal or 'unknown'}",
     ]
-    if isinstance(dispatch_id, str) and dispatch_id.strip():
-        lines.append(f"Dispatch ID: {dispatch_id}")
-    if isinstance(dispatch_status, str) and dispatch_status.strip():
-        lines.append(f"Dispatch status: {dispatch_status}")
+    if isinstance(runtime_context_id, str) and runtime_context_id.strip():
+        lines.append(f"Runtime context: {runtime_context_id}")
+    if isinstance(runtime_context_status, str) and runtime_context_status.strip():
+        lines.append(f"Runtime context status: {runtime_context_status}")
     if isinstance(agent_type, str) and agent_type.strip():
         lines.append(f"Agent type: {agent_type}")
     if isinstance(dispatch_reliability, str) and dispatch_reliability.strip():
         lines.append(f"Dispatch reliability: {dispatch_reliability}")
-    if isinstance(ack_token, str) and ack_token.strip():
-        lines.append(f"ACK token: {ack_token}")
-    if isinstance(expected_ack, str) and expected_ack.strip():
-        lines.append(f"Expected ACK: {expected_ack}")
     if context.context_file:
         lines.append(f"Context file: {context.context_file}")
     if isinstance(allowed_context, list) and allowed_context:
@@ -379,10 +373,9 @@ def build_subagent_resume_text(
     lines.extend([
         "",
         "## RULES",
-        "- If you have not acknowledged this dispatch, first return only: COWORK_ACK <dispatch_id> <ack_token>.",
-        "- Execute only after the coordinator sends EXECUTE <dispatch_id> for this same dispatch.",
-        "- If a message names a different dispatch_id, report needs_context and do not execute it.",
-        "- Generic worker dispatch is best-effort only; no ACK means the coordinator must close or retry it.",
+        "- Execute only when the bound runtime context exists, is open, and names this agent type.",
+        "- If runtime context is missing, closed, invalid, or mismatched, report needs_context and do not execute it.",
+        "- Generic worker dispatch is advisory only and cannot complete formal Implement or Check.",
         "- Read only prompt-named files and allowed context unless you ask for more context.",
         "- Do not run task start, task finish, task archive, or unscoped resume.",
         "- Stop only with success, needs_context, or blocked status evidence.",