cowork-flow 2.2.0 → 2.4.0

package/presets/zcode/.zcode-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "cowork-flow",
-  "version": "2.2.0",
+  "version": "2.4.0",
   "description": "AI 协作工作流引擎：任务生命周期、子代理调度、门禁与状态注入。将 cowork-flow 的完整工作流带入 ZCode。",
   "author": {
     "name": "fishlikewater",

package/presets/zcode/skills/cowork-flow-bootstrap/SKILL.md

@@ -17,12 +17,18 @@ workflow entry `./.cowork-flow/run`).
 
 ## No runtime: offer the install
 
-Tell the user this repository has no cowork-flow runtime, then offer:
+Tell the user this repository has no cowork-flow runtime, then offer (replace
+`<host>` with the host you are running in: `codex`, `claude-code`, `opencode`,
+`zcode`, `qoder`, `kimi-code`, or `dsh`):
 
 ```bash
-npx cowork-flow project init .
+npx cowork-flow project init --host <host>
 ```
 
+The default artifact language is `zh-CN`. When the user asks for English task or
+plan artifacts, append `--language en-US`. An existing
+`.cowork-flow/config.yaml` remains authoritative.
+
 After init the project carries its own Skills (`.agents/skills/`), the task
 runtime (`.cowork-flow/`), and the workflow entry `./.cowork-flow/run task next`.
 Resume the work through that entry.

package/src/cli.js

