cowork-flow 0.0.47 → 0.0.49

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

@@ -17,6 +17,28 @@ except ModuleNotFoundError:  # pragma: no cover - Python < 3.11
 MANIFEST_PATH = Path(".cowork-flow/spec/runtime/host-assets.json")
 SCHEMA_PATH = Path(".cowork-flow/spec/schemas/host-assets.schema.json")
 
+REQUIRED_HOST_NEUTRAL_CAPABILITIES = (
+    "task_action",
+    "subagent_dispatch",
+    "file_write",
+    "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):
     """Raised when the Host Asset Manifest is unavailable or invalid."""
@@ -29,6 +51,12 @@ class CommandTarget:
     target: str
 
 
+@dataclass(frozen=True)
+class CapabilityDeclaration:
+    status: str
+    fallback: str | None
+
+
 @dataclass(frozen=True)
 class HostPlatform:
     id: str
@@ -57,6 +85,8 @@ class SyncPolicy:
 class HostManifest:
     schema_version: int
     capability_values: tuple[str, ...]
+    required_host_capabilities: tuple[str, ...]
+    capability_matrix: dict[str, dict[str, CapabilityDeclaration]]
     platforms: tuple[HostPlatform, ...]
     excluded_prefixes: tuple[str, ...]
     sync_policy: SyncPolicy
@@ -80,6 +110,18 @@ class HostManifest:
                 return platform.id
         raise HostManifestError(f"unknown host platform alias: {alias}")
 
+    def host_capability(
+        self,
+        host_id: str,
+        capability: str,
+    ) -> CapabilityDeclaration:
+        try:
+            return self.capability_matrix[host_id][capability]
+        except KeyError as error:
+            raise HostManifestError(
+                f"unknown host-neutral capability: {host_id}:{capability}"
+            ) from error
+
 
 def load_host_manifest(template_root: Path) -> HostManifest:
     path = Path(template_root) / MANIFEST_PATH
@@ -281,125 +323,131 @@ 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)
+    )
     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_platform(raw: dict[str, Any]) -> HostPlatform:
+def _build_capability_matrix(
+    raw: object,
+    allowed: tuple[str, ...],
+    platform_ids: tuple[str, ...],
+) -> 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)
+        raise HostManifestError(f"capabilityMatrix.required must be: {expected}")
+    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")
+        unknown = sorted(set(capabilities_raw) - set(required))
+        if unknown:
+            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}")
+            _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}")
+            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: {host_id}:{capability}")
+                fallback = fallback_raw.strip()
+            if status == "unsupported" and fallback is None:
+                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], 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():
@@ -407,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/config.py

@@ -13,8 +13,6 @@ from infra.paths import DIR_WORKFLOW, get_repo_root
 
 
 # Defaults
-DEFAULT_SESSION_COMMIT_MESSAGE = "chore: record journal"
-DEFAULT_MAX_JOURNAL_LINES = 2000
 DEFAULT_CODEX_DISPATCH_MODE = "sub-agent"
 DEFAULT_PARTY_MODE_V2_MIN_AGENTS = 3
 DEFAULT_PARTY_MODE_V2_MAX_AGENTS = 5
@@ -108,21 +106,6 @@ def _load_config(repo_root: Path | None = None) -> dict:
         return {}
 
 
