cowork-flow 0.0.37 → 0.0.39

package/README.md

@@ -51,6 +51,14 @@ template/
     └── workspace/             # 开发者工作区
 ```
 
+## 架构与扩展点
+
+- **应用服务层**：任务创建、生命周期、归档、上下文、任务树和 runtime context 编排位于 `scripts/application/`；命令层只负责参数和输出适配。
+- **状态存储层**：`scripts/common/storage/` 提供显式 UTF-8、修订检查、操作日志和可恢复 Unit of Work；任务与会话写入不再直接散落在命令函数中。
+- **Host Asset Manifest**：`spec/runtime/host-assets.json` 是宿主资产、平台识别、同步策略和 obsolete 迁移清单的权威来源。新增平台或资产时更新 Manifest 与 schema，不在 CLI 中新增硬编码集合。
+- **事务式 init/sync**：CLI 先构建不可变 Asset Plan，在同文件系统 staging 中校验 hash/权限，再按备份清单提交；失败时逆序回滚，`.cowork-flow/.version` 最后更新。
+- **共享 Hook 核心**：Codex 与 Claude Code Hook 只做宿主输入适配，工作流状态解析由 `scripts/common/host/workflow_state_hook.py` 统一实现。
+
 ## Skills 分发机制
 
 Skills 维护在 `template/skills/` 唯一源码，`init` 时按平台分发到对应目录：
@@ -60,7 +68,7 @@ Skills 维护在 `template/skills/` 唯一源码，`init` 时按平台分发到
 | `codex` / `opencode` | `.agents/skills/` |
 | `claude-code` | `.claude/skills/` |
 
-分发动作：`before-dev`、`brainstorming`、`break-loop`、`check`、`continue`、`finish-work`、`game-design`、`meta`、`party-mode`、`party-mode-v2`、`python-design`、`start`、`tdd`、`update-spec`、`writing-plans`
+分发动作：`batch-mode`、`brainstorming`、`break-loop`、`cowork-flow`、`party-mode`、`writing-plans`
 
 ## CLI 命令
 
@@ -85,6 +93,8 @@ Skills 维护在 `template/skills/` 唯一源码，`init` 时按平台分发到
 - **自动识别**已安装 host 目录，只同步对应平台资产
 - **Skills** 从 `template/skills/` 按平台分发
 - **保护文件**：`config.yaml`、`workflow.md`、`spec/`（除 `workflow-state-templates.md`）、任务、计划、变更、workspace
+- **正式版旧资产清理**：旧脚本位置、旧 adapter 资产和已废弃文件按 Host Asset Manifest 的 `obsoleteFiles` 清理；用户保护文件保持不变
+- **事务恢复**：上次未完成事务会在新一轮 sync 前恢复；事务元数据缺失或损坏时 fail-closed，不在未知状态上继续写入
 - `--force` 整文件覆盖保护文件
 
 ## ZCode 插件
@@ -116,6 +126,11 @@ changes → brainstorming → read spec → plan → tasks → implement → che
 | 归档 | `task archive <name>` | `completed`（归档副本） |
 | 清会话指针 | `task finish` | 不变 |
 
+> Batch 使用任务图和持久化 Host action：运行
+> `task start <parent-task> --auto --approved` 获取 `next_action`，
+> Host 完成真实生命周期动作后用 `task batch-record-result <batch-id> --file <result.json>`
+> 回写结果；失败会暂停，可用 `task batch-resume <batch-id>` 生成新的重试动作。
+
 ## 常用命令
 
 ```bash
@@ -147,14 +162,9 @@ changes → brainstorming → read spec → plan → tasks → implement → che
 
 ## Party Mode
 
