svharness 0.8.0

package/dist/commands/init.js

@@ -0,0 +1,420 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInit = runInit;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const node_path_1 = __importDefault(require("node:path"));
+const prompts_1 = __importDefault(require("prompts"));
+const validate_args_1 = require("../utils/validate-args");
+const version_1 = require("../utils/version");
+const logger_1 = require("../utils/logger");
+const scaffold_1 = require("../core/scaffold");
+const render_meta_1 = require("../core/render-meta");
+const state_1 = require("../core/state");
+const agent_injector_1 = require("../core/agent-injector");
+const adapters_1 = require("../adapters");
+const next_steps_1 = require("../core/next-steps");
+const repomix_pack_1 = require("../core/repomix-pack");
+const baseline_copy_1 = require("../utils/baseline-copy");
+const wiki_1 = require("../wiki");
+/**
+ * Resolve the absolute path to the bundled templates/ directory.
+ * At runtime __dirname is dist/commands, so templates are at ../../templates.
+ */
+function resolveTemplatesRoot() {
+    return node_path_1.default.resolve(__dirname, '..', '..', 'templates');
+}
+async function runInit(opts) {
+    (0, logger_1.setVerbose)(!!opts.verbose);
+    // 0. Mutual-exclusion between wiki modes.
+    if (opts.generateWiki && opts.wikiTasksOnly) {
+        throw new Error('--generate-wiki 与 --wiki-tasks-only 不可同时启用');
+    }
+    // 1. Validate args (throws on failure)
+    const validated = (0, validate_args_1.validateArgs)({
+        name: opts.name,
+        arch: opts.arch,
+        agent: opts.agent,
+        baseline: opts.baseline,
+        baselineBranch: opts.baselineBranch,
+        baselineMaxFileKB: opts.baselineMaxFileKB,
+    });
+    // Warn if --baseline-branch was provided together with a local path.
+    if (opts.baselineBranch && validated.baselineMode === 'local') {
+        logger_1.logger.warn('--baseline-branch 在本地基线模式下被忽略');
+    }
+    const cwd = opts.cwd ?? process.cwd();
+    const targetRoot = node_path_1.default.resolve(cwd, `${validated.name}-harness`);
+    const cliVersion = (0, version_1.getCliVersion)();
+    const createdAt = new Date().toISOString();
+    // Baseline code lands at <target>/assets/baseline/code/ for both git & local
+    // modes. Wiki generation consumes this directory by default so it always
+    // reflects the baseline the user asked for (not the caller's cwd).
+    const hasBaseline = !!validated.baseline;
+    const baselineCodeDir = node_path_1.default.join(targetRoot, 'assets', 'baseline', 'code');
+    const wikiSourceRoot = node_path_1.default.resolve(opts.wikiSource ?? (hasBaseline ? baselineCodeDir : cwd));
+    // Derive the final wiki mode:
+    // - no baseline     -> 'off' (wiki flags are warned and ignored)
+    // - --generate-wiki -> 'full'
+    // - otherwise       -> 'tasks' (new default when baseline is present)
+    let wikiMode;
+    if (!hasBaseline) {
+        if (opts.generateWiki || opts.wikiTasksOnly) {
+            logger_1.logger.warn('未提供 --baseline，忽略 wiki 相关开关（--generate-wiki / --wiki-tasks-only）');
+        }
+        wikiMode = 'off';
+    }
+    else if (opts.generateWiki) {
+        wikiMode = 'full';
+    }
+    else {
+        wikiMode = 'tasks';
+    }
+    // 2. Display configuration and confirmation (unless --yes)
+    const configItems = [
+        { label: '项目', value: validated.name },
+        { label: '架构', value: validated.arch },
+        { label: 'Agent', value: validated.agent },
+        { label: '目标路径', value: targetRoot },
+    ];
+    if (validated.baseline) {
+        const modeTag = validated.baselineMode === 'git' ? 'git' : 'local';
+        configItems.push({ label: `基线 (${modeTag})`, value: validated.baseline });
+        if (validated.baselineMode === 'git' && validated.baselineBranch) {
+            configItems.push({ label: '基线分支', value: validated.baselineBranch });
+        }
+        configItems.push({
+            label: '基线大小上限',
+            value: `${validated.baselineMaxFileKB} KB/文件`,
+        });
+    }
+    configItems.push({ label: '版本', value: `svharness@${cliVersion}` });
+    // Add wiki configuration items based on the resolved wiki mode.
+    const wikiEnabled = wikiMode !== 'off';
+    const wikiModeLabel = wikiMode === 'full' ? '完整生成' : wikiMode === 'tasks' ? '仅任务清单（默认）' : '禁用';
+    configItems.push({ label: 'Wiki 生成', value: wikiModeLabel });
+    if (wikiEnabled) {
+        const wikiSource = wikiSourceRoot;
+        configItems.push({ label: 'Wiki 源码', value: wikiSource });
+        // Resolve wiki config for display
+        try {
+            const wikiCfg = await (0, wiki_1.resolveWikiRunConfig)({
+                cwd,
+                apiKey: opts.wikiApiKey,
+                baseUrl: opts.wikiBaseUrl,
+                model: opts.wikiModel,
+            });
+            configItems.push({ label: 'Wiki 模型', value: wikiCfg.model });
+            const displayBaseUrl = wikiCfg.baseUrl.replace(/\/v1$/, '');
+            configItems.push({ label: 'Wiki API', value: displayBaseUrl });
+        }
+        catch (e) {
+            // Ignore config resolution errors for display
+        }
+    }
+    if (hasBaseline) {
+        configItems.push({
+            label: 'Repomix 基线包',
+            value: `默认生成（${(0, repomix_pack_1.repomixPackRelFile)()}）`,
+        });
+    }
+    logger_1.logger.configBox('配置确认', configItems);
+    if (!opts.yes) {
+        const { ok } = await (0, prompts_1.default)({
+            type: 'confirm',
+            name: 'ok',
+            message: '确认以上配置并继续？',
+            initial: true,
+        });
+        if (!ok) {
+            logger_1.logger.warn('用户取消');
+            return;
+        }
+    }
+    // 3. Target availability
+    await (0, scaffold_1.ensureTargetAvailable)(targetRoot, !!opts.force);
+    // 4. Resolve template paths (shared + arch two-layer)
+    const templatesRoot = resolveTemplatesRoot();
+    const sharedRoot = node_path_1.default.join(templatesRoot, '_shared');
+    const archRoot = node_path_1.default.join(templatesRoot, validated.arch);
+    if (!(await fs_extra_1.default.pathExists(archRoot))) {
+        throw new Error(`架构模板不存在: ${archRoot}`);
+    }
+    if (!(await fs_extra_1.default.pathExists(sharedRoot))) {
+        throw new Error(`共享模板不存在: ${sharedRoot}`);
+    }
+    const skeletonSrcs = [
+        node_path_1.default.join(sharedRoot, 'skeleton'),
+        node_path_1.default.join(archRoot, 'skeleton'),
+    ];
+    const metaSrcs = [
+        node_path_1.default.join(sharedRoot, 'meta'),
+        node_path_1.default.join(archRoot, 'meta'),
+    ];
+    const buildSkillsSrcs = [
+        node_path_1.default.join(sharedRoot, 'build-skills'),
+        node_path_1.default.join(archRoot, 'build-skills'),
+    ];
+    const buildRulesSrcs = [
+        node_path_1.default.join(sharedRoot, 'build-rules'),
+        node_path_1.default.join(archRoot, 'build-rules'),
+    ];
+    const ctx = {
+        name: validated.name,
+        arch: validated.arch,
+        agent: validated.agent,
+        sourcePath: validated.baseline ?? '',
+        createdAt,
+        version: cliVersion,
+    };
+    // 5. Execute pipeline with rollback-on-failure
+    // Dynamic step numbering:
+    //   1: skeleton, 2: meta, 3: skills, 4: rules
+    //   optional: baseline copy, repomix pack, wiki generation
+    //   last: state file
+    let stepCursor = 4;
+    const stepBaseline = hasBaseline ? ++stepCursor : 0;
+    const stepRepomix = hasBaseline ? ++stepCursor : 0;
+    const stepWiki = wikiEnabled ? ++stepCursor : 0;
+    const stepState = ++stepCursor;
+    const totalSteps = stepCursor;
+    let baselineMeta;
+    try {
+        logger_1.logger.section(`步骤 1/${totalSteps} - 生成目录骨架`);
+        const copied = await (0, scaffold_1.scaffoldLayered)(skeletonSrcs, targetRoot);
+        logger_1.logger.success(`已拷贝骨架文件 ${copied.length} 个`);
+        logger_1.logger.section(`步骤 2/${totalSteps} - 渲染元文件`);
+        const meta = await (0, render_meta_1.renderMetaLayered)(metaSrcs, targetRoot, ctx);
+        logger_1.logger.success(`已渲染元文件 ${meta.length} 个: ${meta.join(', ')}`);
+        logger_1.logger.section(`步骤 3/${totalSteps} - 注入构建辅助 skill`);
+        const adapter = (0, adapters_1.getAdapter)(validated.agent);
+        // Skills are injected beside the harness folder (cwd), not inside it,
+        // so the Agent picks them up from the project root.
+        const harnessDirName = node_path_1.default.basename(targetRoot);
+        const injected = await (0, agent_injector_1.injectSkillsLayered)(buildSkillsSrcs, targetRoot, adapter, cwd, harnessDirName);
+        logger_1.logger.success(`已向 ${node_path_1.default.join(cwd, adapter.skillsDir)}/ 注入 skill ${injected.length} 个`);
+        logger_1.logger.section(`步骤 4/${totalSteps} - 注入 harness 构建规则`);
+        const rules = await (0, agent_injector_1.injectRulesLayered)(buildRulesSrcs, adapter, cwd);
+        if (adapter.rulesDir) {
+            logger_1.logger.success(`已向 ${node_path_1.default.join(cwd, adapter.rulesDir)}/ 注入 rule ${rules.length} 个`);
+        }
+        if (hasBaseline && validated.baseline && validated.baselineMode) {
+            logger_1.logger.section(`步骤 ${stepBaseline}/${totalSteps} - 拷贝基线源码`);
+            const destDir = node_path_1.default.join(targetRoot, 'assets', 'baseline', 'code');
+            baselineMeta = await (0, baseline_copy_1.copyBaseline)({
+                mode: validated.baselineMode,
+                source: validated.baseline,
+                branch: validated.baselineBranch,
+                destDir,
+                maxSizeKB: validated.baselineMaxFileKB,
+                onLog: (m) => logger_1.logger.info(m),
+            });
+            const { files, sizeKB, skipped } = baselineMeta.stats;
+            logger_1.logger.success(`基线已拷贝：${files} 个文件 · ${sizeKB} KB · 跳过 ${skipped} 个` +
+                (baselineMeta.commit ? ` · commit ${baselineMeta.commit.substring(0, 8)}` : ''));
+        }
+    }
+    catch (err) {
+        logger_1.logger.error(err.message);
+        logger_1.logger.warn('正在回滚已生成的不完整产物...');
+        await (0, scaffold_1.rollbackTarget)(targetRoot);
+        throw err;
+    }
+    // 6a. Repomix XML pack of baseline code (default when --baseline; non-fatal on failure).
+    if (hasBaseline) {
+        logger_1.logger.section(`步骤 ${stepRepomix}/${totalSteps} - 生成 baseline Repomix 包`);
+        try {
+            const packRootFs = wikiSourceRoot;
+            if (hasBaseline) {
+                const exists = await fs_extra_1.default.pathExists(packRootFs);
+                const entries = exists ? await fs_extra_1.default.readdir(packRootFs) : [];
+                if (!exists || entries.length === 0) {
+                    throw new Error(`Repomix 打包目录为空或不存在：${packRootFs}。` +
+                        '请检查基线拷贝结果（黑名单/大小上限可能过滤掉了所有文件）。');
+                }
+            }
+            const outAbs = await (0, repomix_pack_1.runRepomixPackBaseline)({
+                packRootFs,
+                harnessRootFs: targetRoot,
+                onLog: (m) => logger_1.logger.info(`  ${m}`),
+            });
+            logger_1.logger.success(`baseline Repomix 已生成：${node_path_1.default.relative(targetRoot, outAbs)}`);
+        }
+        catch (err) {
+            logger_1.logger.warn(`Repomix 生成失败（不回滚 harness 骨架）：${err.message}`);
+        }
+    }
+    // 6b. Optional: generate baseline wiki via repowiki core.
+    //    Wiki failure is non-fatal: we only warn, do NOT rollback the scaffold above.
+    //    Wiki generation runs BEFORE state file so that the state accurately reflects
+    //    the wiki result.
+    let resolvedWikiPhase = wikiMode === 'off' ? 'none' : wikiMode === 'tasks' ? 'pending' : 'done';
+    let resolvedWikiSource;
+    if (wikiMode === 'full') {
+        logger_1.logger.section(`步骤 ${stepWiki}/${totalSteps} - 生成 baseline wiki`);
+        let wikiFullOk = false;
+        try {
+            const repoRootFs = wikiSourceRoot;
+            const wikiOutputRootFs = targetRoot;
+            const wikiRelPath = node_path_1.default.join('assets', 'baseline', 'wiki');
+            // Guard: baseline wiki must be based on real code. If the user provided
+            // --baseline but the copy step produced an empty directory (e.g. every
+            // file was filtered out), refuse to silently index cwd or an empty dir.
+            if (hasBaseline) {
+                const exists = await fs_extra_1.default.pathExists(repoRootFs);
+                const entries = exists ? await fs_extra_1.default.readdir(repoRootFs) : [];
+                if (!exists || entries.length === 0) {
+                    throw new Error(`Wiki 源码目录为空或不存在：${repoRootFs}。` +
+                        '请检查基线拷贝结果（黑名单/大小上限可能过滤掉了所有文件）。');
+                }
+            }
+            const cfg = await (0, wiki_1.resolveWikiRunConfig)({
+                cwd,
+                apiKey: opts.wikiApiKey,
+                baseUrl: opts.wikiBaseUrl,
+                model: opts.wikiModel,
+            });
+            const langFolder = opts.wikiLang === 'en' ? 'en' : 'zh';
+            const langRun = (0, wiki_1.langRunForRepowikiTarget)(langFolder);
+            logger_1.logger.info(`  源码根：${repoRootFs}`);
+            logger_1.logger.info(`  输出到：${node_path_1.default.join(wikiOutputRootFs, wikiRelPath)}`);
+            logger_1.logger.info(`  语言：${langFolder} · 模型：${cfg.model}`);
+            await (0, wiki_1.runRepowikiIndex)({
+                repoRootFs,
+                wikiOutputRootFs,
+                wikiRelPath,
+                baseUrl: cfg.baseUrl,
+                apiKey: cfg.apiKey,
+                model: cfg.model,
+                languages: [langRun],
+                comprehensiveSections: true,
+                onLog: (m) => logger_1.logger.info(m),
+                onProgress: (p) => {
+                    if (p.total > 0) {
+                        logger_1.logger.info(`  [${p.done}/${p.total}] ${p.detail}`);
+                    }
+                    else {
+                        logger_1.logger.info(`  ${p.detail}`);
+                    }
+                },
+            });
+            logger_1.logger.success('baseline wiki 已生成');
+            wikiFullOk = true;
+        }
+        catch (err) {
+            if ((0, wiki_1.isAbortError)(err)) {
+                logger_1.logger.warn('wiki 生成被中断（已写出部分页可从 checkpoint 恢复）');
+            }
+            else {
+                logger_1.logger.warn(`wiki 生成失败（不回滚 harness 骨架）：${err.message}`);
+            }
+        }
+        // If the full run failed, downgrade P1_wiki from DONE to PENDING
+        // so the agent can pick it up via harness-build-skill-wiki-writer.
+        if (!wikiFullOk) {
+            resolvedWikiPhase = 'pending';
+            resolvedWikiSource = 'cli-full-degraded';
+            logger_1.logger.warn('P1_wiki 将标记为 PENDING，等待 agent 接力补齐');
+        }
+    }
+    else if (wikiMode === 'tasks') {
+        logger_1.logger.section(`步骤 ${stepWiki}/${totalSteps} - 生成 baseline wiki 任务清单`);
+        try {
+            const repoRootFs = wikiSourceRoot;
+            const wikiOutputRootFs = targetRoot;
+            const wikiRelPath = node_path_1.default.join('assets', 'baseline', 'wiki');
+            if (hasBaseline) {
+                const exists = await fs_extra_1.default.pathExists(repoRootFs);
+                const entries = exists ? await fs_extra_1.default.readdir(repoRootFs) : [];
+                if (!exists || entries.length === 0) {
+                    throw new Error(`Wiki 源码目录为空或不存在：${repoRootFs}。` +
+                        '请检查基线拷贝结果（黑名单/大小上限可能过滤掉了所有文件）。');
+                }
+            }
+            const cfg = await (0, wiki_1.resolveWikiRunConfig)({
+                cwd,
+                apiKey: opts.wikiApiKey,
+                baseUrl: opts.wikiBaseUrl,
+                model: opts.wikiModel,
+            });
+            const langFolder = opts.wikiLang === 'en' ? 'en' : 'zh';
+            const langRun = (0, wiki_1.langRunForRepowikiTarget)(langFolder);
+            logger_1.logger.info(`  源码根：${repoRootFs}`);
+            logger_1.logger.info(`  输出到：${node_path_1.default.join(wikiOutputRootFs, wikiRelPath)}`);
+            logger_1.logger.info(`  语言：${langFolder} · 模型：${cfg.model}`);
+            logger_1.logger.info('  模式：仅任务清单（tasks-only，默认）');
+            const outline = await (0, wiki_1.runRepowikiOutlineOnly)({
+                repoRootFs,
+                wikiOutputRootFs,
+                wikiRelPath,
+                baseUrl: cfg.baseUrl,
+                apiKey: cfg.apiKey,
+                model: cfg.model,
+                languages: [langRun],
+                comprehensiveSections: true,
+                onLog: (m) => logger_1.logger.info(m),
+                onProgress: (p) => {
+                    if (p.total > 0) {
+                        logger_1.logger.info(`  [${p.done}/${p.total}] ${p.detail}`);
+                    }
+                    else {
+                        logger_1.logger.info(`  ${p.detail}`);
+                    }
+                },
+            });
+            const tasksPath = await (0, wiki_1.writeWikiTasks)({
+                outline,
+                targetRoot,
+                wikiRelPath,
+                projectName: validated.name,
+                cliVersion,
+                model: cfg.model,
+                generatedAtIso: new Date().toISOString(),
+                sourceRootRel: node_path_1.default
+                    .relative(targetRoot, wikiSourceRoot)
+                    .replace(/\\/g, '/') || '.',
+            });
+            logger_1.logger.success(`baseline wiki 任务清单已生成：${node_path_1.default.relative(targetRoot, tasksPath)} （共 ${outline.pages.length} 页任务）`);
+        }
+        catch (err) {
+            if ((0, wiki_1.isAbortError)(err)) {
+                logger_1.logger.warn('wiki 任务清单生成被中断');
+            }
+            else {
+                logger_1.logger.warn(`wiki 任务清单生成失败（不回滚 harness 骨架）：${err.message}`);
+            }
+        }
+    }
+    // 7. Write build state file (after wiki, so wiki result is accurately reflected).
+    try {
+        logger_1.logger.section(`步骤 ${stepState}/${totalSteps} - 初始化构建状态文件`);
+        const state = (0, state_1.buildInitialState)({
+            name: validated.name,
+            arch: validated.arch,
+            agent: validated.agent,
+            baseline: baselineMeta ?? validated.baseline,
+            cliVersion,
+            createdAt,
+            wikiPhase: resolvedWikiPhase,
+            wikiSource: resolvedWikiSource,
+        });
+        const statePath = await (0, state_1.writeStateFile)(targetRoot, state);
+        logger_1.logger.success(`状态文件: ${node_path_1.default.relative(targetRoot, statePath)}`);
+    }
+    catch (err) {
+        logger_1.logger.error(`状态文件写入失败：${err.message}`);
+        throw err;
+    }
+    // 8. Print next steps
+    const adapterForNext = (0, adapters_1.getAdapter)(validated.agent);
+    (0, next_steps_1.printNextSteps)({
+        projectName: validated.name,
+        targetRoot,
+        adapter: adapterForNext,
+        agent: validated.agent,
+        hasSource: !!validated.baseline,
+        wikiMode,
+    });
+}