-def get_session_commit_message(repo_root: Path | None = None) -> str:
-    """Get the commit message for auto-committing session records."""
-    config = _load_config(repo_root)
-    return config.get("session_commit_message", DEFAULT_SESSION_COMMIT_MESSAGE)
-
-
-def get_max_journal_lines(repo_root: Path | None = None) -> int:
-    """Get the maximum lines per journal file."""
-    config = _load_config(repo_root)
-    value = config.get("max_journal_lines", DEFAULT_MAX_JOURNAL_LINES)
-    try:
-        return int(value)
-    except (ValueError, TypeError):
-        return DEFAULT_MAX_JOURNAL_LINES
-
 
 def get_hooks(event: str, repo_root: Path | None = None) -> list[str]:
     """Get hook commands for a lifecycle event.

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

@@ -16,10 +16,8 @@ from pathlib import Path
 
 from infra.paths import (
     DIR_WORKFLOW,
-    DIR_WORKSPACE,
     DIR_TASKS,
     FILE_DEVELOPER,
-    FILE_JOURNAL_PREFIX,
     get_repo_root,
     get_developer,
     check_developer,
@@ -30,75 +28,12 @@ from infra.paths import (
 # Developer Initialization
 # =============================================================================
 
-INITIAL_JOURNAL_NUMBER = 1
-INDEX_FILE_NAME = "index.md"
-
-
-def _initial_journal_content(name: str, today: str) -> str:
-    """Build the initial journal file content."""
-    return f"""# Development Journal - {name} (Part 1)
-
-> AI development session journal
-> Start date: {today}
-
----
-
-"""
-
-
-def _initial_index_content(name: str) -> str:
-    """Build the initial workspace index content."""
-    return f"""# Workspace Index - {name}
-
-> Tracks AI development session records.
-
----
-
-## Current Status
-
-<!-- @@@auto:current-status -->
-- **Current file**: `journal-1.md`
-- **Total Sessions**: 0
-- **Last Active**: -
-<!-- @@@/auto:current-status -->
-
----
-
-## Active Documents
-
-<!-- @@@auto:active-documents -->
-| File | Lines | Status |
-|------|------|------|
-| `journal-1.md` | ~0 | Current |
-<!-- @@@/auto:active-documents -->
-
----
-
-## Session History
-
-<!-- @@@auto:session-history -->
-| # | Date | Title | Commit |
-|---|------|------|------|
-<!-- @@@/auto:session-history -->
-
----
-
-## Notes
-
-- Sessions are appended to the journal file
-- A new journal file is created automatically after the current file exceeds 2000 lines
-- Use `add_session.py` to record sessions
-- New records use English text; existing records can remain as they are
-"""
-
 
 def init_developer(name: str, repo_root: Path | None = None) -> bool:
     """Initialize developer.
 
     Creates:
         - .cowork-flow/.developer file with developer info
-        - .cowork-flow/workspace/<name>/ directory structure
-        - Initial journal file and index.md
 
     Args:
         name: Developer name.
@@ -115,7 +50,6 @@ def init_developer(name: str, repo_root: Path | None = None) -> bool:
         repo_root = get_repo_root()
 
     dev_file = repo_root / DIR_WORKFLOW / FILE_DEVELOPER
-    workspace_dir = repo_root / DIR_WORKFLOW / DIR_WORKSPACE / name
 
     # Create .developer file
     initialized_at = datetime.now().isoformat()
@@ -128,37 +62,9 @@ def init_developer(name: str, repo_root: Path | None = None) -> bool:
         print(f"Error: failed to create .developer file: {e}", file=sys.stderr)
         return False
 
-    # Create workspace directory structure
-    try:
-        workspace_dir.mkdir(parents=True, exist_ok=True)
-    except (OSError, IOError) as e:
-        print(f"Error: failed to create workspace directory: {e}", file=sys.stderr)
-        return False
-
-    # Create initial journal file
-    journal_file = workspace_dir / f"{FILE_JOURNAL_PREFIX}{INITIAL_JOURNAL_NUMBER}.md"
-    if not journal_file.exists():
-        today = datetime.now().strftime("%Y-%m-%d")
-        journal_content = _initial_journal_content(name, today)
-        try:
-            journal_file.write_text(journal_content, encoding="utf-8")
-        except (OSError, IOError) as e:
-            print(f"Error: failed to create journal file: {e}", file=sys.stderr)
-            return False
-
-    # Create index.md with markers for auto-update
-    index_file = workspace_dir / INDEX_FILE_NAME
-    if not index_file.exists():
-        index_content = _initial_index_content(name)
-        try:
-            index_file.write_text(index_content, encoding="utf-8")
-        except (OSError, IOError) as e:
-            print(f"Error: failed to create index.md: {e}", file=sys.stderr)
-            return False
 
     print(f"Developer initialized: {name}")
     print(f"  .developer file: {dev_file}")
-    print(f"  Workspace directory: {workspace_dir}")
 
     return True
 