-| | v1 | v2 |
-|---|---|---|
-| 机制 | 真实子代理 roundtable | Runtime board controlled |
-| 默认 | `max_agents=3`、`max_rounds=5` | 由 runtime 管理 |
-| 交互 | Host Adapter 协调 | Board API |
-| 产出 | 建议、证据、分歧、验收信号 | 同上 |
-
-party-mode、party-mode-v2 是两种 advisory roundtable 模式。默认 `max_agents=3`、`max_rounds=5`（v1）。`party-mode-v2` 是 runtime board controlled advisory workflow，子代理通过 board API 交流，主持人只监控和纠偏。
+`party-mode` 是唯一公开的 advisory roundtable 入口。它默认使用
+runtime board controlled workflow：子代理通过 Board API 交流，主持人只执行
+runtime 发出的 host-neutral action、记录执行结果并纠偏漂移。
 
 > Party Mode 只产出建议，不能推进任务状态，也不能替代 `cowork-implement` / `cowork-check`。
 
@@ -166,14 +176,17 @@ npm run release -- minor # minor
 ```
 
 **发布流程：**
-1. `npm run test:all`（Node + Python + pack check）
-2. `npm version` 升级版本
-3. 同步版本到 `template/.cowork-flow/.version` 和 `template/.zcode/.zcode-plugin/plugin.json`
-4. `git commit` + `git tag`
-5. `npm publish`
+1. `npm test`、`npm run test:template`、`npm run pack:check`、`git diff --check`
+2. 稳定性变更使用 `COWORK_TEMPLATE_TEST_REPEAT=3` 和固定 `COWORK_TEMPLATE_TEST_SEED` 重复运行模板测试
+3. `npm version` 升级版本
+4. 同步版本到 `template/.cowork-flow/.version` 和 `template/.zcode/.zcode-plugin/plugin.json`
+5. `git commit` + `git tag`
+6. `npm publish`
 
 CI 需要 `NPM_TOKEN` secret。
 
+Windows 上发布前使用 `run.cmd` 入口验证；POSIX shell 专属 release 用例在没有 shell 的 Windows 环境会明确跳过，不得记录为通过。
+
 ## 接入原则
 
 - 以目标项目事实为准，不把模板内容当成项目事实

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cowork-flow",
-  "version": "0.0.37",
+  "version": "0.0.39",
   "description": "CLI for installing and maintaining cowork-flow collaboration templates.",
   "type": "module",
   "bin": {

package/src/commands/init.js

@@ -1,4 +1,4 @@
-import { access, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { access, readFile } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
 
 import {
@@ -10,7 +10,8 @@ import { readPackageInfo } from '../lib/package-info.js';
 import {
   SUPPORTED_PLATFORMS,
   formatPlatformList,
-  parsePlatformSelection
+  parsePlatformSelection,
+  platformLabel
 } from '../lib/platforms.js';
 
 function parseInitArgs(args) {
@@ -107,19 +108,6 @@ async function resolveDeveloperName(options, prompt) {
   return { existing: false, name: normalizeDeveloperName(name) };
 }
 
-function platformLabel(platform) {
-  if (platform === 'codex') {
-    return 'Codex';
-  }
-  if (platform === 'opencode') {
-    return 'OpenCode';
-  }
-  if (platform === 'claude-code') {
-    return 'Claude Code';
-  }
-  return platform;
-}
-
 async function resolvePlatforms(options, selectPlatforms) {
   if (options.platforms.length > 0) {
     return parsePlatformSelection(options.platforms);
@@ -199,47 +187,71 @@ function initialIndexContent(name) {
 `;
 }
 
