cowork-flow 0.0.46 → 0.0.48

package/src/lib/host-assets.js

@@ -12,6 +12,19 @@ export const hostAssetManifestPath = join(
   'host-assets.json'
 );
 
+const REQUIRED_HOST_NEUTRAL_CAPABILITIES = [
+  'task_action',
+  'subagent_dispatch',
+  'file_write',
+  'party_board_action'
+];
+const REQUIRED_CAPABILITY_MATRIX_HOSTS = [
+  'codex',
+  'claude-code',
+  'opencode',
+  'zcode'
+];
+
 
 export function loadHostAssetManifest(path = hostAssetManifestPath) {
   const manifest = JSON.parse(readFileSync(path, 'utf8'));
@@ -41,6 +54,7 @@ export function createHostRegistry(manifest) {
     }
   }
   const platformIds = platforms.map((platform) => platform.id);
+  const capabilityMatrix = normalizeCapabilityMatrix(manifest.capabilityMatrix);
   const syncPolicy = {
     protectedFiles: manifest.syncPolicy.protectedFiles.map(normalizePath),
     protectedPrefixes: manifest.syncPolicy.protectedPrefixes.map(normalizePath),
@@ -49,6 +63,20 @@ export function createHostRegistry(manifest) {
     managedBlockFiles: manifest.syncPolicy.managedBlockFiles.map(normalizePath),
     obsoleteFiles: manifest.syncPolicy.obsoleteFiles.map(normalizePath)
   };
+  const assetPrefixes = unique(
+    platforms.flatMap((platform) => platform.assetPrefixes)
+  );
+  const skillTargets = unique(
+    platforms
+      .map((platform) => platform.skillTarget)
+      .filter(
+        (value) => typeof value === 'string' && value.length > 0
+      )
+      .map(normalizePath)
+  );
+  const protectedFiles = new Set(syncPolicy.protectedFiles);
+  const safeFiles = new Set(syncPolicy.safeFiles);
+  const managedBlockFiles = new Set(syncPolicy.managedBlockFiles);
 
   function parsePlatformSelection(values) {
     const rawValues = Array.isArray(values) ? values : [values];
@@ -92,20 +120,57 @@ export function createHostRegistry(manifest) {
     ) {
       return false;
     }
-    const owners = platforms.filter((platform) => (
-      platform.assetFiles.includes(normalized)
-      || platform.assetPrefixes.some(
-        (prefix) => normalized.startsWith(prefix)
-      )
-    ));
+    const owners = assetOwners(normalized);
     if (owners.length === 0) {
       return true;
     }
     return owners.some(
-      (platform) => selectedPlatforms.includes(platform.id)
+      (platformId) => selectedPlatforms.includes(platformId)
     );
   }
 
+  function assetOwners(relativePath) {
+    const normalized = normalizePath(relativePath);
+    return platforms
+      .filter((platform) => ownsAsset(platform, normalized))
+      .map((platform) => platform.id);
+  }
+
+  function isKnownPlatformAsset(relativePath) {
+    return assetOwners(relativePath).length > 0;
+  }
+
+  function isSafeSyncFile(relativePath) {
+    const normalized = normalizePath(relativePath);
+    return safeFiles.has(normalized)
+      || syncPolicy.safePrefixes.some((prefix) => normalized.startsWith(prefix))
+      || assetPrefixes.some((prefix) => normalized.startsWith(prefix))
+      || skillTargets.some((target) => normalized.startsWith(`${target}/`))
+      || normalized.endsWith('/.gitkeep');
+  }
+
+  function isProtectedSyncFile(relativePath) {
+    const normalized = normalizePath(relativePath);
+    if (safeFiles.has(normalized)) {
+      return false;
+    }
+    return protectedFiles.has(normalized)
+      || syncPolicy.protectedPrefixes.some((prefix) => normalized.startsWith(prefix));
+  }
+
+  function isManagedBlockFile(relativePath) {
+    return managedBlockFiles.has(normalizePath(relativePath));
+  }
+
+  function obsoleteSyncFiles() {
+    return [...syncPolicy.obsoleteFiles].sort((left, right) => {
+      if (left.length !== right.length) {
+        return left.length - right.length;
+      }
+      return left.localeCompare(right);
+    });
+  }
+
   async function detectInstalledPlatforms(targetDir, pathExists) {
     const installed = [];
     for (const platform of platforms) {
@@ -123,20 +188,13 @@ export function createHostRegistry(manifest) {
     manifest,
     platforms,
     platformIds,
+    capabilityMatrix,
     syncPolicy,
-    assetPrefixes: unique(
-      platforms.flatMap((platform) => platform.assetPrefixes)
-    ),
-    skillTargets: unique(
-      platforms
-        .map((platform) => platform.skillTarget)
-        .filter(
-          (value) => typeof value === 'string' && value.length > 0
-        )
-        .map(normalizePath)
-    ),
+    assetPrefixes,
+    skillTargets,
     parsePlatformSelection,
     shouldInclude,
+    assetOwners,
     detectInstalledPlatforms,
     platform(platformId) {
       return byId.get(platformId) ?? null;
@@ -144,22 +202,29 @@ export function createHostRegistry(manifest) {
     platformLabel(platformId) {
       return byId.get(platformId)?.displayName ?? platformId;
     },
+    hostCapability(hostId, capability) {
+      return capabilityMatrix.hosts[hostId]?.[capability] ?? null;
+    },
     skillDestination(platformId) {
       return byId.get(platformId)?.skillTarget ?? null;
     },
-    isKnownPlatformAsset(relativePath) {
-      const normalized = normalizePath(relativePath);
-      return platforms.some((platform) => (
-        platform.assetFiles.includes(normalized)
-        || platform.assetPrefixes.some(
-          (prefix) => normalized.startsWith(prefix)
-        )
-      ));
-    }
+    isKnownPlatformAsset,
+    isSafeSyncFile,
+    isProtectedSyncFile,
+    isManagedBlockFile,
+    obsoleteSyncFiles
   };
 }
 
 
+function ownsAsset(platform, normalizedPath) {
+  return platform.assetFiles.includes(normalizedPath)
+    || platform.assetPrefixes.some(
+      (prefix) => normalizedPath.startsWith(prefix)
+    );
+}
+
+
 function validateManifest(manifest) {
   if (!manifest || typeof manifest !== 'object' || Array.isArray(manifest)) {
     throw new Error('Host Asset Manifest must be an object');
@@ -179,6 +244,7 @@ function validateManifest(manifest) {
       'Host Asset Manifest excludedPrefixes must be an array'
     );
   }
+  validateCapabilityMatrix(manifest);
   if (!manifest.syncPolicy || typeof manifest.syncPolicy !== 'object') {
     throw new Error('Host Asset Manifest syncPolicy must be an object');
   }
@@ -217,6 +283,91 @@ function validateManifest(manifest) {
 }
 
 
+function validateCapabilityMatrix(manifest) {
+  if (!Array.isArray(manifest.capabilityValues) || manifest.capabilityValues.length === 0) {
+    throw new Error('Host Asset Manifest capabilityValues must be a non-empty array');
+  }
+  const allowed = new Set(manifest.capabilityValues);
+  for (const value of allowed) {
+    if (typeof value !== 'string' || value.length === 0) {
+      throw new Error('Host Asset Manifest capabilityValues entries must be strings');
+    }
+  }
+  const matrix = manifest.capabilityMatrix;
+  if (!matrix || typeof matrix !== 'object' || Array.isArray(matrix)) {
+    throw new Error('Host Asset Manifest capabilityMatrix must be an object');
+  }
+  if (!arraysEqual(matrix.required, REQUIRED_HOST_NEUTRAL_CAPABILITIES)) {
+    throw new Error(
+      `Host Asset Manifest capabilityMatrix.required must be ${REQUIRED_HOST_NEUTRAL_CAPABILITIES.join(', ')}`
+    );
+  }
+  if (!matrix.hosts || typeof matrix.hosts !== 'object' || Array.isArray(matrix.hosts)) {
+    throw new Error('Host Asset Manifest capabilityMatrix.hosts must be an object');
+  }
+  const requiredHosts = new Set([
+    ...REQUIRED_CAPABILITY_MATRIX_HOSTS,
+    ...manifest.platforms.map((platform) => platform.id)
+  ]);
+  for (const hostId of [...requiredHosts].sort()) {
+    if (!matrix.hosts[hostId]) {
+      throw new Error(`Host Asset Manifest capability matrix missing host: ${hostId}`);
+    }
+  }
+  for (const [hostId, capabilities] of Object.entries(matrix.hosts)) {
+    if (!capabilities || typeof capabilities !== 'object' || Array.isArray(capabilities)) {
+      throw new Error(`Host Asset Manifest capabilityMatrix host ${hostId} must be an object`);
+    }
+    for (const key of Object.keys(capabilities)) {
+      if (!REQUIRED_HOST_NEUTRAL_CAPABILITIES.includes(key)) {
+        throw new Error(`Host Asset Manifest unknown host-neutral capability ${hostId}:${key}`);
+      }
+    }
+    for (const capability of REQUIRED_HOST_NEUTRAL_CAPABILITIES) {
+      const declaration = capabilities[capability];
+      if (!declaration || typeof declaration !== 'object' || Array.isArray(declaration)) {
+        throw new Error(`Host Asset Manifest missing host-neutral capability ${hostId}:${capability}`);
+      }
+      if (!allowed.has(declaration.status)) {
+        throw new Error(
+          `Host Asset Manifest illegal host-neutral capability ${hostId}:${capability}=${declaration.status}`
+        );
+      }
+      if (declaration.fallback !== undefined && (
+        typeof declaration.fallback !== 'string' || declaration.fallback.length === 0
+      )) {
+        throw new Error(
+          `Host Asset Manifest capability fallback must be a non-empty string: ${hostId}:${capability}`
+        );
+      }
+      if (declaration.status === 'unsupported' && !declaration.fallback) {
+        throw new Error(
+          `Host Asset Manifest unsupported capability requires fallback: ${hostId}:${capability}`
+        );
+      }
+    }
+  }
+}
+
+
+function normalizeCapabilityMatrix(matrix) {
+  return {
+    required: [...matrix.required],
+    hosts: Object.fromEntries(
+      Object.entries(matrix.hosts).map(([hostId, capabilities]) => [
+        hostId,
+        Object.fromEntries(
+          Object.entries(capabilities).map(([capability, declaration]) => [
+            capability,
+            { ...declaration }
+          ])
+        )
+      ])
+    )
+  };
+}
+
+
 function normalizePath(value) {
   return String(value).replaceAll('\\', '/');
 }
@@ -227,5 +378,12 @@ function unique(values) {
 }
 
 
+function arraysEqual(left, right) {
+  return Array.isArray(left)
+    && left.length === right.length
+    && left.every((value, index) => value === right[index]);
+}
+
+
 export const hostAssetManifest = loadHostAssetManifest();
 export const hostRegistry = createHostRegistry(hostAssetManifest);

package/src/lib/plan-applier.js

@@ -226,6 +226,53 @@ function validateMetadata(metadata, transactionRoot, resolvedTarget) {
   }
 }
 
+export async function inspectAssetTransactions(
+  targetDir,
+  { fileSystem = defaultFileSystem } = {}
+) {
+  const fs = fileSystem ?? defaultFileSystem;
+  const resolvedTarget = resolve(targetDir);
+  const parentDir = dirname(resolvedTarget);
+  let entries;
+  try {
+    entries = await fs.readdir(parentDir, { withFileTypes: true });
+  } catch (error) {
+    if (error && error.code === 'ENOENT') {
+      return [];
+    }
+    throw error;
+  }
+
+  const prefix = transactionPrefix(resolvedTarget);
+  const transactions = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory() || !entry.name.startsWith(prefix)) {
+      continue;
+    }
+    const transactionRoot = join(parentDir, entry.name);
+    try {
+      const metadata = await readMetadata(fs, transactionRoot);
+      validateMetadata(metadata, transactionRoot, resolvedTarget);
+      transactions.push({
+        path: transactionRoot,
+        status: metadata.status,
+        actionCount: metadata.actions.length,
+        pending: metadata.status !== 'committed'
+      });
+    } catch (error) {
+      transactions.push({
+        path: transactionRoot,
+        status: 'unknown',
+        actionCount: null,
+        pending: true,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+
+  return transactions.sort((left, right) => left.path.localeCompare(right.path));
+}
+
 export async function recoverAssetTransactions(
   targetDir,
   { fileSystem = defaultFileSystem } = {}

package/template/.claude/hooks/inject-workflow-state.py

@@ -10,6 +10,12 @@ from pathlib import Path
 from typing import Any
 
 
+def _configure_stdio() -> None:
+    for stream in (sys.stdout, sys.stderr):
+        if hasattr(stream, "reconfigure"):
+            stream.reconfigure(encoding="utf-8", errors="replace")
+
+
 def _read_input() -> dict[str, Any]:
     raw = sys.stdin.buffer.read()
     if not raw.strip():
@@ -90,4 +96,5 @@ def main() -> int:
 
 
 if __name__ == "__main__":
+    _configure_stdio()
     raise SystemExit(main())

package/template/.codex/hooks/inject-workflow-state.py

@@ -10,6 +10,12 @@ from pathlib import Path
 from typing import Any
 
 
+def _configure_stdio() -> None:
+    for stream in (sys.stdout, sys.stderr):
+        if hasattr(stream, "reconfigure"):
+            stream.reconfigure(encoding="utf-8", errors="replace")
+
+
 def _read_input() -> dict[str, Any]:
     raw = sys.stdin.buffer.read()
     if not raw.strip():
@@ -87,4 +93,5 @@ def main() -> int:
 
 
 if __name__ == "__main__":
+    _configure_stdio()
     raise SystemExit(main())

package/template/.cowork-flow/.version

@@ -1 +1 @@
-0.0.46
+0.0.48

package/template/.cowork-flow/config.yaml

@@ -3,17 +3,6 @@
 #
 # All values have sensible defaults. Only override what you need.
 
-#-------------------------------------------------------------------------------
-# Session Recording
-#-------------------------------------------------------------------------------
-
-# Commit message used when auto-committing journal/index changes
-# after running add_session.py
-session_commit_message: "chore: record journal"
-
-# Maximum lines per journal file before rotating to a new one
-max_journal_lines: 2000
-
 #-------------------------------------------------------------------------------
 # Codex Runtime
 #-------------------------------------------------------------------------------

package/template/.cowork-flow/scripts/adapters/cli/init_developer.py

@@ -7,7 +7,6 @@ Usage:
 
 This creates:
     - .cowork-flow/.developer file with developer info
-    - .cowork-flow/workspace/<name>/ directory structure
 """
 
 from __future__ import annotations

package/template/.cowork-flow/scripts/adapters/cli/subagent.py

@@ -98,6 +98,9 @@ def _host_context_prefix(host: str) -> str:
 def _suggest_host_context_key(host: str, runtime_context_id: str) -> str:
     return f"{_host_context_prefix(host)}_{runtime_context_id}"
 
+def _print_runtime_error(error: RuntimeContextError) -> None:
+    print(f"Error: {error.code}: {error.detail}", file=sys.stderr)
+
 def _resolve_agent_type(role: str, agent_type: str | None) -> tuple[str, str]:
     normalized_role = role.strip()
     requested = agent_type.strip() if isinstance(agent_type, str) else ""
@@ -178,7 +181,7 @@ def cmd_init(args: argparse.Namespace) -> int:
             context,
         )
     except RuntimeContextError as error:
-        print(f"Error: {error.detail}", file=sys.stderr)
+        _print_runtime_error(error)
         return 1
     logical_context_key = initialized.logical_context_key
     host_context_key = _suggest_host_context_key(host, runtime_context_id)
@@ -244,7 +247,7 @@ def cmd_update(args: argparse.Namespace) -> int:
             note=args.note,
         )
     except RuntimeContextError as error:
-        print(f"Error: {error.detail}", file=sys.stderr)
+        _print_runtime_error(error)
         return 1
     if context is None:
         print(f"Error: subagent not found: {args.subagent_id}", file=sys.stderr)
@@ -261,7 +264,7 @@ def cmd_bind(args: argparse.Namespace) -> int:
             args.context_key,
         )
     except RuntimeContextError as error:
-        print(f"Error: {error.detail}", file=sys.stderr)
+        _print_runtime_error(error)
         return 1
     if context is None:
         print(f"Error: cannot bind runtime context: {args.subagent_id}", file=sys.stderr)
@@ -275,7 +278,7 @@ def cmd_close(args: argparse.Namespace) -> int:
     try:
         closed = RuntimeContextService(repo_root).close(args.subagent_id)
     except RuntimeContextError as error:
-        print(f"Error: {error.detail}", file=sys.stderr)
+        _print_runtime_error(error)
         return 1
     if not closed:
         print(f"Error: subagent not found: {args.subagent_id}", file=sys.stderr)