@@ -149,7 +149,7 @@ async function defaultSelectPlatforms({ message, choices, defaultSelected = [] }
       const action = applyPickerKey(state, text, key, choices);
       if (action?.outcome === 'cancel') {
         cleanup();
-        reject(new Error('Platform selection cancelled'));
+        reject(new Error('Host selection cancelled'));
         return;
       }
       if (action?.outcome === 'confirm') {

package/src/commands/init.js

@@ -1,9 +1,12 @@
+import { execFile } from 'node:child_process';
 import { access, readFile } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
+import { promisify } from 'node:util';
 
 import {
   applyPlan,
   buildInitPlan,
+  detectInstalledPlatforms,
   summarizePlan
 } from '../lib/copy-template.js';
 import { readPackageInfo } from '../lib/package-info.js';
@@ -14,6 +17,16 @@ import {
   platformLabel
 } from '../lib/platforms.js';
 import { parseFlags, UsageError } from '../lib/cli-flags.js';
+import {
+  DEFAULT_LANGUAGE,
+  SUPPORTED_LANGUAGES,
+  normalizeLanguage,
+  readProjectLanguage,
+  withLanguage
+} from '../lib/language.js';
+import { templateRoot } from '../lib/paths.js';
+
+const execFileAsync = promisify(execFile);
 
 // The manifest layer reports a plain Error; re-thrown as a
 // usage error so a bad host name exits with the
@@ -29,15 +42,20 @@ function parsePlatformSelectionOrUsage(values) {
 function parseInitArgs(args) {
   const { flags, positionals } = parseFlags(args, {
     boolean: ['--dry-run', '--force'],
-    value: ['--platform', '--platforms', '--developer'],
-    repeatable: ['--platform', '--platforms'],
+    value: ['--host', '--platform', '--platforms', '--developer', '--language'],
+    repeatable: ['--host', '--platform', '--platforms'],
     positional: { min: 0, max: 1, name: '[target]' }
   });
   return {
     developer: flags['--developer'] ?? null,
     dryRun: Boolean(flags['--dry-run']),
     force: Boolean(flags['--force']),
-    platforms: [...(flags['--platform'] ?? []), ...(flags['--platforms'] ?? [])],
+    language: flags['--language'] ?? null,
+    platforms: [
+      ...(flags['--host'] ?? []),
+      ...(flags['--platform'] ?? []),
+      ...(flags['--platforms'] ?? [])
+    ],
     target: positionals[0] === undefined ? process.cwd() : resolve(positionals[0])
   };
 }
@@ -57,7 +75,7 @@ async function pathExists(path) {
 function normalizeDeveloperName(value) {
   const name = String(value ?? '').trim();
   if (!name) {
-    throw new UsageError('Developer name required. Run: cwf project init <target> --developer <name>');
+    throw new UsageError('Developer name required. Run: cwf project init [target] --developer <name>');
   }
   if (/[\\/]/.test(name)) {
     throw new UsageError('Developer name must not contain path separators');
@@ -65,6 +83,32 @@ function normalizeDeveloperName(value) {
   return name;
 }
 
+function normalizeGitDeveloper(value) {
+  const name = String(value ?? '').trim();
+  if (!name || /[\\/]/.test(name) || (name.startsWith('<') && name.endsWith('>'))) {
+    return null;
+  }
+  return name;
+}
+
+// `git config user.name` reads the local repository first and falls back to the
+// global config, which is the "nearest identity" this command wants. A missing
+// binary, an unset value, or a directory that vanishes under us all mean "no
+// git identity", never a failed init.
+async function readGitDeveloper(target) {
+  const cwd = await pathExists(target) ? target : process.cwd();
+  try {
+    const { stdout } = await execFileAsync('git', ['config', 'user.name'], {
+      cwd,
+      timeout: 5000,
+      windowsHide: true
+    });
+    return normalizeGitDeveloper(stdout);
+  } catch {
+    return null;
+  }
+}
+
 async function readExistingDeveloper(target) {
   const developerFile = join(target, '.cowork-flow', '.developer');
   if (!await pathExists(developerFile)) {
@@ -78,19 +122,30 @@ async function readExistingDeveloper(target) {
 async function resolveDeveloperName(options, prompt) {
   const existing = await readExistingDeveloper(options.target);
   if (existing) {
-    return { existing: true, name: existing };
+    return { existing: true, name: existing, source: 'existing' };
+  }
+
+  if (options.developer) {
+    return { existing: false, name: normalizeDeveloperName(options.developer), source: 'flag' };
   }
 
-  if (options.dryRun && !options.developer) {
-    return { existing: false, name: null };
+  const gitName = await readGitDeveloper(options.target);
+
+  if (options.dryRun) {
+    return { existing: false, name: gitName, source: gitName ? 'git' : null };
   }
 
-  let name = options.developer;
-  if (!name && typeof prompt === 'function') {
-    name = await prompt('Developer name: ');
+  if (typeof prompt === 'function') {
+    const answer = await prompt(`Developer name${gitName ? ` [${gitName}]` : ''}: `);
+    const typed = String(answer ?? '').trim();
+    return {
+      existing: false,
+      name: normalizeDeveloperName(typed || gitName),
+      source: typed ? 'prompt' : 'git'
+    };
   }
 
-  return { existing: false, name: normalizeDeveloperName(name) };
+  return { existing: false, name: normalizeDeveloperName(gitName), source: 'git' };
 }
 
 async function resolvePlatforms(options, selectPlatforms) {
@@ -98,10 +153,17 @@ async function resolvePlatforms(options, selectPlatforms) {
     return parsePlatformSelectionOrUsage(options.platforms);
   }
 
+  // Reuse the same marker-based detection `project sync` uses, so init and sync
+  // agree on what "this project already uses" means.
+  const detected = await detectInstalledPlatforms(options.target);
+  if (detected.length > 0) {
+    return detected;
+  }
+
   let selected = null;
   if (typeof selectPlatforms === 'function') {
     selected = await selectPlatforms({
-      message: 'Select platforms to set up',
+      message: 'Select hosts to set up',
       choices: SUPPORTED_PLATFORMS.map((platform) => ({
         label: platformLabel(platform),
         value: platform
@@ -112,6 +174,104 @@ async function resolvePlatforms(options, selectPlatforms) {
   return parsePlatformSelectionOrUsage(selected);
 }
 
+function normalizeLanguageOrUsage(value) {
+  const language = normalizeLanguage(value);
+  if (!language) {
+    throw new UsageError(
+      `Unsupported language: ${value}. Supported: ${SUPPORTED_LANGUAGES.join(', ')}`
+    );
+  }
+  return language;
+}
+
+// An existing config is authoritative: the choice is never re-prompted or
+// rewritten, even by --force. A missing config prompts once, with zh-CN as the
+// default for both non-interactive and dry-run runs.
+async function resolveLanguage(options, prompt) {
+  const requested = options.language
+    ? normalizeLanguageOrUsage(options.language)
+    : null;
+  const existing = await readProjectLanguage(options.target);
+  if (existing.present) {
+    return {
+      existing: true,
+      configured: existing.configured,
+      language: existing.language,
+      valid: existing.valid,
+      raw: existing.raw,
+      requested,
+      source: 'existing'
+    };
+  }
+
+  if (requested) {
+    return {
+      existing: false,
+      language: requested,
+      requested,
+      source: 'flag'
+    };
+  }
+
+  if (options.dryRun || typeof prompt !== 'function') {
+    return {
+      existing: false,
+      language: DEFAULT_LANGUAGE,
+      requested,
+      source: 'default'
+    };
+  }
+
+  const answer = String(
+    await prompt(`Project language (${SUPPORTED_LANGUAGES.join('/')}) [${DEFAULT_LANGUAGE}]: `) ?? ''
+  ).trim();
+  return {
+    existing: false,
+    language: normalizeLanguageOrUsage(answer || DEFAULT_LANGUAGE),
+    requested,
+    source: answer ? 'prompt' : 'default'
+  };
+}
+
+function emitLanguageWarnings(io, language) {
+  if (!language.existing) {
+    return;
+  }
+  if (!language.valid) {
+    io.writeErr(
+      `Warning: unsupported language ${JSON.stringify(language.raw)} in .cowork-flow/config.yaml; using ${language.language}. Edit the file to change it.\n`
+    );
+    return;
+  }
+  if (language.requested && !language.configured) {
+    io.writeErr(
+      `Warning: .cowork-flow/config.yaml has no language setting; using ${language.language}. Add language: ${language.requested} and run cwf project sync to switch.\n`
+    );
+    return;
+  }
+  if (language.requested && language.requested !== language.language) {
+    io.writeErr(
+      `Warning: existing .cowork-flow/config.yaml language ${language.language} wins over --language ${language.requested}.\n`
+    );
+  }
+}
+
+async function buildConfigActions(target, language, existing) {
+  if (existing) {
+    return [];
+  }
+  const source = join(templateRoot, '.cowork-flow', 'config.yaml');
+  const content = withLanguage(await readFile(source, 'utf8'), language);
+  return [{
+    action: 'create',
+    source,
+    destination: join(target, '.cowork-flow', 'config.yaml'),
+    relativePath: '.cowork-flow/config.yaml',
+    content,
+    targetExists: false
+  }];
+}
+
 
 async function buildDeveloperActions(target, developer) {
   const workflowDir = join(target, '.cowork-flow');
@@ -142,27 +302,43 @@ export async function runInitWithOptions(
 ) {
   const options = parseInitArgs(args);
   const platforms = await resolvePlatforms(options, selectPlatforms);
+  const language = await resolveLanguage(options, prompt);
+  emitLanguageWarnings(io, language);
   const developer = await resolveDeveloperName(options, prompt);
   const packageInfo = await readPackageInfo();
   const developerActions = developer.name
     ? await buildDeveloperActions(options.target, developer)
     : [];
+  const configActions = await buildConfigActions(
+    options.target,
+    language.language,
+    language.existing
+  );
   const plan = await buildInitPlan(options.target, {
-    additionalActions: developerActions,
+    additionalActions: [...developerActions, ...configActions],
     force: options.force,
+    language: language.language,
     platforms,
     version: packageInfo.version
   });
 
   await applyPlan(plan, { dryRun: options.dryRun, fileSystem });
   io.writeOut(summarizePlan(plan, options.dryRun));
-  io.writeOut(`Platforms: ${formatPlatformList(platforms)}\n`);
+  io.writeOut(`Hosts: ${formatPlatformList(platforms)}\n`);
 
   if (options.dryRun) {
     if (developer.existing) {
       io.writeOut(`dry-run preserve-existing=.cowork-flow/.developer for developer ${developer.name}\n`);
     } else if (developer.name) {
-      io.writeOut(`dry-run would-create=.cowork-flow/.developer for developer ${developer.name}\n`);
+      const source = developer.source === 'git' ? ' (from git user.name)' : '';
+      io.writeOut(`dry-run would-create=.cowork-flow/.developer for developer ${developer.name}${source}\n`);
+    } else {
+      io.writeOut('dry-run would-skip=.cowork-flow/.developer (no developer identity; pass --developer)\n');
+    }
+    if (language.existing) {
+      io.writeOut(`dry-run preserve-existing=.cowork-flow/config.yaml for language ${language.language}\n`);
+    } else {
+      io.writeOut(`dry-run would-create=.cowork-flow/config.yaml for language ${language.language}\n`);
     }
     io.writeOut('Next: update AGENTS.md and .cowork-flow/config.yaml for this project.\n');
     return 0;
@@ -171,7 +347,15 @@ export async function runInitWithOptions(
   if (developer.existing) {
     io.writeOut(`Developer already initialized: ${developer.name}\n`);
   } else {
-    io.writeOut(`Developer initialized: ${developer.name}\n`);
+    const source = developer.source === 'git' ? ' (from git user.name)' : '';
+    io.writeOut(`Developer initialized: ${developer.name}${source}\n`);
+  }
+  if (language.existing) {
+    const missing = language.configured ? '' : ' (default; no language key)';
+    io.writeOut(`Language already initialized: ${language.language}${missing}\n`);
+  } else {
+    const source = language.source === 'default' ? ' (default)' : '';
+    io.writeOut(`Language initialized: ${language.language}${source}\n`);
   }
   io.writeOut('Next: update AGENTS.md and .cowork-flow/config.yaml for this project.\n');
   return 0;

package/src/commands/registry.js

@@ -35,7 +35,7 @@ const FLAG_HELP = {
 const flag = (name) => ({ name, kind: 'boolean', description: FLAG_HELP[name] });
 const valueFlag = (name, valueName) => ({ name, kind: 'value', valueName, description: FLAG_HELP[name] });
 
-const PLATFORM_TOKENS = `${hostRegistry.platformIds.join('|')}|all`;
+const HOST_TOKENS = `${hostRegistry.platformIds.join('|')}|all`;
 const HOST_NOTE = `Hosts: ${Object.entries(HOST_COMPONENTS)
   .map(([id, host]) => `${id} (${Object.keys(host.components).join(', ')})`)
   .join('; ')}.`;
@@ -51,18 +51,21 @@ export const COMMANDS = [
   {
     path: ['project', 'init'],
     summary: 'Copy the cowork-flow template into a project',
-    usage: `project init [target] --platform <${PLATFORM_TOKENS}> [--developer <name>] [--dry-run] [--force]`,
+    usage: `project init [target] --host <${HOST_TOKENS}> [--developer <name>] [--language <zh-CN|en-US>] [--dry-run] [--force]`,
     flags: [
-      { name: '--platform', kind: 'value', valueName: 'host', repeatable: true, description: 'Host to set the project up for; repeatable and comma-separated' },
-      { name: '--platforms', kind: 'value', valueName: 'host', repeatable: true, description: 'Alias of --platform' },
-      { name: '--developer', kind: 'value', valueName: 'name', description: 'Developer name recorded in .cowork-flow/.developer' },
+      { name: '--host', kind: 'value', valueName: 'host', repeatable: true, description: 'Host to set the project up for; repeatable and comma-separated, auto-detected when omitted' },
+      { name: '--platform', kind: 'value', valueName: 'host', repeatable: true, description: 'Alias of --host' },
+      { name: '--platforms', kind: 'value', valueName: 'host', repeatable: true, description: 'Alias of --host' },
+      { name: '--developer', kind: 'value', valueName: 'name', description: 'Developer name recorded in .cowork-flow/.developer; falls back to git user.name' },
+      { name: '--language', kind: 'value', valueName: 'language', description: 'Output language for task and plan artifacts; accepts zh-CN or en-US (default: zh-CN)' },
       flag('--dry-run'),
       flag('--force')
     ],
     positional: { min: 0, max: 1, name: '[target]' },
     examples: [
-      'cwf project init . --platform codex --developer alice',
-      'cwf project init ./my-project --platform all --dry-run'
+      'cwf project init --host codex --developer alice',
+      'cwf project init --host codex --developer alice --language en-US',
+      'cwf project init ./my-project --host all --dry-run'
     ],
     run: (args, context) => runInit(args, context)
   },

package/src/commands/source-refresh.js

@@ -9,6 +9,7 @@ import {
   formatReadinessReport,
   summarizePlan
 } from '../lib/copy-template.js';
+import { readProjectLanguageStrict } from '../lib/language.js';
 
 import { parseFlags } from '../lib/cli-flags.js';
 
@@ -25,7 +26,10 @@ function parseSourceRefreshArgs(args) {
 
 export async function runSourceRefresh(args, { io, fileSystem } = {}) {
   const options = parseSourceRefreshArgs(args);
-  const plan = await buildSourceCheckoutRefreshPlan(options.target);
+  const language = await readProjectLanguageStrict(options.target);
+  const plan = await buildSourceCheckoutRefreshPlan(options.target, {
+    language: language.language
+  });
 
   await applyPlan(plan, { dryRun: options.dryRun, fileSystem });
   io.writeOut(summarizePlan(plan, options.dryRun));

package/src/commands/sync.js

@@ -12,6 +12,7 @@ import {
 } from '../lib/copy-template.js';
 import { readPackageInfo } from '../lib/package-info.js';
 import { formatPlatformList } from '../lib/platforms.js';
+import { readProjectLanguageStrict } from '../lib/language.js';
 import { parseFlags } from '../lib/cli-flags.js';
 
 function parseSyncArgs(args) {
@@ -29,9 +30,11 @@ function parseSyncArgs(args) {
 export async function runSync(args, { io, fileSystem }) {
   const options = parseSyncArgs(args);
   const packageInfo = await readPackageInfo();
+  const language = await readProjectLanguageStrict(options.target);
   const platforms = await detectInstalledPlatforms(options.target);
   const plan = await buildSyncPlan(options.target, {
     force: options.force,
+    language: language.language,
     platforms,
     version: packageInfo.version
   });
@@ -43,6 +46,6 @@ export async function runSync(args, { io, fileSystem }) {
     const readiness = await buildReadinessReport(plan, { fileSystem });
     io.writeOut(formatReadinessReport(readiness));
   }
-  io.writeOut(`Platforms: ${platforms.length > 0 ? formatPlatformList(platforms) : 'none'}\n`);
+  io.writeOut(`Hosts: ${platforms.length > 0 ? formatPlatformList(platforms) : 'none'}\n`);
   return 0;
 }

package/src/lib/copy-template.js

@@ -153,13 +153,17 @@ async function appendSkillReadRootActions(actions, {
   }
 }
 
+// The source checkout's `.cowork-flow/spec` tree is a mirror of the template,
+// not a downstream project's spec tree: project-owned directories are framework
+// content here too, so dev refresh rewrites every spec directory and keeps only
+// task/plan state and the project config protected.
 function isSourceCheckoutProtected(relativePath) {
   const normalized = toTemplatePath(relativePath);
   if (hostRegistry.syncPolicy.protectedFiles.includes(normalized)) {
     return true;
   }
   return hostRegistry.syncPolicy.protectedPrefixes
-    .filter((prefix) => prefix !== '.cowork-flow/spec/')
+    .filter((prefix) => !prefix.startsWith('.cowork-flow/spec/'))
     .some((prefix) => normalized.startsWith(prefix))
     || normalized.startsWith('.cowork-flow/.runtime/');
 }
@@ -196,12 +200,16 @@ export async function buildInitPlan(targetDir, options = {}) {
       continue;
     }
 
-    const source = join(templateRoot, file);
+    const source = join(
+      templateRoot,
+      ...hostRegistry.localizedSource(templatePath, options.language).split('/')
+    );
     const destination = join(targetDir, file);
     seen.add(destination);
     const exists = await pathExists(destination);
+    const forceProtected = hostRegistry.isForceProtectedSyncFile(templatePath);
     const action = exists
-      ? (options.force && templatePath !== '.cowork-flow/.developer' ? 'update' : 'skip')
+      ? (forceProtected ? 'protected' : (options.force && templatePath !== '.cowork-flow/.developer' ? 'update' : 'skip'))
       : 'create';
     actions.push({ action, source, destination, relativePath: file });
   }
@@ -448,7 +456,10 @@ export async function buildSourceCheckoutRefreshPlan(targetDir, options = {}) {
     if (!shouldIncludeSourceCheckoutRuntimeFile(templatePath)) {
       continue;
     }
-    const source = join(templateRoot, file);
+    const source = join(
+      templateRoot,
+      ...hostRegistry.localizedSource(templatePath, options.language).split('/')
+    );
     const destination = join(targetDir, file);
     seen.add(destination);
     const exists = await pathExists(destination);
@@ -508,12 +519,19 @@ async function planSyncFile(file, { targetDir, options, platforms, seen }) {
     return null;
   }
 
-  const source = join(templateRoot, file);
+  const source = join(
+    templateRoot,
+    ...hostRegistry.localizedSource(file, options.language).split('/')
+  );
   const exists = await pathExists(destination);
   if (hostRegistry.isManagedBlockFile(file)) {
     return await buildManagedBlockSyncAction({ source, destination, exists, options, relativePath: file });
   }
 
+  if (exists && hostRegistry.isForceProtectedSyncFile(file)) {
+    return { action: 'protected', source, destination, relativePath: file };
+  }
+
   const protectedFile = hostRegistry.isProtectedSyncFile(file) && !options.force && exists;
   const safeFile = hostRegistry.isSafeSyncFile(file);