-async function initializeDeveloper(target, developer) {
+async function buildDeveloperActions(target, developer) {
   const workflowDir = join(target, '.cowork-flow');
   const developerFile = join(workflowDir, '.developer');
   const workspaceDir = join(workflowDir, 'workspace', developer.name);
   const journalFile = join(workspaceDir, 'journal-1.md');
   const indexFile = join(workspaceDir, 'index.md');
+  const actions = [];
 
-  await mkdir(workflowDir, { recursive: true });
   if (!developer.existing) {
-    await writeFile(
-      developerFile,
-      `name=${developer.name}\ninitialized_at=${new Date().toISOString()}\n`,
-      'utf8'
-    );
+    actions.push({
+      action: 'create',
+      source: null,
+      destination: developerFile,
+      relativePath: '.cowork-flow/.developer',
+      content: `name=${developer.name}\ninitialized_at=${new Date().toISOString()}\n`,
+      targetExists: false
+    });
   }
 
-  await mkdir(workspaceDir, { recursive: true });
   if (!await pathExists(journalFile)) {
-    await writeFile(journalFile, initialJournalContent(developer.name), 'utf8');
+    actions.push({
+      action: 'create',
+      source: null,
+      destination: journalFile,
+      relativePath: `.cowork-flow/workspace/${developer.name}/journal-1.md`,
+      content: initialJournalContent(developer.name),
+      targetExists: false
+    });
   }
   if (!await pathExists(indexFile)) {
-    await writeFile(indexFile, initialIndexContent(developer.name), 'utf8');
+    actions.push({
+      action: 'create',
+      source: null,
+      destination: indexFile,
+      relativePath: `.cowork-flow/workspace/${developer.name}/index.md`,
+      content: initialIndexContent(developer.name),
+      targetExists: false
+    });
   }
+  return actions;
 }
 
 export async function runInit(args, { io, prompt, selectPlatforms }) {
   return runInitWithOptions(args, { io, prompt, selectPlatforms });
 }
 
-export async function runInitWithOptions(args, { io, prompt, selectPlatforms }) {
+export async function runInitWithOptions(
+  args,
+  { io, prompt, selectPlatforms, fileSystem }
+) {
   const options = parseInitArgs(args);
   const platforms = await resolvePlatforms(options, selectPlatforms);
   const developer = await resolveDeveloperName(options, prompt);
   const packageInfo = await readPackageInfo();
+  const developerActions = developer.name
+    ? await buildDeveloperActions(options.target, developer)
+    : [];
   const plan = await buildInitPlan(options.target, {
+    additionalActions: developerActions,
     force: options.force,
     platforms,
     version: packageInfo.version
   });
 
-  await applyPlan(plan, { dryRun: options.dryRun });
+  await applyPlan(plan, { dryRun: options.dryRun, fileSystem });
   io.writeOut(summarizePlan(plan, options.dryRun));
   io.writeOut(`Platforms: ${formatPlatformList(platforms)}\n`);
 
@@ -254,7 +266,6 @@ export async function runInitWithOptions(args, { io, prompt, selectPlatforms })
     return 0;
   }
 
-  await initializeDeveloper(options.target, developer);
   if (developer.existing) {
     io.writeOut(`Developer already initialized: ${developer.name}\n`);
   } else {

package/src/commands/sync.js

@@ -25,7 +25,7 @@ function parseSyncArgs(args) {
   return options;
 }
 
-export async function runSync(args, { io }) {
+export async function runSync(args, { io, fileSystem }) {
   const options = parseSyncArgs(args);
   const packageInfo = await readPackageInfo();
   const platforms = await detectInstalledPlatforms(options.target);
@@ -35,7 +35,7 @@ export async function runSync(args, { io }) {
     version: packageInfo.version
   });
 
-  await applyPlan(plan, { dryRun: options.dryRun });
+  await applyPlan(plan, { dryRun: options.dryRun, fileSystem });
   io.writeOut(summarizePlan(plan, options.dryRun));
   io.writeOut(`Platforms: ${platforms.length > 0 ? formatPlatformList(platforms) : 'none'}\n`);
   return 0;

package/src/lib/asset-plan.js

@@ -0,0 +1,127 @@
+import { createHash } from 'node:crypto';
+import { readFile, stat } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+const VERSION_PATH = '.cowork-flow/.version';
+const MATERIALIZED_ACTIONS = new Set(['create', 'update']);
+
+function sha256(content) {
+  return createHash('sha256').update(content).digest('hex');
+}
+
+function normalizeRelativePath(value) {
+  const normalized = String(value).replaceAll('\\', '/');
+  if (
+    normalized.startsWith('/')
+    || normalized === '..'
+    || normalized.startsWith('../')
+    || normalized.includes('/../')
+  ) {
+    throw new Error(`Asset plan path must stay inside the target: ${value}`);
+  }
+  return normalized;
+}
+
+function targetPolicy(action) {
+  if (action === 'create') return 'create';
+  if (action === 'update') return 'replace';
+  if (action === 'delete') return 'delete';
+  return 'preserve';
+}
+
+function rollbackStrategy(action, targetExists) {
+  if (action === 'skip' || action === 'protected') return 'none';
+  if (targetExists || action === 'update' || action === 'delete') {
+    return 'restore-backup';
+  }
+  return 'remove-created';
+}
+
+async function readMode(action) {
+  try {
+    const path = action.source ?? action.destination;
+    if (!path) return null;
+    const stats = await stat(path);
+    return stats.mode & 0o777;
+  } catch (error) {
+    if (error && error.code === 'ENOENT') {
+      return null;
+    }
+    throw error;
+  }
+}
+
+async function enrichAction(rawAction) {
+  const relativePath = normalizeRelativePath(rawAction.relativePath);
+  const action = rawAction.action;
+  const targetExists = rawAction.targetExists
+    ?? (action === 'update' || action === 'delete');
+  let content = null;
+  let mode = rawAction.mode ?? null;
+
+  if (MATERIALIZED_ACTIONS.has(action)) {
+    if (rawAction.content !== undefined) {
+      content = Buffer.from(rawAction.content, 'utf8');
+      if (mode === null && targetExists) {
+        mode = await readMode(rawAction);
+      }
+    } else {
+      content = await readFile(rawAction.source, 'utf8');
+      if (mode === null) {
+        mode = await readMode(rawAction);
+      }
+    }
+  }
+
+  const sourceHash = content === null ? null : sha256(content);
+  const enriched = {
+    ...rawAction,
+    relativePath,
+    targetExists: Boolean(targetExists),
+    sourceHash,
+    mode,
+    targetPolicy: targetPolicy(action),
+    validation: {
+      sha256: sourceHash,
+      executable: mode !== null && (mode & 0o111) !== 0
+    },
+    rollback: {
+      strategy: rollbackStrategy(action, Boolean(targetExists))
+    }
+  };
+  return deepFreeze(enriched);
+}
+
+function actionOrder(left, right) {
+  const leftVersion = left.relativePath === VERSION_PATH;
+  const rightVersion = right.relativePath === VERSION_PATH;
+  if (leftVersion !== rightVersion) {
+    return leftVersion ? 1 : -1;
+  }
+  return left.relativePath.localeCompare(right.relativePath);
+}
+
+function deepFreeze(value) {
+  if (!value || typeof value !== 'object' || Object.isFrozen(value)) {
+    return value;
+  }
+  for (const child of Object.values(value)) {
+    deepFreeze(child);
+  }
+  return Object.freeze(value);
+}
+
+export function planActions(planOrActions) {
+  return Array.isArray(planOrActions) ? planOrActions : planOrActions.actions;
+}
+
+export async function createAssetPlan({ kind, targetDir, actions }) {
+  const enriched = await Promise.all(actions.map(enrichAction));
+  enriched.sort(actionOrder);
+  return deepFreeze({
+    schemaVersion: 1,
+    kind,
+    targetDir: resolve(targetDir),
+    actions: enriched
+  });
+}

package/src/lib/copy-template.js

@@ -1,9 +1,13 @@
-import { constants } from 'node:fs';
-import { access, chmod, copyFile, mkdir, readFile, readdir, rm, stat, writeFile } from 'node:fs/promises';
-import { dirname, join, relative } from 'node:path';
+import { constants } from 'node:fs';
+import { access, readFile, readdir } from 'node:fs/promises';
+import { join, relative } from 'node:path';
 
+import { createAssetPlan, planActions } from './asset-plan.js';
+import { hostRegistry } from './host-assets.js';
+import { applyAssetPlan } from './plan-applier.js';
 import { templateRoot } from './paths.js';
 import { shouldIncludeForPlatforms, skillDestinationForPlatform } from './platforms.js';
+import { skillRegistry } from './skill-registry.js';
 
 async function pathExists(path) {
   try {
@@ -63,26 +67,19 @@ export async function buildInitPlan(targetDir, options = {}) {
     actions.push({ action, source, destination, relativePath: file });
   }
 
-  // Inject per-platform skills directories from the canonical template/skills/.
-  const skillsSrc = join(templateRoot, 'skills');
-  if (await pathExists(skillsSrc)) {
-    const skillEntries = await readdir(skillsSrc, { withFileTypes: true });
-    for (const entry of skillEntries) {
-      if (!entry.isDirectory()) continue;
-      const skillName = entry.name;
-      for (const platform of platforms) {
-        const destBase = skillDestinationForPlatform(platform);
-        if (!destBase) continue;
-        const dest = join(targetDir, destBase, skillName, 'SKILL.md');
-        if (seen.has(dest)) continue;
-        seen.add(dest);
-        actions.push({
-          action: (await pathExists(dest)) ? 'skip' : 'create',
-          source: join(skillsSrc, skillName, 'SKILL.md'),
-          destination: dest,
-          relativePath: join(destBase, skillName, 'SKILL.md')
-        });
-      }
+  for (const entry of skillRegistry.publicEntries) {
+    for (const platform of platforms) {
+      const destBase = skillDestinationForPlatform(platform);
+      if (!destBase) continue;
+      const dest = join(targetDir, destBase, entry.id, 'SKILL.md');
+      if (seen.has(dest)) continue;
+      seen.add(dest);
+      actions.push({
+        action: (await pathExists(dest)) ? 'skip' : 'create',
+        source: join(templateRoot, entry.source),
+        destination: dest,
+        relativePath: join(destBase, entry.id, 'SKILL.md')
+      });
     }
   }
 
@@ -96,71 +93,36 @@ export async function buildInitPlan(targetDir, options = {}) {
     content: `${options.version}\n`
   });
 
-  return actions;
+  const additionalActions = options.additionalActions ?? [];
+  const overrides = new Set(
+    additionalActions.map((action) => action.destination)
+  );
+  return createAssetPlan({
+    kind: 'init',
+    targetDir,
+    actions: [
+      ...actions.filter((action) => !overrides.has(action.destination)),
+      ...additionalActions
+    ]
+  });
 }
 
-const PROTECTED_SYNC_FILES = new Set([
-  '.cowork-flow/config.yaml'
-]);
-
-const PROTECTED_SYNC_PREFIXES = [
-  '.cowork-flow/spec/',
-  '.cowork-flow/workspace/',
-  '.cowork-flow/tasks/',
-  '.cowork-flow/changes/',
-  '.cowork-flow/plans/'
-];
-
+const PROTECTED_SYNC_FILES = new Set(
+  hostRegistry.syncPolicy.protectedFiles
+);
+const PROTECTED_SYNC_PREFIXES = hostRegistry.syncPolicy.protectedPrefixes;
+const SAFE_SYNC_FILES = new Set(hostRegistry.syncPolicy.safeFiles);
 const SAFE_SYNC_PREFIXES = [
-  '.codex/',
-  '.opencode/',
-  '.claude/',
-  '.agents/skills/',
-  '.cowork-flow/'
+  ...hostRegistry.syncPolicy.safePrefixes,
+  ...hostRegistry.assetPrefixes,
+  ...hostRegistry.skillTargets.map((target) => `${target}/`)
 ];
-
-const SAFE_SYNC_FILES = new Set([
-  '.cowork-flow/.gitignore',
-  '.cowork-flow/.version',
-  '.cowork-flow/run',
-  '.cowork-flow/run.cmd',
-  '.cowork-flow/spec/contracts/workflow-state-templates.md'
-]);
-
-const OBSOLETE_SYNC_FILES = new Set([
-  '.cowork-flow/project-context.md',
-  '.cowork-flow/scripts/add_session.py',
-  '.cowork-flow/scripts/change.py',
-  '.cowork-flow/scripts/doctor.py',
-  '.cowork-flow/scripts/get_context.py',
-  '.cowork-flow/scripts/get_developer.py',
-  '.cowork-flow/scripts/init_developer.py',
-  '.cowork-flow/scripts/party_mode_v2.py',
-  '.cowork-flow/scripts/project_context.py',
-  '.cowork-flow/scripts/resume.py',
-  '.cowork-flow/scripts/subagent.py',
-  '.cowork-flow/scripts/task.py',
-  '.cowork-flow/scripts/common/active_task.py',
-  '.cowork-flow/scripts/common/archive_utils.py',
-  '.cowork-flow/scripts/common/coding_standards.py',
-  '.cowork-flow/scripts/common/config.py',
-  '.cowork-flow/scripts/common/developer.py',
-  '.cowork-flow/scripts/common/execution_context.py',
-  '.cowork-flow/scripts/common/files.py',
-  '.cowork-flow/scripts/common/gates.py',
-  '.cowork-flow/scripts/common/git_context.py',
-  '.cowork-flow/scripts/common/git_snapshot.py',
-  '.cowork-flow/scripts/common/paths.py',
-  '.cowork-flow/scripts/common/readiness.py',
-  '.cowork-flow/scripts/common/state_machine.py',
-  '.cowork-flow/scripts/common/task_utils.py',
-  '.cowork-flow/scripts/common/tdd_evidence.py',
-  '.cowork-flow/scripts/common/test_intent.py',
-  '.cowork-flow/scripts/common/validate_coding_standards.py',
-  '.cowork-flow/scripts/common/validate_implementation.py',
-  '.cowork-flow/scripts/common/validate_rules.py',
-  '.cowork-flow/spec/contracts/entry-contract.md'
-]);
+const MANAGED_BLOCK_FILES = new Set(
+  hostRegistry.syncPolicy.managedBlockFiles
+);
+const OBSOLETE_SYNC_FILES = new Set(
+  hostRegistry.syncPolicy.obsoleteFiles
+);
 
 const COWORK_FLOW_START = '<!-- COWORK-FLOW:START -->';
 const COWORK_FLOW_END = '<!-- COWORK-FLOW:END -->';
@@ -178,6 +140,7 @@ function isSafeSyncFile(relativePath) {
   const templatePath = toTemplatePath(relativePath);
   return SAFE_SYNC_FILES.has(templatePath)
     || SAFE_SYNC_PREFIXES.some((prefix) => templatePath.startsWith(prefix))
+    || hostRegistry.isKnownPlatformAsset(templatePath)
     || templatePath.endsWith('/.gitkeep');
 }
 
@@ -247,7 +210,7 @@ export async function buildSyncPlan(targetDir, options = {}) {
 
     const source = join(templateRoot, file);
     const exists = await pathExists(destination);
-    if (file === 'AGENTS.md' || file === 'CLAUDE.md') {
+    if (MANAGED_BLOCK_FILES.has(toTemplatePath(file))) {
       actions.push(await buildManagedBlockSyncAction({ source, destination, exists, options, relativePath: file }));
       continue;
     }
@@ -266,26 +229,49 @@ export async function buildSyncPlan(targetDir, options = {}) {
     }
   }
 
-  // Inject per-platform skills directories from the canonical template/skills/.
-  const skillsSrc = join(templateRoot, 'skills');
-  if (await pathExists(skillsSrc)) {
-    const skillEntries = await readdir(skillsSrc, { withFileTypes: true });
-    for (const entry of skillEntries) {
-      if (!entry.isDirectory()) continue;
-      const skillName = entry.name;
-      for (const platform of platforms) {
-        const destBase = skillDestinationForPlatform(platform);
-        if (!destBase) continue;
-        const dest = join(targetDir, destBase, skillName, 'SKILL.md');
-        if (seen.has(dest)) continue;
-        seen.add(dest);
-        const destExists = await pathExists(dest);
-        const safe = ['.agents/skills', '.claude/skills'].some((p) => dest.startsWith(join(targetDir, p)));
-        if (destExists && (safe || options.force)) {
-          actions.push({ action: 'update', source: join(skillsSrc, skillName, 'SKILL.md'), destination: dest, relativePath: join(destBase, skillName, 'SKILL.md') });
-        } else if (!destExists) {
-          actions.push({ action: 'create', source: join(skillsSrc, skillName, 'SKILL.md'), destination: dest, relativePath: join(destBase, skillName, 'SKILL.md') });
-        }
+  for (const entry of skillRegistry.publicEntries) {
+    for (const platform of platforms) {
+      const destBase = skillDestinationForPlatform(platform);
+      if (!destBase) continue;
+      const dest = join(targetDir, destBase, entry.id, 'SKILL.md');
+      if (seen.has(dest)) continue;
+      seen.add(dest);
+      const destExists = await pathExists(dest);
+      const safe = hostRegistry.skillTargets.some(
+        (target) => dest.startsWith(join(targetDir, target))
+      );
+      if (destExists && (safe || options.force)) {
+        actions.push({
+          action: 'update',
+          source: join(templateRoot, entry.source),
+          destination: dest,
+          relativePath: join(destBase, entry.id, 'SKILL.md')
+        });
+      } else if (!destExists) {
+        actions.push({
+          action: 'create',
+          source: join(templateRoot, entry.source),
+          destination: dest,
+          relativePath: join(destBase, entry.id, 'SKILL.md')
+        });
+      }
+    }
+  }
+
+  for (const entry of skillRegistry.entries) {
+    if (entry.status === 'active') {
+      continue;
+    }
+    for (const managedPath of entry.managedPaths) {
+      const relativePath = managedPath.slice(0, -1);
+      const destination = join(targetDir, relativePath);
+      if (await pathExists(destination)) {
+        actions.push({
+          action: 'delete',
+          source: null,
+          destination,
+          relativePath
+        });
       }
     }
   }
@@ -305,24 +291,19 @@ export async function buildSyncPlan(targetDir, options = {}) {
     content: `${options.version}\n`
   });
 
-  return actions;
+  return createAssetPlan({
+    kind: 'sync',
+    targetDir,
+    actions
+  });
 }
 
 export async function detectInstalledPlatforms(targetDir) {
-  const platforms = [];
-  if (await pathExists(join(targetDir, '.codex'))) {
-    platforms.push('codex');
-  }
-  if (await pathExists(join(targetDir, '.opencode'))) {
-    platforms.push('opencode');
-  }
-  if (await pathExists(join(targetDir, '.claude')) || await pathExists(join(targetDir, 'CLAUDE.md'))) {
-    platforms.push('claude-code');
-  }
-  return platforms;
+  return hostRegistry.detectInstalledPlatforms(targetDir, pathExists);
 }
 
-export function summarizePlan(actions, dryRun = false) {
+export function summarizePlan(plan, dryRun = false) {
+  const actions = planActions(plan);
   const counts = { create: 0, update: 0, skip: 0, protected: 0, delete: 0 };
   for (const action of actions) {
     counts[action.action] += 1;
@@ -335,27 +316,6 @@ export function summarizePlan(actions, dryRun = false) {
   return `${prefix}${createLabel}=${counts.create} ${updateLabel}=${counts.update} ${deleteLabel}=${counts.delete} skipped=${counts.skip} protected=${counts.protected}\n`;
 }
 
-export async function applyPlan(actions, options = {}) {
-  if (options.dryRun) {
-    return;
-  }
-
-  for (const item of actions) {
-    if (item.action === 'skip' || item.action === 'protected') {
-      continue;
-    }
-    if (item.action === 'delete') {
-      await rm(item.destination, { force: true });
-      continue;
-    }
-
-    await mkdir(dirname(item.destination), { recursive: true });
-    if (item.content !== undefined) {
-      await writeFile(item.destination, item.content, 'utf8');
-    } else {
-      await copyFile(item.source, item.destination);
-      const sourceStats = await stat(item.source);
-      await chmod(item.destination, sourceStats.mode & 0o777);
-    }
-  }
+export async function applyPlan(plan, options = {}) {
+  await applyAssetPlan(plan, options);
 }