cowork-flow 0.0.37 → 0.0.39

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

@@ -228,13 +228,104 @@ def worker_command_block_message(
     return f"Blocked: worker mode cannot run `{command}` for assignment {assignment}. {reason}"
 
 
-def build_worker_resume_text(
-    context: ExecutionContext,
-    repo_root: Path | None = None,
-) -> str:
-    if repo_root is None:
-        repo_root = get_repo_root()
-
+def _append_allowed_context(
+    lines: list[str],
+    allowed_context: object,
+    *,
+    allow_string_items: bool,
+) -> None:
+    if not isinstance(allowed_context, list) or not allowed_context:
+        return
+    lines.extend(["", "## Allowed context"])
+    for item in allowed_context:
+        if allow_string_items and isinstance(item, str) and item.strip():
+            lines.append(f"- {item.strip()}")
+        elif isinstance(item, dict):
+            _append_file_reason_item(lines, item)
+
+
+def _append_file_reason_item(lines: list[str], item: dict) -> None:
+    file_value = item.get("file")
+    reason = item.get("reason")
+    if isinstance(file_value, str) and file_value.strip():
+        suffix = f" - {reason}" if isinstance(reason, str) and reason.strip() else ""
+        lines.append(f"- {file_value}{suffix}")
+
+
+def _append_string_list_section(
+    lines: list[str],
+    title: str,
+    values: object,
+) -> None:
+    if not isinstance(values, list) or not values:
+        return
+    items = [value.strip() for value in values if isinstance(value, str) and value.strip()]
+    if not items:
+        return
+    lines.extend(["", title])
+    lines.extend(f"- {item}" for item in items)
+
+
+def _append_context_metadata(
+    lines: list[str],
+    context_data: dict[str, object],
+) -> None:
+    metadata_fields = [
+        ("runtimeContextId", "Runtime context"),
+        ("runtimeContextStatus", "Runtime context status"),
+        ("agentType", "Agent type"),
+        ("dispatchReliability", "Dispatch reliability"),
+    ]
+    runtime_context_id = (
+        context_data.get("runtimeContextId")
+        or context_data.get("runtime_context_id")
+    )
+    if isinstance(runtime_context_id, str) and runtime_context_id.strip():
+        lines.append(f"Runtime context: {runtime_context_id}")
+    for key, label in metadata_fields[1:]:
+        value = context_data.get(key)
+        if isinstance(value, str) and value.strip():
+            lines.append(f"{label}: {value}")
+
+
+def _append_status_file(
+    lines: list[str],
+    repo_root: Path,
+    status_file: object,
+) -> None:
+    if not isinstance(status_file, str) or not status_file.strip():
+        return
+    status_path = repo_root / status_file
+    if not status_path.is_file():
+        return
+    try:
+        status = json.loads(status_path.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError):
+        lines.extend(["", "## Current status", f"Status file unreadable: {status_file}"])
+        return
+    lines.extend(["", "## Current status", f"Status: {status.get('status', 'unknown')}"])
+    note = status.get("note")
+    if isinstance(note, str) and note.strip():
+        lines.append(f"Note: {note}")
+
+
+def _append_recent_events(
+    lines: list[str],
+    repo_root: Path,
+    events_file: object,
+) -> None:
+    if not isinstance(events_file, str) or not events_file.strip():
+        return
+    events_path = repo_root / events_file
+    if not events_path.is_file():
+        return
+    events = events_path.read_text(encoding="utf-8").splitlines()[-5:]
+    if events:
+        lines.extend(["", "## Recent events"])
+        lines.extend(f"- {event}" for event in events)
+
+
+def _worker_resume_header(context: ExecutionContext) -> list[str]:
     lines = [
         "========================================",
         "WORKER CONTEXT",
@@ -249,36 +340,28 @@ def build_worker_resume_text(
         lines.append(f"Prompt file: {context.prompt_file}")
     if context.context_file:
         lines.append(f"Context file: {context.context_file}")
-    lines.extend(
-        [
-            "",
-            "## READ FIRST",
-            f"- Read worker brief: {context.prompt_file or '(missing prompt file)'}",
-        ]
+    return lines
+
+
+def _append_worker_read_first(
+    lines: list[str],
+    context: ExecutionContext,
+    repo_root: Path,
+    context_data: dict[str, object],
+) -> None:
+    lines.extend(["", "## READ FIRST", f"- Read worker brief: {context.prompt_file or '(missing prompt file)'}"])
+    _append_allowed_context(
+        lines,
+        context_data.get("allowedContext"),
+        allow_string_items=False,
     )
-    context_data = _load_context_file(context.context_file) if context.context_file else {}
-    allowed_context = context_data.get("allowedContext")
-    if isinstance(allowed_context, list) and allowed_context:
-        lines.extend(["", "## Allowed context"])
-        for item in allowed_context:
-            if not isinstance(item, dict):
-                continue
-            file_value = item.get("file")
-            reason = item.get("reason")
-            if isinstance(file_value, str) and file_value.strip():
-                suffix = f" - {reason}" if isinstance(reason, str) and reason.strip() else ""
-                lines.append(f"- {file_value}{suffix}")
-    if context.task_dir and (repo_root / context.task_dir / "decision-anchor.md").is_file():
-        lines.append(f"- Read task PRD: {context.task_dir}/decision-anchor.md")
+    decision_anchor = repo_root / (context.task_dir or "") / "decision-anchor.md"
+    if context.task_dir and decision_anchor.is_file():
+        lines.append(f"- Read task decision-anchor: {context.task_dir}/decision-anchor.md")
     lines.append("- Follow only the files, steps, and commands named in the worker brief.")
 
-    forbidden_actions = context_data.get("forbiddenActions")
-    if isinstance(forbidden_actions, list) and forbidden_actions:
-        lines.extend(["", "## FORBIDDEN ACTIONS"])
-        for action in forbidden_actions:
-            if isinstance(action, str) and action.strip():
-                lines.append(f"- {action.strip()}")
 
+def _append_worker_rules(lines: list[str], context: ExecutionContext) -> None:
     lines.extend(
         [
             "",
@@ -295,24 +378,31 @@ def build_worker_resume_text(
             "========================================",
         ]
     )
-    return "\n".join(lines)
 
 
-def build_subagent_resume_text(
+def build_worker_resume_text(
     context: ExecutionContext,
     repo_root: Path | None = None,
 ) -> str:
     if repo_root is None:
         repo_root = get_repo_root()
+
+    lines = _worker_resume_header(context)
     context_data = _load_context_file(context.context_file) if context.context_file else {}
-    allowed_context = context_data.get("allowedContext")
-    forbidden_actions = context_data.get("forbiddenActions")
-    status_file = context_data.get("statusFile")
-    events_file = context_data.get("eventsFile")
-    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")
+    _append_worker_read_first(lines, context, repo_root, context_data)
+    _append_string_list_section(
+        lines,
+        "## FORBIDDEN ACTIONS",
+        context_data.get("forbiddenActions"),
+    )
+    _append_worker_rules(lines, context)
+    return "\n".join(lines)
+
+
+def _subagent_resume_header(
+    context: ExecutionContext,
+    context_data: dict[str, object],
+) -> list[str]:
     lines = [
         "========================================",
         "COWORK-FLOW SUBAGENT RESUME",
@@ -326,50 +416,13 @@ def build_subagent_resume_text(
         f"Role: {context.role or 'unknown'}",
         f"Goal: {context.goal or 'unknown'}",
     ]
-    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}")
+    _append_context_metadata(lines, context_data)
     if context.context_file:
         lines.append(f"Context file: {context.context_file}")
-    if isinstance(allowed_context, list) and allowed_context:
-        lines.extend(["", "## Allowed context"])
-        for item in allowed_context:
-            if isinstance(item, str) and item.strip():
-                lines.append(f"- {item.strip()}")
-            elif isinstance(item, dict):
-                file_value = item.get("file")
-                reason = item.get("reason")
-                if isinstance(file_value, str) and file_value.strip():
-                    suffix = f" - {reason}" if isinstance(reason, str) and reason.strip() else ""
-                    lines.append(f"- {file_value}{suffix}")
-    if isinstance(forbidden_actions, list) and forbidden_actions:
-        lines.extend(["", "## Forbidden actions"])
-        for action in forbidden_actions:
-            if isinstance(action, str) and action.strip():
-                lines.append(f"- {action.strip()}")
-    if isinstance(status_file, str) and status_file.strip():
-        status_path = repo_root / status_file
-        if status_path.is_file():
-            try:
-                status = json.loads(status_path.read_text(encoding="utf-8"))
-                lines.extend(["", "## Current status", f"Status: {status.get('status', 'unknown')}"])
-                note = status.get("note")
-                if isinstance(note, str) and note.strip():
-                    lines.append(f"Note: {note}")
-            except (json.JSONDecodeError, OSError):
-                lines.extend(["", "## Current status", f"Status file unreadable: {status_file}"])
-    if isinstance(events_file, str) and events_file.strip():
-        events_path = repo_root / events_file
-        if events_path.is_file():
-            events = events_path.read_text(encoding="utf-8").splitlines()[-5:]
-            if events:
-                lines.extend(["", "## Recent events"])
-                lines.extend(f"- {event}" for event in events)
+    return lines
+
+
+def _append_subagent_rules(lines: list[str]) -> None:
     lines.extend([
         "",
         "## RULES",
@@ -382,4 +435,27 @@ def build_subagent_resume_text(
         "",
         "========================================",
     ])
+
+
+def build_subagent_resume_text(
+    context: ExecutionContext,
+    repo_root: Path | None = None,
+) -> str:
+    if repo_root is None:
+        repo_root = get_repo_root()
+    context_data = _load_context_file(context.context_file) if context.context_file else {}
+    lines = _subagent_resume_header(context, context_data)
+    _append_allowed_context(
+        lines,
+        context_data.get("allowedContext"),
+        allow_string_items=True,
+    )
+    _append_string_list_section(
+        lines,
+        "## Forbidden actions",
+        context_data.get("forbiddenActions"),
+    )
+    _append_status_file(lines, repo_root, context_data.get("statusFile"))
+    _append_recent_events(lines, repo_root, context_data.get("eventsFile"))
+    _append_subagent_rules(lines)
     return "\n".join(lines)

package/template/.cowork-flow/scripts/common/core/host_manifest.py

@@ -0,0 +1,393 @@
+#!/usr/bin/env python3
+"""Host Asset Manifest loading and semantic validation."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+try:
+    import tomllib
+except ModuleNotFoundError:  # pragma: no cover - Python < 3.11
+    tomllib = None  # type: ignore[assignment]
+
+
+MANIFEST_PATH = Path(".cowork-flow/spec/runtime/host-assets.json")
+SCHEMA_PATH = Path(".cowork-flow/spec/schemas/host-assets.schema.json")
+
+
+class HostManifestError(RuntimeError):
+    """Raised when the Host Asset Manifest is unavailable or invalid."""
+
+
+@dataclass(frozen=True)
+class CommandTarget:
+    config: str
+    format: str
+    target: str
+
+
+@dataclass(frozen=True)
+class HostPlatform:
+    id: str
+    display_name: str
+    aliases: tuple[str, ...]
+    detect_any: tuple[str, ...]
+    asset_prefixes: tuple[str, ...]
+    asset_files: tuple[str, ...]
+    skill_target: str | None
+    adapter_path: str
+    capabilities: dict[str, str]
+    command_targets: tuple[CommandTarget, ...]
+
+
+@dataclass(frozen=True)
+class SyncPolicy:
+    protected_files: tuple[str, ...]
+    protected_prefixes: tuple[str, ...]
+    safe_files: tuple[str, ...]
+    safe_prefixes: tuple[str, ...]
+    managed_block_files: tuple[str, ...]
+    obsolete_files: tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class HostManifest:
+    schema_version: int
+    capability_values: tuple[str, ...]
+    platforms: tuple[HostPlatform, ...]
+    excluded_prefixes: tuple[str, ...]
+    sync_policy: SyncPolicy
+
+    @property
+    def platform_ids(self) -> tuple[str, ...]:
+        return tuple(platform.id for platform in self.platforms)
+
+    def platform(self, platform_id: str) -> HostPlatform:
+        for platform in self.platforms:
+            if platform.id == platform_id:
+                return platform
+        raise HostManifestError(f"unknown host platform: {platform_id}")
+
+    def resolve_alias(self, alias: str) -> str:
+        normalized = alias.strip().lower()
+        if normalized == "all":
+            raise HostManifestError("all resolves to multiple host platforms")
+        for platform in self.platforms:
+            if normalized in platform.aliases:
+                return platform.id
+        raise HostManifestError(f"unknown host platform alias: {alias}")
+
+
+def load_host_manifest(template_root: Path) -> HostManifest:
+    path = Path(template_root) / MANIFEST_PATH
+    try:
+        raw = json.loads(path.read_text(encoding="utf-8"))
+    except FileNotFoundError as error:
+        raise HostManifestError(f"missing host asset manifest: {path}") from error
+    except json.JSONDecodeError as error:
+        raise HostManifestError(f"invalid host asset manifest JSON: {path}") from error
+    if not isinstance(raw, dict):
+        raise HostManifestError("host asset manifest must be a JSON object")
+    return _build_manifest(raw)
+
+
+def validate_host_assets(template_root: Path) -> list[str]:
+    root = Path(template_root)
+    errors: list[str] = []
+    try:
+        manifest = load_host_manifest(root)
+    except HostManifestError as error:
+        return [str(error)]
+
+    if not (root / SCHEMA_PATH).is_file():
+        errors.append(f"missing host asset schema: {root / SCHEMA_PATH}")
+
+    allowed = set(manifest.capability_values)
+    aliases: dict[str, str] = {}
+    for platform in manifest.platforms:
+        for alias in platform.aliases:
+            owner = aliases.get(alias)
+            if owner is not None and owner != platform.id:
+                errors.append(
+                    f"duplicate platform alias {alias}: {owner}, {platform.id}"
+                )
+            aliases[alias] = platform.id
+        _validate_platform(root, platform, allowed, errors)
+    return errors
+
+
+def _validate_platform(
+    root: Path,
+    platform: HostPlatform,
+    allowed: set[str],
+    errors: list[str],
+) -> None:
+    adapter_path = root / platform.adapter_path
+    if not adapter_path.is_file():
+        errors.append(f"missing adapter: {platform.adapter_path}")
+        return
+    try:
+        adapter = _parse_simple_yaml(adapter_path)
+    except (OSError, ValueError) as error:
+        errors.append(f"invalid adapter YAML {platform.adapter_path}: {error}")
+        return
+
+    if adapter.get("host") != platform.id:
+        errors.append(
+            f"adapter host mismatch {platform.adapter_path}: "
+            f"{adapter.get('host')} != {platform.id}"
+        )
+    capabilities = adapter.get("capabilities")
+    if not isinstance(capabilities, dict):
+        errors.append(f"adapter missing capabilities: {platform.adapter_path}")
+    else:
+        for name, value in capabilities.items():
+            if value not in allowed:
+                errors.append(
+                    f"illegal capability {platform.id}:{name}={value}"
+                )
+        if capabilities != platform.capabilities:
+            errors.append(
+                f"capability mismatch between manifest and adapter: {platform.id}"
+            )
+
+    for target in platform.command_targets:
+        _validate_command_target(root, platform.id, target, errors)
+
+
+def _validate_command_target(
+    root: Path,
+    platform_id: str,
+    command_target: CommandTarget,
+    errors: list[str],
+) -> None:
+    config_path = root / command_target.config
+    target_path = root / command_target.target
+    if not config_path.is_file():
+        errors.append(
+            f"missing command config {platform_id}: {command_target.config}"
+        )
+        return
+    if not target_path.is_file():
+        errors.append(
+            f"missing command target {platform_id}: {command_target.target}"
+        )
+        return
+    try:
+        config = _load_structured(config_path, command_target.format)
+    except (OSError, ValueError, json.JSONDecodeError) as error:
+        errors.append(
+            f"invalid command config {platform_id}: "
+            f"{command_target.config}: {error}"
+        )
+        return
+    strings = tuple(_walk_strings(config))
+    if not any(command_target.target in value for value in strings):
+        errors.append(
+            f"command config {command_target.config} does not reference "
+            f"{command_target.target}"
+        )
+
+
+def _load_structured(path: Path, format_name: str) -> object:
+    text = path.read_text(encoding="utf-8")
+    if format_name == "json":
+        return json.loads(text)
+    if format_name == "toml":
+        if tomllib is None:
+            raise ValueError("TOML parser unavailable")
+        return tomllib.loads(text)
+    if format_name == "yaml":
+        return _parse_simple_yaml(path)
+    raise ValueError(f"unsupported config format: {format_name}")
+
+
+def _walk_strings(value: object):
+    if isinstance(value, str):
+        yield value
+    elif isinstance(value, dict):
+        for item in value.values():
+            yield from _walk_strings(item)
+    elif isinstance(value, list):
+        for item in value:
+            yield from _walk_strings(item)
+
+
+def _parse_simple_yaml(path: Path) -> dict[str, object]:
+    root: dict[str, object] = {}
+    stack: list[tuple[int, dict[str, object]]] = [(-1, root)]
+    for line_number, raw_line in enumerate(
+        path.read_text(encoding="utf-8").splitlines(),
+        start=1,
+    ):
+        if not raw_line.strip() or raw_line.lstrip().startswith("#"):
+            continue
+        indent = len(raw_line) - len(raw_line.lstrip())
+        stripped = raw_line.strip()
+        key, separator, raw_value = stripped.partition(":")
+        if not separator or not key.strip():
+            raise ValueError(f"invalid mapping at line {line_number}")
+        while stack[-1][0] >= indent:
+            stack.pop()
+        parent = stack[-1][1]
+        value = raw_value.strip()
+        if value:
+            parent[key.strip()] = _parse_scalar(value)
+        else:
+            child: dict[str, object] = {}
+            parent[key.strip()] = child
+            stack.append((indent, child))
+    return root
+
+
+def _parse_scalar(value: str) -> object:
+    if value == "true":
+        return True
+    if value == "false":
+        return False
+    if value.isdecimal():
+        return int(value)
+    return value
+
+
+def _build_manifest(raw: dict[str, Any]) -> HostManifest:
+    schema_version = raw.get("schemaVersion")
+    if schema_version != 1:
+        raise HostManifestError(
+            f"unsupported host asset schemaVersion: {schema_version}"
+        )
+    capability_values = _string_tuple(
+        raw.get("capabilityValues"),
+        "capabilityValues",
+    )
+    platforms_raw = raw.get("platforms")
+    if not isinstance(platforms_raw, list) or not platforms_raw:
+        raise HostManifestError("platforms must be a non-empty array")
+    platforms = tuple(
+        _build_platform(item)
+        for item in platforms_raw
+        if isinstance(item, dict)
+    )
+    if len(platforms) != len(platforms_raw):
+        raise HostManifestError("every platform must be an object")
+    sync_raw = raw.get("syncPolicy")
+    if not isinstance(sync_raw, dict):
+        raise HostManifestError("syncPolicy must be an object")
+    return HostManifest(
+        schema_version=schema_version,
+        capability_values=capability_values,
+        platforms=platforms,
+        excluded_prefixes=_string_tuple(
+            raw.get("excludedPrefixes"),
+            "excludedPrefixes",
+        ),
+        sync_policy=SyncPolicy(
+            protected_files=_string_tuple(
+                sync_raw.get("protectedFiles"),
+                "syncPolicy.protectedFiles",
+            ),
+            protected_prefixes=_string_tuple(
+                sync_raw.get("protectedPrefixes"),
+                "syncPolicy.protectedPrefixes",
+            ),
+            safe_files=_string_tuple(
+                sync_raw.get("safeFiles"),
+                "syncPolicy.safeFiles",
+            ),
+            safe_prefixes=_string_tuple(
+                sync_raw.get("safePrefixes"),
+                "syncPolicy.safePrefixes",
+            ),
+            managed_block_files=_string_tuple(
+                sync_raw.get("managedBlockFiles"),
+                "syncPolicy.managedBlockFiles",
+            ),
+            obsolete_files=_string_tuple(
+                sync_raw.get("obsoleteFiles"),
+                "syncPolicy.obsoleteFiles",
+            ),
+        ),
+    )
+
+
+def _build_platform(raw: dict[str, Any]) -> HostPlatform:
+    platform_id = _required_string(raw, "id")
+    capabilities = raw.get("capabilities")
+    if not isinstance(capabilities, dict) or not capabilities:
+        raise HostManifestError(
+            f"platform {platform_id} capabilities must be an object"
+        )
+    normalized_capabilities: dict[str, str] = {}
+    for name, value in capabilities.items():
+        if not isinstance(name, str) or not isinstance(value, str):
+            raise HostManifestError(
+                f"platform {platform_id} capabilities must be strings"
+            )
+        normalized_capabilities[name] = value
+    command_targets_raw = raw.get("commandTargets")
+    if not isinstance(command_targets_raw, list):
+        raise HostManifestError(
+            f"platform {platform_id} commandTargets must be an array"
+        )
+    command_targets = tuple(
+        CommandTarget(
+            config=_required_string(item, "config"),
+            format=_required_string(item, "format"),
+            target=_required_string(item, "target"),
+        )
+        for item in command_targets_raw
+        if isinstance(item, dict)
+    )
+    if len(command_targets) != len(command_targets_raw):
+        raise HostManifestError(
+            f"platform {platform_id} commandTargets must be objects"
+        )
+    skill_target = raw.get("skillTarget")
+    if skill_target is not None and not isinstance(skill_target, str):
+        raise HostManifestError(
+            f"platform {platform_id} skillTarget must be a string or null"
+        )
+    return HostPlatform(
+        id=platform_id,
+        display_name=_required_string(raw, "displayName"),
+        aliases=_string_tuple(raw.get("aliases"), f"{platform_id}.aliases"),
+        detect_any=_string_tuple(
+            raw.get("detectAny"),
+            f"{platform_id}.detectAny",
+        ),
+        asset_prefixes=_string_tuple(
+            raw.get("assetPrefixes"),
+            f"{platform_id}.assetPrefixes",
+        ),
+        asset_files=_string_tuple(
+            raw.get("assetFiles"),
+            f"{platform_id}.assetFiles",
+        ),
+        skill_target=skill_target,
+        adapter_path=_required_string(raw, "adapterPath"),
+        capabilities=normalized_capabilities,
+        command_targets=command_targets,
+    )
+
+
+def _required_string(raw: dict[str, Any], key: str) -> str:
+    value = raw.get(key)
+    if not isinstance(value, str) or not value.strip():
+        raise HostManifestError(f"{key} must be a non-empty string")
+    return value.strip()
+
+
+def _string_tuple(value: object, label: str) -> tuple[str, ...]:
+    if not isinstance(value, list):
+        raise HostManifestError(f"{label} must be an array")
+    result: list[str] = []
+    for item in value:
+        if not isinstance(item, str) or not item.strip():
+            raise HostManifestError(
+                f"{label} entries must be non-empty strings"
+            )
+        result.append(item.strip())
+    return tuple(result)