cowork-flow 0.0.48 → 0.0.49

package/template/.cowork-flow/scripts/adapters/host/host_manifest.py

@@ -24,6 +24,20 @@ REQUIRED_HOST_NEUTRAL_CAPABILITIES = (
     "party_board_action",
 )
 REQUIRED_CAPABILITY_MATRIX_HOSTS = ("codex", "claude-code", "opencode", "zcode")
+CAPABILITY_STATUS_VALUES = (
+    "native",
+    "shim",
+    "plugin",
+    "external",
+    "experimental",
+    "unsupported",
+)
+MANIFEST_KEYS = frozenset(("schemaVersion", "capabilityValues", "capabilityMatrix", "platforms", "excludedPrefixes", "syncPolicy"))
+PLATFORM_KEYS = frozenset(("id", "displayName", "aliases", "detectAny", "assetPrefixes", "assetFiles", "skillTarget", "adapterPath", "capabilities", "commandTargets"))
+SYNC_POLICY_KEYS = frozenset(("protectedFiles", "protectedPrefixes", "safeFiles", "safePrefixes", "managedBlockFiles", "obsoleteFiles"))
+COMMAND_TARGET_KEYS = frozenset(("config", "format", "target"))
+COMMAND_TARGET_FORMATS = frozenset(("json", "toml", "yaml"))
+CAPABILITY_DECLARATION_KEYS = frozenset(("status", "fallback"))
 
 
 class HostManifestError(RuntimeError):
@@ -309,72 +323,47 @@ def _parse_scalar(value: str) -> object:
 
 
 def _build_manifest(raw: dict[str, Any]) -> HostManifest:
+    _reject_unknown_fields(raw, MANIFEST_KEYS, "host asset manifest")
     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",
-    )
+    capability_values = _string_tuple(raw.get("capabilityValues"), "capabilityValues", unique=True)
+    if capability_values != CAPABILITY_STATUS_VALUES:
+        expected = ", ".join(CAPABILITY_STATUS_VALUES)
+        raise HostManifestError(f"capabilityValues must be: {expected}")
     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)
-    )
+    platforms = tuple(_build_platform(item, set(capability_values)) for item in platforms_raw if isinstance(item, dict))
     if len(platforms) != len(platforms_raw):
         raise HostManifestError("every platform must be an object")
+    _validate_platform_identity(platforms)
     required_host_capabilities, capability_matrix = _build_capability_matrix(
-        raw.get("capabilityMatrix"),
-        capability_values,
-        tuple(platform.id for platform in platforms),
+        raw.get("capabilityMatrix"), capability_values, tuple(platform.id for platform in platforms)
     )
     sync_raw = raw.get("syncPolicy")
     if not isinstance(sync_raw, dict):
         raise HostManifestError("syncPolicy must be an object")