@@ -193,7 +99,6 @@ def show_developer_info(repo_root: Path | None = None) -> None:
         print("Developer: not initialized")
     else:
         print(f"Developer: {developer}")
-        print(f"Workspace: {DIR_WORKFLOW}/{DIR_WORKSPACE}/{developer}/")
         print(f"Tasks directory: {DIR_WORKFLOW}/{DIR_TASKS}/")
 
 

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

@@ -5,9 +5,7 @@ Common path utilities for Cowork Flow workflow.
 Provides:
     get_repo_root          - Get repository root directory
     get_developer          - Get developer name
-    get_workspace_dir      - Get developer workspace directory
     get_tasks_dir          - Get tasks directory
-    get_active_journal_file - Get current journal file
 """
 
 from __future__ import annotations
@@ -24,8 +22,6 @@ from pathlib import Path
 # Directory names
 DIR_WORKFLOW = ".cowork-flow"
 DIR_AGENTS = ".agents"
-DIR_CHANGES = "changes"
-DIR_WORKSPACE = "workspace"
 DIR_TASKS = "tasks"
 DIR_ARCHIVE = "archive"
 DIR_SPEC = "spec"
@@ -34,7 +30,6 @@ DIR_SCRIPTS = "scripts"
 # File names
 FILE_DEVELOPER = ".developer"
 FILE_TASK_JSON = "task.json"
-FILE_JOURNAL_PREFIX = "journal-"
 TASK_DATE_PREFIX_PATTERN = re.compile(r"^\d{2}-\d{2}-")
 
 
@@ -129,78 +124,6 @@ def get_tasks_dir(repo_root: Path | None = None) -> Path:
     return repo_root / DIR_WORKFLOW / DIR_TASKS
 
 
-# =============================================================================
-# Workspace Directory
-# =============================================================================
-
-def get_workspace_dir(repo_root: Path | None = None) -> Path | None:
-    """Get developer workspace directory.
-
-    Args:
-        repo_root: Repository root path. Defaults to auto-detected.
-
-    Returns:
-        Path to workspace directory or None if developer not set.
-    """
-    if repo_root is None:
-        repo_root = get_repo_root()
-
-    developer = get_developer(repo_root)
-    if developer:
-        return repo_root / DIR_WORKFLOW / DIR_WORKSPACE / developer
-    return None
-
-
-# =============================================================================
-# Journal File
-# =============================================================================
-
-def get_active_journal_file(repo_root: Path | None = None) -> Path | None:
-    """Get the current active journal file.
-
-    Args:
-        repo_root: Repository root path. Defaults to auto-detected.
-
-    Returns:
-        Path to active journal file or None if not found.
-    """
-    if repo_root is None:
-        repo_root = get_repo_root()
-
-    workspace_dir = get_workspace_dir(repo_root)
-    if workspace_dir is None or not workspace_dir.is_dir():
-        return None
-
-    latest: Path | None = None
-    highest = 0
-
-    for f in workspace_dir.glob(f"{FILE_JOURNAL_PREFIX}*.md"):
-        if not f.is_file():
-            continue
-
-        # Extract number from filename
-        name = f.stem  # e.g., "journal-1"
-        match = re.search(r"(\d+)$", name)
-        if match:
-            num = int(match.group(1))
-            if num > highest:
-                highest = num
-                latest = f
-
-    return latest
-
-
-def count_lines(file_path: Path) -> int:
-    """Count lines in a file.
-
-    Args:
-        file_path: Path to file.
-
-    Returns:
-        Number of lines, or 0 if file doesn't exist.
-    """
-    if not file_path.is_file():
-        return 0
 
     try:
         with file_path.open("r", encoding="utf-8") as f:
@@ -238,5 +161,3 @@ if __name__ == "__main__":
     print(f"Repository root: {repo}")
     print(f"Developer: {get_developer(repo)}")
     print(f"Tasks dir: {get_tasks_dir(repo)}")
-    print(f"Workspace dir: {get_workspace_dir(repo)}")
-    print(f"Journal file: {get_active_journal_file(repo)}")

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
         ),
     )