cc-devflow 4.4.1 → 4.5.0

package/lib/skill-runtime/__tests__/cli-bootstrap.integration.test.js

@@ -15,10 +15,14 @@ const REPO_ROOT = path.resolve(__dirname, '../../..');
 const CLI_BIN = path.join(REPO_ROOT, 'bin/cc-devflow-cli.js');
 const TEMPLATE_ROOT = path.join(REPO_ROOT, '.claude');
 
-function runCli(args, cwd) {
+function runCli(args, cwd, env = {}) {
   const result = spawnSync(process.execPath, [CLI_BIN, ...args], {
     cwd,
-    encoding: 'utf8'
+    encoding: 'utf8',
+    env: {
+      ...process.env,
+      ...env
+    }
   });
 
   if (result.error) {
@@ -76,6 +80,84 @@ describe('cc-devflow cli distribution bootstrap', () => {
     expect(fs.existsSync(path.join(repoRoot, '.claude', 'tsc-cache'))).toBe(false);
   });
 
+  test('init does not bake project YAML output policy into managed Claude skills', () => {
+    const customSkillDir = path.join(repoRoot, '.claude', 'skills', 'custom-skill');
+    fs.mkdirSync(customSkillDir, { recursive: true });
+    fs.writeFileSync(path.join(customSkillDir, 'SKILL.md'), '# Custom Skill\n');
+    fs.mkdirSync(path.join(repoRoot, '.cc-devflow'), { recursive: true });
+    fs.writeFileSync(
+      path.join(repoRoot, '.cc-devflow', 'config.yml'),
+      [
+        'version: 1',
+        'output:',
+        '  document_language: zh-CN',
+        'agent_preferences:',
+        '  general:',
+        '    - 先给结论。',
+        ''
+      ].join('\n')
+    );
+
+    const result = runCli(['init', '--dir', repoRoot], repoRoot);
+    expect(result.status).toBe(0);
+
+    const skillContent = fs.readFileSync(
+      path.join(repoRoot, '.claude', 'skills', 'cc-plan', 'SKILL.md'),
+      'utf8'
+    );
+
+    expect(skillContent).not.toContain('<!-- CC-DEVFLOW OUTPUT POLICY START -->');
+    expect(skillContent).not.toContain('文档语言: zh-CN');
+    expect(skillContent).toContain('cc-devflow config resolve --format policy');
+    expect(fs.readFileSync(path.join(customSkillDir, 'SKILL.md'), 'utf8')).toBe('# Custom Skill\n');
+  });
+
+  test('config commands manage and diagnose the effective output policy', () => {
+    fs.mkdirSync(path.join(repoRoot, '.cc-devflow'), { recursive: true });
+    fs.writeFileSync(
+      path.join(repoRoot, '.cc-devflow', 'config.yml'),
+      [
+        'version: 1',
+        'output:',
+        '  document_language: zh-CN',
+        ''
+      ].join('\n')
+    );
+
+    const resolveResult = runCli(
+      ['config', 'resolve', '--cwd', repoRoot, '--format', 'policy', '--trace'],
+      repoRoot
+    );
+    const getResult = runCli(['config', 'get', 'output.document_language', '--cwd', repoRoot], repoRoot);
+    const doctorResult = runCli(['config', 'doctor', '--cwd', repoRoot], repoRoot);
+
+    expect(resolveResult.status).toBe(0);
+    expect(resolveResult.stdout).toContain('CC-DevFlow Output Policy');
+    expect(resolveResult.stdout).toContain('Output language: zh-CN');
+    expect(resolveResult.stdout).toContain('Trace:');
+    expect(resolveResult.stdout).toContain('project');
+    expect(getResult.status).toBe(0);
+    expect(getResult.stdout.trim()).toBe('zh-CN');
+    expect(doctorResult.status).toBe(0);
+    expect(doctorResult.stdout).toContain('Config OK');
+
+    const setResult = runCli(
+      ['config', 'set', 'output.document_language', 'en', '--cwd', repoRoot, '--project'],
+      repoRoot
+    );
+    expect(setResult.status).toBe(0);
+    expect(runCli(['config', 'get', 'output.document_language', '--cwd', repoRoot], repoRoot).stdout.trim()).toBe('en');
+
+    const isolatedHome = path.join(repoRoot, 'home');
+    const userInitResult = runCli(
+      ['config', 'init', '--cwd', repoRoot, '--user', '--force'],
+      repoRoot,
+      { HOME: isolatedHome }
+    );
+    expect(userInitResult.status).toBe(0);
+    expect(userInitResult.stdout).toContain(path.join(isolatedHome, '.cc-devflow', 'config.yml'));
+  });
+
   test('init overwrites diverged .claude files with packaged content', () => {
     expect(runCli(['init', '--dir', repoRoot], repoRoot).status).toBe(0);
 
@@ -161,6 +243,34 @@ describe('cc-devflow cli distribution bootstrap', () => {
     );
   });
 
+  test('adapt mirrors Codex skills without baking project YAML output policy', () => {
+    fs.mkdirSync(path.join(repoRoot, '.cc-devflow'), { recursive: true });
+    fs.writeFileSync(
+      path.join(repoRoot, '.cc-devflow', 'config.yml'),
+      [
+        'version: 1',
+        'output:',
+        '  document_language: zh-CN',
+        'agent_preferences:',
+        '  documentation:',
+        '    - 输出文档默认使用中文。',
+        ''
+      ].join('\n')
+    );
+    expect(runCli(['init', '--dir', repoRoot], repoRoot).status).toBe(0);
+
+    const result = runCli(['adapt', '--cwd', repoRoot, '--platform', 'codex'], repoRoot);
+    expect(result.status).toBe(0);
+
+    const codexPlanSkill = fs.readFileSync(
+      path.join(repoRoot, '.codex', 'skills', 'cc-plan', 'SKILL.md'),
+      'utf8'
+    );
+    expect(codexPlanSkill).not.toContain('<!-- CC-DEVFLOW OUTPUT POLICY START -->');
+    expect(codexPlanSkill).not.toContain('文档语言: zh-CN');
+    expect(codexPlanSkill).toContain('cc-devflow config resolve --format policy');
+  });
+
   test('adapt preserves pre-existing non-public Codex skills and does not mirror new private ones', () => {
     expect(runCli(['init', '--dir', repoRoot], repoRoot).status).toBe(0);
 

package/lib/skill-runtime/__tests__/config.test.js

@@ -0,0 +1,161 @@
+/**
+ * [INPUT]: 临时 home/repo 配置、env 覆盖与 CLI 等价写入操作。
+ * [OUTPUT]: 验证运行时个人配置解析、校验、trace、policy 与写入行为。
+ * [POS]: skill runtime 个人配置的单元测试。
+ * [PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const {
+  LOCAL_CONFIG_RELATIVE_PATH,
+  PROJECT_CONFIG_RELATIVE_PATH,
+  USER_CONFIG_RELATIVE_PATH,
+  getConfigValue,
+  resolveUserConfig,
+  setConfigValue,
+  writeConfigTemplate
+} = require('../config.js');
+
+describe('skill-runtime user config', () => {
+  let tmpRoot;
+  let homeDir;
+  let repoRoot;
+
+  beforeEach(() => {
+    tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-runtime-config-'));
+    homeDir = path.join(tmpRoot, 'home');
+    repoRoot = path.join(tmpRoot, 'repo');
+    fs.mkdirSync(path.join(homeDir, '.cc-devflow'), { recursive: true });
+    fs.mkdirSync(path.join(repoRoot, '.cc-devflow'), { recursive: true });
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+  });
+
+  test('resolves document language with default, file, env, and cli precedence trace', () => {
+    fs.writeFileSync(
+      path.join(homeDir, USER_CONFIG_RELATIVE_PATH),
+      [
+        'version: 1',
+        'output:',
+        '  document_language: en',
+        'agent_preferences:',
+        '  planning:',
+        '    - Keep plans short.',
+        ''
+      ].join('\n')
+    );
+    fs.writeFileSync(
+      path.join(repoRoot, PROJECT_CONFIG_RELATIVE_PATH),
+      [
+        'version: 1',
+        'output:',
+        '  document_language: zh-CN',
+        ''
+      ].join('\n')
+    );
+    fs.writeFileSync(
+      path.join(repoRoot, LOCAL_CONFIG_RELATIVE_PATH),
+      [
+        'version: 1',
+        'agent_preferences:',
+        '  review:',
+        '    order: severe-first',
+        ''
+      ].join('\n')
+    );
+
+    const result = resolveUserConfig({
+      cwd: repoRoot,
+      homeDir,
+      env: {
+        CC_DEVFLOW_DOCUMENT_LANGUAGE: 'en'
+      },
+      overrides: {
+        output: {
+          document_language: 'zh-CN'
+        }
+      }
+    });
+
+    expect(result.config.output.document_language).toBe('zh-CN');
+    expect(result.config.agent_preferences.planning).toEqual(['Keep plans short.']);
+    expect(result.config.agent_preferences.review.order).toBe('severe-first');
+    expect(result.sources.map((source) => source.kind)).toEqual(['user', 'project', 'local', 'env', 'cli']);
+    expect(result.trace.map((entry) => `${entry.source}:${entry.key}:${entry.value}`)).toEqual([
+      'default:version:1',
+      'default:output.document_language:en',
+      'user:version:1',
+      'user:output.document_language:en',
+      'user:agent_preferences.planning:["Keep plans short."]',
+      'project:version:1',
+      'project:output.document_language:zh-CN',
+      'local:version:1',
+      'local:agent_preferences.review.order:severe-first',
+      'env:output.document_language:en',
+      'cli:output.document_language:zh-CN'
+    ]);
+    expect(result.policy).toContain('Output language: zh-CN');
+    expect(result.policy).toContain('Machine-enforced fields: output.document_language');
+    expect(result.policy).toContain('Agent advisory preferences');
+  });
+
+  test('rejects unsupported language and unknown top-level fields', () => {
+    fs.writeFileSync(
+      path.join(repoRoot, PROJECT_CONFIG_RELATIVE_PATH),
+      [
+        'version: 1',
+        'output:',
+        '  document_language: klingon',
+        ''
+      ].join('\n')
+    );
+
+    expect(() => resolveUserConfig({ cwd: repoRoot, homeDir })).toThrow(/output.document_language/);
+
+    fs.writeFileSync(
+      path.join(repoRoot, PROJECT_CONFIG_RELATIVE_PATH),
+      [
+        'version: 1',
+        'preferences:',
+        '  general:',
+        '    - non standard root',
+        ''
+      ].join('\n')
+    );
+
+    expect(() => resolveUserConfig({ cwd: repoRoot, homeDir })).toThrow(/Unsupported config key/);
+  });
+
+  test('wraps invalid YAML errors with the config path', () => {
+    const configPath = path.join(repoRoot, PROJECT_CONFIG_RELATIVE_PATH);
+    fs.writeFileSync(configPath, 'version: 1\noutput:\n  document_language: [\n');
+
+    expect(() => resolveUserConfig({ cwd: repoRoot, homeDir })).toThrow(configPath);
+  });
+
+  test('reads and writes config values without losing advisory preferences', () => {
+    const configPath = writeConfigTemplate({ scope: 'project', cwd: repoRoot, homeDir });
+    expect(configPath).toBe(path.join(repoRoot, PROJECT_CONFIG_RELATIVE_PATH));
+
+    setConfigValue('output.document_language', 'en', { scope: 'project', cwd: repoRoot, homeDir });
+    setConfigValue('agent_preferences.documentation.voice', 'direct', {
+      scope: 'project',
+      cwd: repoRoot,
+      homeDir
+    });
+
+    const resolved = resolveUserConfig({ cwd: repoRoot, homeDir });
+
+    expect(getConfigValue(resolved.config, 'output.document_language')).toBe('en');
+    expect(getConfigValue(resolved.config, 'agent_preferences.documentation.voice')).toBe('direct');
+  });
+
+  test('rejects unknown config scopes instead of silently writing project config', () => {
+    expect(() => writeConfigTemplate({ scope: 'team', cwd: repoRoot, homeDir })).toThrow(/Unknown config scope/);
+  });
+});

package/lib/skill-runtime/__tests__/runtime.integration.test.js

@@ -46,6 +46,8 @@ const MARK_TASK_COMPLETE = path.join(
   '.claude/skills/cc-do/scripts/mark-task-complete.sh'
 );
 
+jest.setTimeout(20000);
+
 describe('Skill runtime', () => {
   let repoRoot;
 

package/lib/skill-runtime/config.js

@@ -0,0 +1,379 @@
+/**
+ * [INPUT]: 用户级、项目级、本地 YAML 配置，以及 env / CLI 覆盖。
+ * [OUTPUT]: 运行时输出策略、key 级来源 trace、配置读写与 doctor 结果。
+ * [POS]: skill runtime 的个人配置真相源，避免把个人偏好烘进 Skill 文件。
+ * [PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const yaml = require('js-yaml');
+
+const USER_CONFIG_RELATIVE_PATH = path.join('.cc-devflow', 'config.yml');
+const PROJECT_CONFIG_RELATIVE_PATH = path.join('.cc-devflow', 'config.yml');
+const LOCAL_CONFIG_RELATIVE_PATH = path.join('.cc-devflow', 'config.local.yml');
+const CONFIG_TEMPLATE_PATH = path.resolve(__dirname, '..', '..', 'config', 'user-config.template.yml');
+const SUPPORTED_DOCUMENT_LANGUAGES = new Set(['en', 'zh-CN']);
+
+const DEFAULT_CONFIG = {
+  version: 1,
+  output: {
+    document_language: 'en'
+  },
+  agent_preferences: {}
+};
+
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function traceValue(value) {
+  if (Array.isArray(value) || isPlainObject(value)) {
+    return JSON.stringify(value);
+  }
+
+  return String(value);
+}
+
+function readYamlConfig(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+
+  let parsed;
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    parsed = yaml.load(content) || {};
+  } catch (error) {
+    throw new Error(`Failed to parse cc-devflow config ${filePath}: ${error.message}`);
+  }
+
+  if (!isPlainObject(parsed)) {
+    throw new Error(`cc-devflow config must be a YAML object: ${filePath}`);
+  }
+
+  validateConfigShape(parsed, filePath);
+  return parsed;
+}
+
+function validateConfigShape(config, source = 'config') {
+  const allowedRootKeys = new Set(['version', 'output', 'agent_preferences']);
+
+  for (const key of Object.keys(config || {})) {
+    if (!allowedRootKeys.has(key)) {
+      throw new Error(`Unsupported config key "${key}" in ${source}. Put custom fields under agent_preferences.`);
+    }
+  }
+
+  if ('version' in config && config.version !== 1) {
+    throw new Error(`Unsupported config version "${config.version}" in ${source}. Expected version: 1.`);
+  }
+
+  if ('output' in config) {
+    if (!isPlainObject(config.output)) {
+      throw new Error(`output must be an object in ${source}`);
+    }
+
+    for (const key of Object.keys(config.output)) {
+      if (key !== 'document_language') {
+        throw new Error(`Unsupported output key "output.${key}" in ${source}`);
+      }
+    }
+
+    if (
+      'document_language' in config.output
+      && !SUPPORTED_DOCUMENT_LANGUAGES.has(config.output.document_language)
+    ) {
+      throw new Error(
+        `Unsupported output.document_language "${config.output.document_language}" in ${source}. Use en or zh-CN.`
+      );
+    }
+  }
+
+  if ('agent_preferences' in config && !isPlainObject(config.agent_preferences)) {
+    throw new Error(`agent_preferences must be an object in ${source}`);
+  }
+}
+
+function pushTrace(trace, source, sourcePath, key, value) {
+  trace.push({
+    key,
+    value: traceValue(value),
+    source,
+    path: sourcePath || null
+  });
+}
+
+function applyConfigLayer(base, layer, trace, source, sourcePath, prefix = '') {
+  const next = Array.isArray(base) ? [...base] : { ...(base || {}) };
+
+  for (const [key, value] of Object.entries(layer || {})) {
+    const traceKey = prefix ? `${prefix}.${key}` : key;
+
+    if (isPlainObject(value)) {
+      next[key] = applyConfigLayer(
+        isPlainObject(next[key]) ? next[key] : {},
+        value,
+        trace,
+        source,
+        sourcePath,
+        traceKey
+      );
+      continue;
+    }
+
+    next[key] = Array.isArray(value) ? [...value] : value;
+    pushTrace(trace, source, sourcePath, traceKey, next[key]);
+  }
+
+  return next;
+}
+
+function collectConfigSources(options = {}) {
+  const cwd = path.resolve(options.cwd || process.cwd());
+  const homeDir = path.resolve(options.homeDir || os.homedir());
+
+  return [
+    {
+      kind: 'user',
+      path: path.join(homeDir, USER_CONFIG_RELATIVE_PATH)
+    },
+    {
+      kind: 'project',
+      path: path.join(cwd, PROJECT_CONFIG_RELATIVE_PATH)
+    },
+    {
+      kind: 'local',
+      path: path.join(cwd, LOCAL_CONFIG_RELATIVE_PATH)
+    }
+  ];
+}
+
+function envToConfig(env = process.env) {
+  const documentLanguage = env.CC_DEVFLOW_DOCUMENT_LANGUAGE
+    || env.CC_DEVFLOW_OUTPUT_DOCUMENT_LANGUAGE;
+
+  if (!documentLanguage) {
+    return null;
+  }
+
+  return {
+    output: {
+      document_language: documentLanguage
+    }
+  };
+}
+
+function resolveUserConfig(options = {}) {
+  const trace = [];
+  const sources = [];
+  let config = applyConfigLayer({}, DEFAULT_CONFIG, trace, 'default', null);
+
+  for (const source of collectConfigSources(options)) {
+    const value = readYamlConfig(source.path);
+    if (!value) {
+      continue;
+    }
+
+    config = applyConfigLayer(config, value, trace, source.kind, source.path);
+    sources.push(source);
+  }
+
+  const envConfig = envToConfig(options.env || process.env);
+  if (envConfig) {
+    validateConfigShape(envConfig, 'environment');
+    config = applyConfigLayer(config, envConfig, trace, 'env', null);
+    sources.push({ kind: 'env', path: null });
+  }
+
+  if (options.overrides && Object.keys(options.overrides).length > 0) {
+    validateConfigShape(options.overrides, 'CLI overrides');
+    config = applyConfigLayer(config, options.overrides, trace, 'cli', null);
+    sources.push({ kind: 'cli', path: null });
+  }
+
+  validateConfigShape(config, 'resolved config');
+
+  return {
+    enabled: sources.length > 0,
+    config,
+    sources,
+    trace,
+    policy: renderOutputPolicy(config)
+  };
+}
+
+function formatPreferenceLines(value, prefix = '') {
+  if (Array.isArray(value)) {
+    return value.map((item) => `- ${prefix}: ${traceValue(item)}`);
+  }
+
+  if (!isPlainObject(value)) {
+    return [`- ${prefix}: ${traceValue(value)}`];
+  }
+
+  return Object.entries(value).flatMap(([key, child]) => {
+    const nextPrefix = prefix ? `${prefix}.${key}` : key;
+    return formatPreferenceLines(child, nextPrefix);
+  });
+}
+
+function renderOutputPolicy(config = DEFAULT_CONFIG) {
+  const documentLanguage = config.output?.document_language || DEFAULT_CONFIG.output.document_language;
+  const lines = [
+    '## CC-DevFlow Output Policy',
+    '',
+    'Machine-enforced fields: output.document_language',
+    `- Output language: ${documentLanguage}`,
+    `- Durable Markdown artifacts must include \`Output language: ${documentLanguage}\` in their metadata or first screen.`,
+    '',
+    'Agent advisory preferences:'
+  ];
+
+  const preferences = config.agent_preferences || {};
+  const preferenceLines = formatPreferenceLines(preferences);
+
+  if (preferenceLines.length === 0) {
+    lines.push('- none');
+  } else {
+    lines.push(...preferenceLines);
+  }
+
+  return `${lines.join('\n')}\n`;
+}
+
+function getConfigPath(scope, options = {}) {
+  const cwd = path.resolve(options.cwd || process.cwd());
+  const homeDir = path.resolve(options.homeDir || os.homedir());
+
+  if (scope === 'user') {
+    return path.join(homeDir, USER_CONFIG_RELATIVE_PATH);
+  }
+
+  if (scope === 'local') {
+    return path.join(cwd, LOCAL_CONFIG_RELATIVE_PATH);
+  }
+
+  if (scope !== 'project') {
+    throw new Error(`Unknown config scope "${scope}". Use user, project, or local.`);
+  }
+
+  return path.join(cwd, PROJECT_CONFIG_RELATIVE_PATH);
+}
+
+function getConfigValue(config, keyPath) {
+  return String(keyPath || '')
+    .split('.')
+    .filter(Boolean)
+    .reduce((value, key) => (value == null ? undefined : value[key]), config);
+}
+
+function setNestedValue(target, keyPath, value) {
+  const parts = String(keyPath || '').split('.').filter(Boolean);
+  if (parts.length === 0) {
+    throw new Error('Config key is required.');
+  }
+
+  let cursor = target;
+  for (const key of parts.slice(0, -1)) {
+    if (!isPlainObject(cursor[key])) {
+      cursor[key] = {};
+    }
+    cursor = cursor[key];
+  }
+
+  cursor[parts[parts.length - 1]] = value;
+}
+
+function coerceConfigValue(keyPath, value) {
+  if (keyPath === 'output.document_language') {
+    if (!SUPPORTED_DOCUMENT_LANGUAGES.has(value)) {
+      throw new Error(`Unsupported output.document_language "${value}". Use en or zh-CN.`);
+    }
+  }
+
+  return value;
+}
+
+function writeYamlConfig(filePath, config) {
+  validateConfigShape(config, filePath);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, yaml.dump(config, { lineWidth: 100, noRefs: true }), 'utf8');
+}
+
+function setConfigValue(keyPath, value, options = {}) {
+  if (keyPath !== 'output.document_language' && !keyPath.startsWith('agent_preferences.')) {
+    throw new Error('Only output.document_language and agent_preferences.* can be set.');
+  }
+
+  const filePath = getConfigPath(options.scope || 'project', options);
+  const config = readYamlConfig(filePath) || { version: 1 };
+  setNestedValue(config, keyPath, coerceConfigValue(keyPath, value));
+  writeYamlConfig(filePath, config);
+  return filePath;
+}
+
+function writeConfigTemplate(options = {}) {
+  const scope = options.scope || 'project';
+  const filePath = getConfigPath(scope, options);
+
+  if (fs.existsSync(filePath) && !options.force) {
+    return filePath;
+  }
+
+  const template = readYamlConfig(CONFIG_TEMPLATE_PATH);
+
+  writeYamlConfig(filePath, template);
+  return filePath;
+}
+
+function isLocalConfigIgnored(repoRoot) {
+  const gitignorePath = path.join(repoRoot, '.gitignore');
+  if (!fs.existsSync(gitignorePath)) {
+    return false;
+  }
+
+  const lines = fs.readFileSync(gitignorePath, 'utf8')
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line && !line.startsWith('#'));
+
+  return lines.includes('.cc-devflow/config.local.yml')
+    || lines.includes('/.cc-devflow/config.local.yml')
+    || lines.includes('.cc-devflow/');
+}
+
+function doctorUserConfig(options = {}) {
+  const cwd = path.resolve(options.cwd || process.cwd());
+  const resolved = resolveUserConfig(options);
+  const warnings = [];
+  const localPath = path.join(cwd, LOCAL_CONFIG_RELATIVE_PATH);
+
+  if (fs.existsSync(localPath) && !isLocalConfigIgnored(cwd)) {
+    warnings.push('.cc-devflow/config.local.yml exists but is not ignored by .gitignore.');
+  }
+
+  return {
+    ok: warnings.length === 0,
+    warnings,
+    resolved
+  };
+}
+
+module.exports = {
+  DEFAULT_CONFIG,
+  CONFIG_TEMPLATE_PATH,
+  LOCAL_CONFIG_RELATIVE_PATH,
+  PROJECT_CONFIG_RELATIVE_PATH,
+  SUPPORTED_DOCUMENT_LANGUAGES,
+  USER_CONFIG_RELATIVE_PATH,
+  doctorUserConfig,
+  getConfigPath,
+  getConfigValue,
+  readYamlConfig,
+  renderOutputPolicy,
+  resolveUserConfig,
+  setConfigValue,
+  writeConfigTemplate
+};

package/lib/skill-runtime/index.js

@@ -15,6 +15,7 @@ const lifecycle = require('./lifecycle');
 const teamState = require('./team-state');
 const delegation = require('./delegation');
 const paths = require('./paths');
+const config = require('./config');
 const worker = require('./operations/worker');
 const workerRun = require('./operations/worker-run');
 
@@ -29,6 +30,7 @@ module.exports = {
   ...teamState,
   ...delegation,
   ...paths,
+  ...config,
   ...worker,
   ...workerRun
 };