+    _reject_unknown_fields(sync_raw, SYNC_POLICY_KEYS, "syncPolicy")
     return HostManifest(
         schema_version=schema_version,
         capability_values=capability_values,
         required_host_capabilities=required_host_capabilities,
         capability_matrix=capability_matrix,
         platforms=platforms,
-        excluded_prefixes=_string_tuple(
-            raw.get("excludedPrefixes"),
-            "excludedPrefixes",
-        ),
+        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",
-            ),
+            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_capability_matrix(
     raw: object,
     allowed: tuple[str, ...],
@@ -382,6 +371,7 @@ def _build_capability_matrix(
 ) -> tuple[tuple[str, ...], dict[str, dict[str, CapabilityDeclaration]]]:
     if not isinstance(raw, dict):
         raise HostManifestError("capabilityMatrix must be an object")
+    _reject_unknown_fields(raw, frozenset(("required", "hosts")), "capabilityMatrix")
     required = _string_tuple(raw.get("required"), "capabilityMatrix.required")
     if required != REQUIRED_HOST_NEUTRAL_CAPABILITIES:
         expected = ", ".join(REQUIRED_HOST_NEUTRAL_CAPABILITIES)
@@ -389,119 +379,75 @@ def _build_capability_matrix(
     hosts_raw = raw.get("hosts")
     if not isinstance(hosts_raw, dict) or not hosts_raw:
         raise HostManifestError("capabilityMatrix.hosts must be an object")
-
     required_hosts = set(REQUIRED_CAPABILITY_MATRIX_HOSTS).union(platform_ids)
     for host_id in sorted(required_hosts):
         if host_id not in hosts_raw:
             raise HostManifestError(f"capability matrix missing host: {host_id}")
-
     allowed_values = set(allowed)
     matrix: dict[str, dict[str, CapabilityDeclaration]] = {}
     for host_id, capabilities_raw in hosts_raw.items():
         if not isinstance(host_id, str) or not host_id.strip():
             raise HostManifestError("capabilityMatrix host ids must be strings")
         if not isinstance(capabilities_raw, dict):
-            raise HostManifestError(
-                f"capabilityMatrix host {host_id} must be an object"
-            )
+            raise HostManifestError(f"capabilityMatrix host {host_id} must be an object")
         unknown = sorted(set(capabilities_raw) - set(required))
         if unknown:
-            raise HostManifestError(
-                f"unknown host-neutral capability {host_id}:{unknown[0]}"
-            )
+            raise HostManifestError(f"unknown host-neutral capability {host_id}:{unknown[0]}")
         matrix[host_id] = {}
         for capability in required:
             declaration = capabilities_raw.get(capability)
             if not isinstance(declaration, dict):
-                raise HostManifestError(
-                    f"missing host-neutral capability {host_id}:{capability}"
-                )
+                raise HostManifestError(f"missing host-neutral capability {host_id}:{capability}")
+            _reject_unknown_fields(declaration, CAPABILITY_DECLARATION_KEYS, f"capabilityMatrix.hosts.{host_id}.{capability}")
             status = declaration.get("status")
             if not isinstance(status, str) or status not in allowed_values:
-                raise HostManifestError(
-                    f"illegal host-neutral capability {host_id}:{capability}={status}"
-                )
+                raise HostManifestError(f"illegal host-neutral capability {host_id}:{capability}={status}")
             fallback_raw = declaration.get("fallback")
             fallback: str | None = None
             if fallback_raw is not None:
                 if not isinstance(fallback_raw, str) or not fallback_raw.strip():
-                    raise HostManifestError(
-                        f"capability fallback must be a non-empty string: "
-                        f"{host_id}:{capability}"
-                    )
+                    raise HostManifestError(f"capability fallback must be a non-empty string: {host_id}:{capability}")
                 fallback = fallback_raw.strip()
             if status == "unsupported" and fallback is None:
-                raise HostManifestError(
-                    f"unsupported capability requires fallback: "
-                    f"{host_id}:{capability}"
-                )
-            matrix[host_id][capability] = CapabilityDeclaration(
-                status=status,
-                fallback=fallback,
-            )
+                raise HostManifestError(f"unsupported capability requires fallback: {host_id}:{capability}")
+            matrix[host_id][capability] = CapabilityDeclaration(status=status, fallback=fallback)
     return required, matrix
 
-
-def _build_platform(raw: dict[str, Any]) -> HostPlatform:
+def _build_platform(raw: dict[str, Any], allowed: set[str]) -> HostPlatform:
+    _reject_unknown_fields(raw, PLATFORM_KEYS, "platform")
     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"
-        )
+        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"
-            )
+        if not isinstance(name, str) or not name.strip():
+            raise HostManifestError(f"platform {platform_id} capabilities must use string keys")
+        if not isinstance(value, str) or value not in allowed:
+            raise HostManifestError(f"platform {platform_id} illegal capability status {name}={value}")
         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"
-        )
+        raise HostManifestError(f"platform {platform_id} commandTargets must be an array")
+    command_targets = tuple(_build_command_target(item, platform_id) for item in command_targets_raw)
     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"
-        )
+    if skill_target is not None:
+        if not isinstance(skill_target, str) or not skill_target.strip():
+            raise HostManifestError(f"platform {platform_id} skillTarget must be a string or null")
+        skill_target = skill_target.strip()
     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",
-        ),
+        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():
@@ -509,14 +455,52 @@ def _required_string(raw: dict[str, Any], key: str) -> str:
     return value.strip()
 
 
-def _string_tuple(value: object, label: str) -> tuple[str, ...]:
+def _string_tuple(value: object, label: str, *, unique: bool = False) -> tuple[str, ...]:
     if not isinstance(value, list):
         raise HostManifestError(f"{label} must be an array")
     result: list[str] = []
+    seen: set[str] = set()
     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())
+            raise HostManifestError(f"{label} entries must be non-empty strings")
+        normalized = item.strip()
+        if unique and normalized in seen:
+            raise HostManifestError(f"{label} entries must be unique: {normalized}")
+        seen.add(normalized)
+        result.append(normalized)
     return tuple(result)