package/dist/core/agent-injector.js

@@ -0,0 +1,192 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.injectSkills = injectSkills;
+exports.injectSkillsLayered = injectSkillsLayered;
+exports.injectRulesLayered = injectRulesLayered;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const node_path_1 = __importDefault(require("node:path"));
+const logger_1 = require("../utils/logger");
+const BUILD_SKILLS = [
+    'harness-build-skill-orchestrator.md',
+    'harness-build-skill-spec-builder.md',
+    'harness-build-skill-knowledge-builder.md',
+    'harness-build-skill-wiki-writer.md',
+];
+/**
+ * Copy build-helper skills into the target project's agent skills directory,
+ * transforming content via the adapter when needed.
+ *
+ * Each skill is placed in its own subdirectory:
+ *   <skillsRoot>/<adapter.skillsDir>/<skillName>/<skillName><adapter.skillExt>
+ *
+ * @param skillsSrcDir  Source directory containing <skill>.md files
+ * @param targetRoot    Harness output root (used for relative-path logging)
+ * @param adapter       Agent-specific configuration
+ * @param skillsRoot    Base directory for the agent skills folder.
+ *                      Defaults to targetRoot (legacy). Pass cwd to inject
+ *                      beside the harness folder instead of inside it.
+ */
+async function injectSkills(skillsSrcDir, targetRoot, adapter, skillsRoot) {
+    if (!(await fs_extra_1.default.pathExists(skillsSrcDir))) {
+        throw new Error(`build-skills source directory missing: ${skillsSrcDir}`);
+    }
+    const base = skillsRoot ?? targetRoot;
+    const dstDir = node_path_1.default.join(base, adapter.skillsDir);
+    await fs_extra_1.default.ensureDir(dstDir);
+    const injected = [];
+    for (const srcName of BUILD_SKILLS) {
+        const srcPath = node_path_1.default.join(skillsSrcDir, srcName);
+        if (!(await fs_extra_1.default.pathExists(srcPath))) {
+            logger_1.logger.warn(`build-skill missing, skipped: ${srcName}`);
+            continue;
+        }
+        const raw = await fs_extra_1.default.readFile(srcPath, 'utf8');
+        const content = adapter.transform
+            ? adapter.transform(raw, srcName)
+            : raw;
+        const baseName = srcName.replace(/\.md$/, '');
+        // Each skill lives in its own subdirectory named after the skill,
+        // with the content file always named SKILL<ext> (e.g. SKILL.md).
+        const skillDir = node_path_1.default.join(dstDir, baseName);
+        await fs_extra_1.default.ensureDir(skillDir);
+        const dstPath = node_path_1.default.join(skillDir, 'SKILL' + adapter.skillExt);
+        await fs_extra_1.default.outputFile(dstPath, content, 'utf8');
+        injected.push(node_path_1.default.relative(base, dstPath));
+        logger_1.logger.debug(`injected skill: ${dstPath}`);
+    }
+    return injected;
+}
+/**
+ * Layered skill injection: search each build-skill in multiple source
+ * directories (ordered low→high priority); the last directory containing
+ * the file wins. Any arch can therefore override a shared skill by placing
+ * a same-named `.md` under its own `build-skills/`.
+ *
+ * Each skill is placed in its own subdirectory:
+ *   <skillsRoot>/<adapter.skillsDir>/<skillName>/<skillName><adapter.skillExt>
+ *
+ * Template placeholder `__HARNESS_ROOT__` is replaced with the harness
+ * directory path relative to cwd (e.g. `./demo8-harness/`).
+ *
+ * @param skillsSrcDirs  Source directories (low→high priority)
+ * @param targetRoot     Harness output root (used for relative-path logging)
+ * @param adapter        Agent-specific configuration
+ * @param skillsRoot     Base directory for the agent skills folder.
+ *                       Defaults to targetRoot (legacy). Pass cwd to inject
+ *                       beside the harness folder instead of inside it.
+ * @param harnessDirName Directory name of the harness (e.g. `demo8-harness`).
+ *                       Used to replace `__HARNESS_ROOT__` in skill content.
+ */
+async function injectSkillsLayered(skillsSrcDirs, targetRoot, adapter, skillsRoot, harnessDirName) {
+    const existing = [];
+    for (const d of skillsSrcDirs) {
+        if (await fs_extra_1.default.pathExists(d))
+            existing.push(d);
+    }
+    if (existing.length === 0) {
+        throw new Error(`no build-skills source directory found among: ${skillsSrcDirs.join(', ')}`);
+    }
+    const base = skillsRoot ?? targetRoot;
+    const dstDir = node_path_1.default.join(base, adapter.skillsDir);
+    await fs_extra_1.default.ensureDir(dstDir);
+    const harnessPrefix = harnessDirName ? `./${harnessDirName}/` : './';
+    const injected = [];
+    for (const srcName of BUILD_SKILLS) {
+        let picked = null;
+        for (let i = existing.length - 1; i >= 0; i--) {
+            const cand = node_path_1.default.join(existing[i], srcName);
+            if (await fs_extra_1.default.pathExists(cand)) {
+                picked = cand;
+                break;
+            }
+        }
+        if (!picked) {
+            logger_1.logger.warn(`build-skill missing in all layers, skipped: ${srcName}`);
+            continue;
+        }
+        const raw = await fs_extra_1.default.readFile(picked, 'utf8');
+        // Replace harness root placeholder with the actual harness directory
+        const resolved = raw.replace(/__HARNESS_ROOT__/g, harnessPrefix);
+        const content = adapter.transform
+            ? adapter.transform(resolved, srcName)
+            : resolved;
+        const baseName = srcName.replace(/\.md$/, '');
+        // Each skill lives in its own subdirectory named after the skill,
+        // with the content file always named SKILL<ext> (e.g. SKILL.md).
+        const skillDir = node_path_1.default.join(dstDir, baseName);
+        await fs_extra_1.default.ensureDir(skillDir);
+        const dstPath = node_path_1.default.join(skillDir, 'SKILL' + adapter.skillExt);
+        await fs_extra_1.default.outputFile(dstPath, content, 'utf8');
+        injected.push(node_path_1.default.relative(base, dstPath));
+        logger_1.logger.debug(`injected skill: ${dstPath} (from ${picked})`);
+    }
+    return injected;
+}
+/**
+ * Layered rule injection: walk the union of `.md` files across the given
+ * source directories (ordered low→high priority), let higher layers override
+ * same-named files from lower layers, and write them flat (no per-file
+ * subdirectory) into `<rulesRoot>/<adapter.rulesDir>/` using `adapter.ruleExt`.
+ *
+ * Unlike skills, rules are written flat because each rule is a single file
+ * consumed directly by the agent's rule loader.
+ *
+ * @param rulesSrcDirs  Source directories (low→high priority), e.g.
+ *                       [_shared/build-rules, <arch>/build-rules]
+ * @param adapter       Agent-specific configuration
+ * @param rulesRoot     Base directory for the agent rules folder, typically cwd.
+ */
+async function injectRulesLayered(rulesSrcDirs, adapter, rulesRoot) {
+    if (!adapter.rulesDir) {
+        logger_1.logger.info(`agent ${adapter.name} 未声明 rulesDir，跳过 rules 注入`);
+        return [];
+    }
+    const existing = [];
+    for (const d of rulesSrcDirs) {
+        if (await fs_extra_1.default.pathExists(d))
+            existing.push(d);
+    }
+    if (existing.length === 0) {
+        logger_1.logger.warn(`no build-rules source directory found among: ${rulesSrcDirs.join(', ')}`);
+        return [];
+    }
+    // Collect the union of .md filenames across all layers.
+    const fileSet = new Set();
+    for (const d of existing) {
+        const entries = await fs_extra_1.default.readdir(d);
+        for (const e of entries) {
+            if (e.toLowerCase().endsWith('.md'))
+                fileSet.add(e);
+        }
+    }
+    const dstDir = node_path_1.default.join(rulesRoot, adapter.rulesDir);
+    await fs_extra_1.default.ensureDir(dstDir);
+    const ruleExt = adapter.ruleExt ?? '.md';
+    const injected = [];
+    for (const srcName of fileSet) {
+        // Resolve highest-priority source for this filename.
+        let picked = null;
+        for (let i = existing.length - 1; i >= 0; i--) {
+            const cand = node_path_1.default.join(existing[i], srcName);
+            if (await fs_extra_1.default.pathExists(cand)) {
+                picked = cand;
+                break;
+            }
+        }
+        if (!picked)
+            continue;
+        const raw = await fs_extra_1.default.readFile(picked, 'utf8');
+        const content = adapter.ruleTransform
+            ? adapter.ruleTransform(raw, srcName)
+            : raw;
+        const baseName = srcName.replace(/\.md$/i, '');
+        const dstPath = node_path_1.default.join(dstDir, baseName + ruleExt);
+        await fs_extra_1.default.outputFile(dstPath, content, 'utf8');
+        injected.push(node_path_1.default.relative(rulesRoot, dstPath));
+        logger_1.logger.debug(`injected rule: ${dstPath} (from ${picked})`);
+    }
+    return injected;
+}