cowork-flow 2.2.0 → 2.4.0

package/src/lib/host-assets.js

@@ -1,4 +1,4 @@
-import { readFileSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 
 import { packageRoot, templateRoot } from './paths.js';
@@ -37,6 +37,7 @@ const MANIFEST_KEYS = [
   'capabilityMatrix',
   'platforms',
   'excludedPrefixes',
+  'localization',
   'syncPolicy'
 ];
 const PLATFORM_KEYS = [
@@ -57,6 +58,7 @@ const SKILL_DISCOVERY_KEYS = ['scope', 'evidence', 'path', 'gates'];
 const SKILL_DISCOVERY_SCOPES = ['project'];
 const SYNC_POLICY_KEYS = [
   'protectedFiles',
+  'forceProtectedFiles',
   'protectedPrefixes',
   'safeFiles',
   'safePrefixes',
@@ -101,6 +103,7 @@ function aliasIndex(platforms) {
 function normalizedSyncPolicy(policy) {
   return {
     protectedFiles: policy.protectedFiles.map(normalizePath),
+    forceProtectedFiles: (policy.forceProtectedFiles ?? []).map(normalizePath),
     protectedPrefixes: policy.protectedPrefixes.map(normalizePath),
     safeFiles: policy.safeFiles.map(normalizePath),
     safePrefixes: policy.safePrefixes.map(normalizePath),
@@ -110,6 +113,27 @@ function normalizedSyncPolicy(policy) {
 }
 
 
+// A manifest without localization keeps every asset in the base template, which
+// is exactly the pre-localization behaviour.
+function normalizedLocalization(localization) {
+  const raw = localization ?? {
+    default: 'zh-CN',
+    supported: ['zh-CN', 'en-US'],
+    assets: {}
+  };
+  return {
+    default: raw.default,
+    supported: [...raw.supported],
+    assets: Object.fromEntries(
+      Object.entries(raw.assets).map(([language, assets]) => [
+        language,
+        assets.map(normalizePath)
+      ])
+    )
+  };
+}
+
+
 // Every lookup a registry closes over, built after the
 // manifest passes validation. The order here is the order
 // init/sync observe.
@@ -120,6 +144,7 @@ function buildHostIndex(manifest) {
   const aliases = aliasIndex(platforms);
   const platformIds = platforms.map((platform) => platform.id);
   const capabilityMatrix = normalizeCapabilityMatrix(manifest.capabilityMatrix);
+  const localization = normalizedLocalization(manifest.localization);
   const syncPolicy = normalizedSyncPolicy(manifest.syncPolicy);
   const assetPrefixes = unique(
     platforms.flatMap((platform) => platform.assetPrefixes)
@@ -140,10 +165,12 @@ function buildHostIndex(manifest) {
     aliases,
     platformIds,
     capabilityMatrix,
+    localization,
     syncPolicy,
     assetPrefixes,
     skillReadRoots,
     protectedFiles: new Set(syncPolicy.protectedFiles),
+    forceProtectedFiles: new Set(syncPolicy.forceProtectedFiles),
     safeFiles: new Set(syncPolicy.safeFiles),
     managedBlockFiles: new Set(syncPolicy.managedBlockFiles)
   };
@@ -172,7 +199,7 @@ function selectionRules(index) {
         const platformId = aliases.get(token);
         if (!platformId) {
           throw new Error(
-            `Unsupported platform: ${token}. Supported platforms: ${platformIds.join(', ')}`
+            `Unsupported host: ${token}. Supported hosts: ${platformIds.join(', ')}`
           );
         }
         selected.add(platformId);
@@ -180,7 +207,7 @@ function selectionRules(index) {
     }
     if (selected.size === 0) {
       throw new Error(
-        `Platform selection required. Run: cwf project init <target> --platform ${platformIds.join('|')}`
+        `Host selection required. Run: cwf project init [target] --host ${platformIds.join('|')}`
       );
     }
     return platformIds.filter((platformId) => selected.has(platformId));
@@ -226,6 +253,7 @@ function syncRules(index) {
   const {
     syncPolicy,
     protectedFiles,
+    forceProtectedFiles,
     safeFiles,
     managedBlockFiles,
     assetPrefixes,
@@ -250,6 +278,12 @@ function syncRules(index) {
       || syncPolicy.protectedPrefixes.some((prefix) => normalized.startsWith(prefix));
   }
 
+  // A force-protected file is created once and never replaced, even by
+  // `init --force` or `sync --force`.
+  function isForceProtectedSyncFile(relativePath) {
+    return forceProtectedFiles.has(normalizePath(relativePath));
+  }
+
   function isManagedBlockFile(relativePath) {
     return managedBlockFiles.has(normalizePath(relativePath));
   }
@@ -267,7 +301,13 @@ function syncRules(index) {
     });
   }
 
-  return { isSafeSyncFile, isProtectedSyncFile, isManagedBlockFile, obsoleteSyncFiles };
+  return {
+    isSafeSyncFile,
+    isProtectedSyncFile,
+    isForceProtectedSyncFile,
+    isManagedBlockFile,
+    obsoleteSyncFiles
+  };
 }
 
 
@@ -298,6 +338,7 @@ export function createHostRegistry(manifest) {
     platforms: index.platforms,
     platformIds: index.platformIds,
     capabilityMatrix: index.capabilityMatrix,
+    localization: index.localization,
     syncPolicy: index.syncPolicy,
     assetPrefixes: index.assetPrefixes,
     skillReadRoots: index.skillReadRoots,
@@ -323,6 +364,27 @@ export function createHostRegistry(manifest) {
     skillDestination(platformId) {
       return index.byId.get(platformId)?.skillReadRoot ?? null;
     },
+    // Canonical project-relative path for the asset's source. Non-default
+    // languages resolve only declared assets; everything else stays on the
+    // base template.
+    localizedSource(relativePath, language) {
+      const normalized = normalizePath(relativePath);
+      const selected = language ?? index.localization.default;
+      if (!index.localization.supported.includes(selected)) {
+        throw new Error(
+          `Unsupported language: ${selected}. Supported: ${index.localization.supported.join(', ')}`
+        );
+      }
+      const assets = index.localization.assets[selected] ?? [];
+      if (!assets.includes(normalized)) {
+        return normalized;
+      }
+      const localized = `locales/${selected}/${normalized}`;
+      if (!existsSync(join(templateRoot, ...localized.split('/')))) {
+        throw new Error(`Missing localized asset: ${localized}`);
+      }
+      return localized;
+    },
     // A declaration names a directory inside the package;
     // the absolute source dir is resolved once, here.
     platformPayload(platformId) {
@@ -337,6 +399,7 @@ export function createHostRegistry(manifest) {
     },
     isSafeSyncFile: sync.isSafeSyncFile,
     isProtectedSyncFile: sync.isProtectedSyncFile,
+    isForceProtectedSyncFile: sync.isForceProtectedSyncFile,
     isManagedBlockFile: sync.isManagedBlockFile,
     obsoleteSyncFiles: sync.obsoleteSyncFiles
   };
@@ -378,10 +441,59 @@ function validateManifest(manifest) {
     manifest.excludedPrefixes,
     'Host Asset Manifest excludedPrefixes'
   );
+  validateLocalization(manifest.localization);
   validateCapabilityMatrix(manifest.capabilityMatrix, allowed, platformIds);
   validateSyncPolicy(manifest.syncPolicy);
 }
 
+function validateLocalization(localization) {
+  if (localization === undefined) {
+    return;
+  }
+  if (!localization || typeof localization !== 'object' || Array.isArray(localization)) {
+    throw new Error('Host Asset Manifest localization must be an object');
+  }
+  assertKnownKeys(
+    localization,
+    ['default', 'supported', 'assets'],
+    'Host Asset Manifest localization'
+  );
+  validateRequiredString(
+    localization.default,
+    'Host Asset Manifest localization.default'
+  );
+  validateStringArray(
+    localization.supported,
+    'Host Asset Manifest localization.supported',
+    { unique: true }
+  );
+  if (!localization.supported.includes(localization.default)) {
+    throw new Error(
+      'Host Asset Manifest localization.default must be listed in localization.supported'
+    );
+  }
+  if (!localization.assets || typeof localization.assets !== 'object' || Array.isArray(localization.assets)) {
+    throw new Error('Host Asset Manifest localization.assets must be an object');
+  }
+  for (const [language, assets] of Object.entries(localization.assets)) {
+    if (!localization.supported.includes(language)) {
+      throw new Error(
+        `Host Asset Manifest localization.assets language is not supported: ${language}`
+      );
+    }
+    if (language === localization.default) {
+      throw new Error(
+        'Host Asset Manifest localization.assets must not override the default language'
+      );
+    }
+    validateStringArray(
+      assets,
+      `Host Asset Manifest localization.assets.${language}`,
+      { unique: true }
+    );
+  }
+}
+
 function validateCapabilityValues(values) {
   validateStringArray(
     values,
@@ -515,6 +627,9 @@ function validateSyncPolicy(syncPolicy) {
   }
   assertKnownKeys(syncPolicy, SYNC_POLICY_KEYS, 'Host Asset Manifest syncPolicy');
   for (const key of SYNC_POLICY_KEYS) {
+    if (key === 'forceProtectedFiles' && syncPolicy[key] === undefined) {
+      continue;
+    }
     validateStringArray(
       syncPolicy[key],
       `Host Asset Manifest syncPolicy.${key}`

package/src/lib/language.js

@@ -0,0 +1,162 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+export const DEFAULT_LANGUAGE = 'zh-CN';
+export const SUPPORTED_LANGUAGES = Object.freeze(['zh-CN', 'en-US']);
+
+const LANGUAGE_ALIASES = new Map([
+  ['zh', 'zh-CN'],
+  ['zh-cn', 'zh-CN'],
+  ['zh_cn', 'zh-CN'],
+  ['en', 'en-US'],
+  ['en-us', 'en-US'],
+  ['en_us', 'en-US']
+]);
+
+// The config is a flat YAML document; a top-level `language:` scalar is the
+// only place the install-time choice is recorded. A `#` starts a comment only
+// outside quotes and only after whitespace, matching the Python reader.
+const LANGUAGE_KEY_RE = /^language\s*:\s*(.*)$/;
+
+function stripInlineComment(value) {
+  let quote = '';
+  let escaped = false;
+  for (let index = 0; index < value.length; index += 1) {
+    const char = value[index];
+    if (escaped) {
+      escaped = false;
+    } else if (quote === '"' && char === '\\') {
+      escaped = true;
+    } else if (quote) {
+      if (char === quote) {
+        quote = '';
+      }
+    } else if (index === 0 && (char === '"' || char === "'")) {
+      quote = char;
+    } else if (char === '#' && (index === 0 || value[index - 1] === ' ' || value[index - 1] === '\t')) {
+      return value.slice(0, index).trimEnd();
+    }
+  }
+  return value;
+}
+
+function unquote(value) {
+  if (
+    value.length >= 2
+    && (value[0] === '"' || value[0] === "'")
+    && value[value.length - 1] === value[0]
+  ) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+
+export function normalizeLanguage(value) {
+  if (value === undefined || value === null) {
+    return null;
+  }
+  return LANGUAGE_ALIASES.get(String(value).trim().toLowerCase()) ?? null;
+}
+
+// Top-level `language:` lines only. Two keys, an empty value, a glued comment,
+// or trailing junk after a quoted value all mean the explicit setting cannot be
+// trusted; callers decide whether that is fatal (sync) or falls back (generation).
+export function readLanguageSetting(content) {
+  const entries = [];
+  for (const rawLine of String(content ?? '').split(/\r?\n/)) {
+    if (/^\s/.test(rawLine)) {
+      continue;
+    }
+    const match = LANGUAGE_KEY_RE.exec(rawLine);
+    if (match) {
+      entries.push(match[1]);
+    }
+  }
+  if (entries.length === 0) {
+    return { present: false, raw: null, duplicate: false };
+  }
+  if (entries.length > 1) {
+    return { present: true, raw: null, duplicate: true };
+  }
+  return {
+    present: true,
+    raw: unquote(stripInlineComment(entries[0].trim())).trim(),
+    duplicate: false
+  };
+}
+
+export function readLanguageValue(content) {
+  const setting = readLanguageSetting(content);
+  return setting.present ? setting.raw : null;
+}
+
+export function parseLanguage(content) {
+  return normalizeLanguage(readLanguageValue(content));
+}
+
+export async function readProjectLanguage(targetDir) {
+  const file = join(targetDir, '.cowork-flow', 'config.yaml');
+  let content;
+  try {
+    content = await readFile(file, 'utf8');
+  } catch (error) {
+    if (error && error.code === 'ENOENT') {
+      return {
+        file,
+        present: false,
+        configured: false,
+        valid: true,
+        duplicate: false,
+        raw: null,
+        language: DEFAULT_LANGUAGE
+      };
+    }
+    throw error;
+  }
+
+  const setting = readLanguageSetting(content);
+  const language = setting.duplicate ? null : normalizeLanguage(setting.raw);
+  return {
+    file,
+    present: true,
+    configured: setting.present,
+    valid: !setting.present || language !== null,
+    duplicate: setting.duplicate,
+    raw: setting.raw,
+    language: language ?? DEFAULT_LANGUAGE
+  };
+}
+
+// Planning commands must not silently fall back on a typo: the caller is about
+// to distribute assets for a language the project explicitly asked for.
+export async function readProjectLanguageStrict(targetDir) {
+  const info = await readProjectLanguage(targetDir);
+  if (info.configured && !info.valid) {
+    const detail = info.duplicate
+      ? 'duplicate language keys'
+      : `unsupported language ${JSON.stringify(info.raw)}`;
+    throw new Error(
+      `${detail} in ${info.file}; expected ${SUPPORTED_LANGUAGES.join(' or ')}`
+    );
+  }
+  return info;
+}
+
+// Write the chosen language into the config content that is about to be
+// installed. The template already declares the key; the fallback keeps a
+// hand-edited template from losing the choice.
+export function withLanguage(content, language) {
+  const canonical = normalizeLanguage(language);
+  if (!canonical) {
+    throw new Error(`Unsupported language: ${language}`);
+  }
+  const setting = readLanguageSetting(content);
+  if (setting.duplicate) {
+    throw new Error('Cannot rewrite a config with duplicate language keys');
+  }
+  const line = `language: "${canonical}"`;
+  if (setting.present) {
+    return content.replace(/^language\s*:.*$/m, line);
+  }
+  return `${content.replace(/\s*$/, '')}\n\n${line}\n`;
+}

package/template/.cowork-flow/.version

@@ -1 +1 @@
-2.2.0
+2.4.0

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

@@ -3,6 +3,14 @@
 #
 # All values have sensible defaults. Only override what you need.
 
+#-------------------------------------------------------------------------------
+# Language
+#-------------------------------------------------------------------------------
+
+# Output language for generated task and plan artifacts: zh-CN or en-US.
+# This file is never overwritten by project sync, including sync --force.
+language: "zh-CN"
+
 #-------------------------------------------------------------------------------
 # Codex Runtime
 #-------------------------------------------------------------------------------

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

@@ -133,10 +133,12 @@ def _print_create_result(result) -> None:
             file=sys.stderr,
         )
     if result.generated_anchor:
-        print(
-            f"  {colored('[OK]', Colors.GREEN)} "
+        message = (
             "Generated decision-anchor.md from plan"
+            if result.generated_anchor_from_plan
+            else "Created decision-anchor.md scaffold"
         )
+        print(f"  {colored('[OK]', Colors.GREEN)} {message}")
 
     print(
         colored(f"Created task: {dir_name}", Colors.GREEN),
@@ -150,7 +152,7 @@ def _print_next_steps() -> None:
     print("", file=sys.stderr)
     print(colored("Next steps:", Colors.BLUE), file=sys.stderr)
     print(
-        "  1. Create decision-anchor.md with requirements",
+        "  1. Fill in decision-anchor.md (a scaffold is created)",
         file=sys.stderr,
     )
     print(

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

@@ -31,11 +31,14 @@ CAPABILITY_STATUS_VALUES = (
     "experimental",
     "unsupported",
 )
-MANIFEST_KEYS = frozenset(("schemaVersion", "capabilityValues", "capabilityMatrix", "platforms", "excludedPrefixes", "syncPolicy"))
+MANIFEST_KEYS = frozenset(("schemaVersion", "capabilityValues", "capabilityMatrix", "platforms", "excludedPrefixes", "localization", "syncPolicy"))
 PLATFORM_KEYS = frozenset(("id", "displayName", "aliases", "detectAny", "assetPrefixes", "assetFiles", "skillReadRoot", "skillDiscovery", "adapterPath", "capabilities", "commandTargets", "payload"))
 SKILL_DISCOVERY_KEYS = frozenset(("scope", "path", "gates", "evidence"))
 SKILL_DISCOVERY_SCOPES = frozenset(("project",))
-SYNC_POLICY_KEYS = frozenset(("protectedFiles", "protectedPrefixes", "safeFiles", "safePrefixes", "managedBlockFiles", "obsoleteFiles"))
+SYNC_POLICY_KEYS = frozenset(("protectedFiles", "forceProtectedFiles", "protectedPrefixes", "safeFiles", "safePrefixes", "managedBlockFiles", "obsoleteFiles"))
+LOCALIZATION_KEYS = frozenset(("default", "supported", "assets"))
+DEFAULT_LANGUAGE = "zh-CN"
+SUPPORTED_LANGUAGES = ("zh-CN", "en-US")
 COMMAND_TARGET_KEYS = frozenset(("config", "format", "target"))
 COMMAND_TARGET_FORMATS = frozenset(("json", "toml", "yaml"))
 CAPABILITY_DECLARATION_KEYS = frozenset(("status", "fallback"))
@@ -108,6 +111,7 @@ class HostPlatform:
 @dataclass(frozen=True)
 class SyncPolicy:
     protected_files: tuple[str, ...]
+    force_protected_files: tuple[str, ...]
     protected_prefixes: tuple[str, ...]
     safe_files: tuple[str, ...]
     safe_prefixes: tuple[str, ...]
@@ -115,6 +119,19 @@ class SyncPolicy:
     obsolete_files: tuple[str, ...]
 
 
+@dataclass(frozen=True)
+class Localization:
+    """Language-specific asset overrides.
+
+    The base template always carries the default language. A non-default
+    language may override a declared asset from `locales/<language>/`.
+    """
+
+    default: str
+    supported: tuple[str, ...]
+    assets: dict[str, tuple[str, ...]]
+
+
 @dataclass(frozen=True)
 class HostManifest:
     schema_version: int
@@ -123,6 +140,7 @@ class HostManifest:
     capability_matrix: dict[str, dict[str, CapabilityDeclaration]]
     platforms: tuple[HostPlatform, ...]
     excluded_prefixes: tuple[str, ...]
+    localization: Localization
     sync_policy: SyncPolicy
 
     @property
@@ -195,6 +213,19 @@ def validate_host_assets(
     if not (root / SCHEMA_PATH).is_file():
         errors.append(f"missing host asset schema: {root / SCHEMA_PATH}")
 
+    # Locale sources live in the package template. An installed project keeps
+    # only the resolved canonical path, so absence of `locales/` is normal and
+    # must not turn into a host-asset error.
+    if (root / "locales").is_dir():
+        for language, assets in manifest.localization.assets.items():
+            for asset in assets:
+                if not (root / asset).is_file():
+                    errors.append(f"missing localized base asset: {asset}")
+                if not (root / "locales" / language / asset).is_file():
+                    errors.append(
+                        f"missing localized asset: locales/{language}/{asset}"
+                    )
+
     selected_platforms: list[HostPlatform] = []
     selected_ids = (
         manifest.platform_ids
@@ -388,8 +419,13 @@ def _build_manifest(raw: dict[str, Any]) -> HostManifest:
         capability_matrix=capability_matrix,
         platforms=platforms,
         excluded_prefixes=_string_tuple(raw.get("excludedPrefixes"), "excludedPrefixes"),
+        localization=_build_localization(raw.get("localization")),
         sync_policy=SyncPolicy(
             protected_files=_string_tuple(sync_raw.get("protectedFiles"), "syncPolicy.protectedFiles"),
+            force_protected_files=_string_tuple(
+                sync_raw.get("forceProtectedFiles", []),
+                "syncPolicy.forceProtectedFiles",
+            ),
             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"),
@@ -398,6 +434,39 @@ def _build_manifest(raw: dict[str, Any]) -> HostManifest:
         ),
     )
 
+
+def _build_localization(raw: object) -> Localization:
+    if raw is None:
+        return Localization(
+            default=DEFAULT_LANGUAGE,
+            supported=SUPPORTED_LANGUAGES,
+            assets={},
+        )
+    if not isinstance(raw, dict):
+        raise HostManifestError("localization must be an object")
+    _reject_unknown_fields(raw, LOCALIZATION_KEYS, "localization")
+    default = raw.get("default")
+    if not isinstance(default, str) or not default.strip():
+        raise HostManifestError("localization.default must be a non-empty string")
+    supported = _string_tuple(raw.get("supported"), "localization.supported")
+    if default not in supported:
+        raise HostManifestError("localization.default must be listed in localization.supported")
+    assets_raw = raw.get("assets")
+    if not isinstance(assets_raw, dict):
+        raise HostManifestError("localization.assets must be an object")
+    assets: dict[str, tuple[str, ...]] = {}
+    for language, paths in assets_raw.items():
+        if language not in supported:
+            raise HostManifestError(
+                f"localization.assets language is not supported: {language}"
+            )
+        if language == default:
+            raise HostManifestError(
+                "localization.assets must not override the default language"
+            )
+        assets[language] = _string_tuple(paths, f"localization.assets.{language}")
+    return Localization(default=default, supported=supported, assets=assets)
+
 def _build_capability_matrix(
     raw: object,
     allowed: tuple[str, ...],

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

@@ -3,6 +3,7 @@
 
 from __future__ import annotations
 
+import re
 from pathlib import Path
 
 from infra.paths import DIR_WORKFLOW, get_repo_root
@@ -18,9 +19,24 @@ DEFAULT_PARTY_MODE_V2_MAX_DRIFT_WARNINGS = 2
 DEFAULT_PARTY_MODE_V2_FRESH_CONTEXT_PER_ROUND = True
 DEFAULT_PARTY_MODE_V2_REQUIRE_CURRENT_ROUND_ONLY = True
 
+DEFAULT_LANGUAGE = "zh-CN"
+SUPPORTED_LANGUAGES = ("zh-CN", "en-US")
+LANGUAGE_ALIASES = {
+    "zh": "zh-CN",
+    "zh-cn": "zh-CN",
+    "zh_cn": "zh-CN",
+    "en": "en-US",
+    "en-us": "en-US",
+    "en_us": "en-US",
+}
+
 CONFIG_FILE = "config.yaml"
 
 
+class UnsupportedLanguageError(ValueError):
+    """The config declares a language the runtime does not support."""
+
+
 def _unquote(value: str) -> str:
     if len(value) >= 2 and value[0] == value[-1] and value[0] in ("'", '"'):
         return value[1:-1]
@@ -117,6 +133,75 @@ def _load_config(repo_root: Path | None = None) -> dict:
         return {}
 
 
+def normalize_language(value: object) -> str | None:
+    """Canonical language for a supported value, otherwise None."""
+    if not isinstance(value, str):
+        return None
+    return LANGUAGE_ALIASES.get(value.strip().lower())
+
+
+_LANGUAGE_KEY_RE = re.compile(r"^language\s*:\s*(.*)$")
+
+
+def _read_language_setting(
+    repo_root: Path | None = None,
+) -> tuple[str | None, bool, bool]:
+    """The explicit top-level language scalar.
+
+    Returns `(raw, present, duplicate)`. Only top-level `language:` lines count.
+    Two keys, an empty value, a glued comment, or trailing junk are left for
+    `normalize_language` to reject, matching the Node reader.
+    """
+    config_file = _get_config_path(repo_root)
+    try:
+        content = config_file.read_text(encoding="utf-8")
+    except (OSError, IOError):
+        return None, False, False
+
+    entries: list[str] = []
+    for raw_line in content.splitlines():
+        if raw_line.startswith((" ", "\t")):
+            continue
+        match = _LANGUAGE_KEY_RE.match(raw_line)
+        if match:
+            entries.append(match.group(1))
+    if not entries:
+        return None, False, False
+    if len(entries) > 1:
+        return None, True, True
+    raw = _unquote(_strip_comment(entries[0].strip())).strip()
+    return raw, True, False
+
+
+def get_language(
+    repo_root: Path | None = None,
+    *,
+    strict: bool = False,
+) -> str:
+    """Task/plan artifact language from the project config.
+
+    A missing file or key yields the default. An explicit unsupported value or
+    duplicate `language` keys raises when strict is set; runtime generation uses
+    the non-strict form so a config typo cannot block task creation.
+    """
+    raw, present, duplicate = _read_language_setting(repo_root)
+    if not present:
+        return DEFAULT_LANGUAGE
+    canonical = None if duplicate else normalize_language(raw)
+    if canonical is not None:
+        return canonical
+    if strict:
+        detail = (
+            "duplicate language keys"
+            if duplicate
+            else f"unsupported language {raw!r}"
+        )
+        raise UnsupportedLanguageError(
+            detail + "; expected one of: " + ", ".join(SUPPORTED_LANGUAGES)
+        )
+    return DEFAULT_LANGUAGE
+
+
 
 def get_hooks(event: str, repo_root: Path | None = None) -> list[str]:
     """Hook commands declared for one lifecycle event; empty when none."""