+
+
+def _build_command_target(raw: object, platform_id: str) -> CommandTarget:
+    if not isinstance(raw, dict):
+        raise HostManifestError(f"platform {platform_id} commandTargets must be objects")
+    _reject_unknown_fields(raw, COMMAND_TARGET_KEYS, f"platform {platform_id} commandTarget")
+    format_value = _required_string(raw, "format")
+    if format_value not in COMMAND_TARGET_FORMATS:
+        raise HostManifestError(f"platform {platform_id} commandTarget.format must be json, toml, or yaml")
+    return CommandTarget(
+        config=_required_string(raw, "config"),
+        format=format_value,
+        target=_required_string(raw, "target"),
+    )
+
+
+def _validate_platform_identity(platforms: tuple[HostPlatform, ...]) -> None:
+    ids: set[str] = set()
+    aliases: dict[str, str] = {}
+    for platform in platforms:
+        if platform.id in ids:
+            raise HostManifestError(f"duplicate platform id: {platform.id}")
+        ids.add(platform.id)
+        for alias in platform.aliases:
+            normalized = alias.lower()
+            owner = aliases.get(normalized)
+            if owner is not None:
+                raise HostManifestError(f"duplicate platform alias {alias}: {owner}, {platform.id}")
+            aliases[normalized] = platform.id
+
+
+def _reject_unknown_fields(raw: dict[str, Any], allowed: frozenset[str], label: str) -> None:
+    unknown = sorted(set(raw) - allowed)
+    if unknown:
+        raise HostManifestError(f"{label} unknown field: {unknown[0]}")

package/template/.cowork-flow/scripts/infra/skill_manifest.py

@@ -312,8 +312,28 @@ def _parse_manifest(path: Path, raw: dict[str, Any]) -> SkillManifest:
     )
 
 
+def _replica_precedence(repo_root: Path, manifest: SkillManifest) -> tuple[int, str]:
+    root = Path(repo_root).resolve()
+    source_template = Path(__file__).resolve().parents[3] / "skills"
+    ordered_roots = (
+        root / "template" / "skills",
+        source_template,
+        root / "skills",
+        root / ".agents" / "skills",
+        root / ".claude" / "skills",
+    )
+    manifest_path = manifest.path.resolve()
+    for index, candidate in enumerate(ordered_roots):
+        try:
+            manifest_path.relative_to(candidate.resolve())
+        except ValueError:
+            continue
+        return (index, str(manifest_path))
+    return (len(ordered_roots), str(manifest_path))
+
+
 def load_skill_manifests(repo_root: Path) -> tuple[SkillManifest, ...]:
-    """Load every valid replica and reject invalid or conflicting metadata."""
+    """Load valid Skill metadata and prefer tracked source replicas."""
     manifests: dict[str, list[SkillManifest]] = {}
     for root in skill_roots(repo_root):
         if not root.is_dir():
@@ -331,7 +351,7 @@ def load_skill_manifests(repo_root: Path) -> tuple[SkillManifest, ...]:
         if any(_manifest_signature(replica) != canonical for replica in replicas[1:]):
             paths = ", ".join(str(replica.path) for replica in replicas)
             raise SkillManifestError(f"conflicting Skill manifest replicas: {skill}: {paths}")
-        result.append(replicas[0])
+        result.append(sorted(replicas, key=lambda replica: _replica_precedence(repo_root, replica))[0])
     command_owners: dict[str, str] = {}
     for manifest in result:
         for command in manifest.commands:
@@ -364,7 +384,7 @@ def _manifest_signature(manifest: SkillManifest) -> tuple[object, ...]:
             for item in manifest.context_rules
         ),
         tuple(
-            (item.name, item.aliases, item.script, item.script_digest)
+            (item.name, item.aliases, item.script)
             for item in manifest.commands
         ),
     )

package/template/.cowork-flow/scripts/infra/storage/operation_log.py

@@ -70,3 +70,43 @@ class OperationLog:
             if record.get("phase") not in FINAL_PHASES:
                 records.append(record)
         return tuple(records)
+    def pending_facts(self) -> tuple[dict, ...]:
+        """Return read-only facts about non-final operation records."""
+        if not self.operations_dir.is_dir():
+            return ()
+        facts: list[dict] = []
+        for path in sorted(self.operations_dir.glob("*.json")):
+            try:
+                record = self.state_store.load(path).data
+            except StateStoreError as error:
+                facts.append(
+                    {
+                        "path": str(path),
+                        "phase": "unreadable",
+                        "error": {
+                            "code": error.code,
+                            "path": str(error.path),
+                            "detail": error.detail,
+                        },
+                    }
+                )
+                continue
+            phase = record.get("phase")
+            if phase == "committed":
+                continue
+            participants = record.get("participants")
+            facts.append(
+                {
+                    "path": str(path),
+                    "operation_id": str(record.get("operation_id") or path.stem),
+                    "kind": str(record.get("kind") or "unknown"),
+                    "phase": str(phase or "unknown"),
+                    "participant_count": (
+                        len(participants)
+                        if isinstance(participants, list)
+                        else 0
+                    ),
+                    "error": record.get("error"),
+                }
+            )
+        return tuple(facts)