svharness 0.11.0 → 0.13.2

package/dist/commands/apply.js

@@ -10,11 +10,30 @@ const js_yaml_1 = __importDefault(require("js-yaml"));
 const prompts_1 = __importDefault(require("prompts"));
 const adapters_1 = require("../adapters");
 const apply_project_entry_1 = require("../core/apply-project-entry");
-const reference_apply_skills_1 = require("../core/reference-apply-skills");
 const validate_args_1 = require("../utils/validate-args");
 const logger_1 = require("../utils/logger");
 const version_1 = require("../utils/version");
 const DISPATCHER_SKILL_NAME = 'harness-apply-skills-main';
+const BUILD_SKILL_TEMPLATE_FILES = [
+    'harness-build-skills-main.md',
+    'harness-build-skill-orchestrator.md',
+    'harness-build-skill-spec-builder.md',
+    'harness-build-skill-references-intake.md',
+    'harness-build-skill-agent-env-merge.md',
+    'harness-build-skill-knowledge-builder.md',
+    'harness-build-skill-wiki-writer.md',
+];
+const PATH_KEYS = [
+    'agent-env/',
+    'baseline/',
+    'specs/',
+    'tasks/',
+    'harness.yaml',
+    '.harness-build-state.yaml',
+    'AGENTS_BUILD.md',
+    'AGENTS_APPLY.md',
+    'VERSION',
+];
 /**
  * Resolve the absolute path to the bundled templates/ directory.
  * At runtime __dirname is dist/commands, so templates are at ../../templates.
@@ -45,6 +64,27 @@ async function readAgentFromState(harnessRoot) {
         return undefined;
     }
 }
+async function readArchFromState(harnessRoot) {
+    const stateFile = node_path_1.default.join(harnessRoot, '.harness-build-state.yaml');
+    if (!(await fs_extra_1.default.pathExists(stateFile)))
+        return undefined;
+    try {
+        const raw = await fs_extra_1.default.readFile(stateFile, 'utf8');
+        const parsed = js_yaml_1.default.load(raw);
+        const arch = parsed?.arch?.trim();
+        if (arch === 'android-compose' ||
+            arch === 'android-xml' ||
+            arch === 'cpp' ||
+            arch === 'web-react' ||
+            arch === 'python') {
+            return arch;
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * Read `<harness>/VERSION` if present. Falls back to 'unknown'.
  */
@@ -68,6 +108,322 @@ function deriveHarnessName(harnessRoot) {
     const base = node_path_1.default.basename(harnessRoot);
     return base.endsWith('-harness') ? base.slice(0, -'-harness'.length) : base;
 }
+function normalizeHarnessPrefix(harnessRootRel) {
+    if (!harnessRootRel || harnessRootRel === '.')
+        return './';
+    const normalized = harnessRootRel.replace(/\\/g, '/');
+    return normalized.endsWith('/') ? normalized : `${normalized}/`;
+}
+function toPosix(p) {
+    return p.replace(/\\/g, '/');
+}
+function isLikelyPathToken(token) {
+    const t = token.trim();
+    if (!t)
+        return false;
+    if (t.includes(' '))
+        return false;
+    if (t.startsWith('http://') ||
+        t.startsWith('https://') ||
+        t.startsWith('mailto:') ||
+        t.startsWith('#')) {
+        return false;
+    }
+    if (t.includes('<') || t.includes('>') || t.includes('*'))
+        return false;
+    if (t.includes('/'))
+        return true;
+    if (t.startsWith('./') || t.startsWith('../'))
+        return true;
+    return false;
+}
+function toHarnessScopedRef(raw, harnessDirName) {
+    const ref = toPosix(raw.trim());
+    if (ref.startsWith('http://') ||
+        ref.startsWith('https://') ||
+        ref.startsWith('mailto:') ||
+        ref.startsWith('#')) {
+        return raw;
+    }
+    const normalized = ref.replace(/^\.\//, '');
+    const needRewrite = PATH_KEYS.some((k) => normalized.startsWith(k) || normalized === k);
+    if (!needRewrite)
+        return raw;
+    return `./${harnessDirName}/${normalized}`.replace(/\/+/g, '/');
+}
+function rewriteHarnessReferences(content, harnessDirName) {
+    const withLinks = content.replace(/\]\(([^)]+)\)/g, (_m, linkTarget) => {
+        const [pathPart, ...hashParts] = linkTarget.split('#');
+        const rewritten = toHarnessScopedRef(pathPart, harnessDirName);
+        if (hashParts.length > 0) {
+            return `](${rewritten}#${hashParts.join('#')})`;
+        }
+        return `](${rewritten})`;
+    });
+    return withLinks.replace(/`([^`\n]+)`/g, (_m, token) => {
+        if (!isLikelyPathToken(token))
+            return `\`${token}\``;
+        return `\`${toHarnessScopedRef(token, harnessDirName)}\``;
+    });
+}
+function collectReferencedPaths(content) {
+    const refs = [];
+    const linkRegex = /\]\(([^)]+)\)/g;
+    let match;
+    while ((match = linkRegex.exec(content)) !== null) {
+        const clean = match[1].split('#')[0].split('?')[0].trim();
+        if (isLikelyPathToken(clean))
+            refs.push(clean);
+    }
+    const backtickRegex = /`([^`\n]+)`/g;
+    while ((match = backtickRegex.exec(content)) !== null) {
+        const token = match[1].trim();
+        if (isLikelyPathToken(token))
+            refs.push(token);
+    }
+    return refs;
+}
+function resolveRefCandidate(fromFile, ref, targetRoot, harnessDirName) {
+    const normalized = toPosix(ref).trim();
+    if (normalized === `./${harnessDirName}` ||
+        normalized === harnessDirName ||
+        normalized.startsWith(`./${harnessDirName}/`) ||
+        normalized.startsWith(`${harnessDirName}/`)) {
+        const withoutDot = normalized.replace(/^\.\//, '');
+        return node_path_1.default.resolve(targetRoot, withoutDot);
+    }
+    if (/^[A-Za-z]:[\\/]/.test(ref))
+        return node_path_1.default.resolve(ref);
+    if (normalized.startsWith('/')) {
+        return node_path_1.default.resolve(targetRoot, `.${normalized}`);
+    }
+    if (normalized.startsWith('./') || normalized.startsWith('../')) {
+        return node_path_1.default.resolve(node_path_1.default.dirname(fromFile), normalized);
+    }
+    return node_path_1.default.resolve(targetRoot, normalized);
+}
+async function resolveSkillSourceFile(skillDir) {
+    const preferred = [node_path_1.default.join(skillDir, 'SKILL.md'), node_path_1.default.join(skillDir, 'SKILL.mdc')];
+    for (const p of preferred) {
+        if (await fs_extra_1.default.pathExists(p))
+            return p;
+    }
+    const entries = await fs_extra_1.default.readdir(skillDir);
+    const fallback = entries.find((e) => /^SKILL\./i.test(e));
+    return fallback ? node_path_1.default.join(skillDir, fallback) : undefined;
+}
+async function copyRuntimeRules(input) {
+    if (!input.adapter.rulesDir) {
+        logger_1.logger.info(`agent ${input.adapter.name} 未声明 rulesDir，跳过运行期 rules 注入`);
+        return [];
+    }
+    const srcDir = node_path_1.default.join(input.harnessRoot, 'agent-env', 'rules');
+    if (!(await fs_extra_1.default.pathExists(srcDir))) {
+        logger_1.logger.info(`harness 中未找到 agent-env/rules，跳过运行期 rules 注入`);
+        return [];
+    }
+    const dstDir = node_path_1.default.join(input.targetRoot, input.adapter.rulesDir);
+    await fs_extra_1.default.ensureDir(dstDir);
+    const ruleExt = input.adapter.ruleExt ?? '.md';
+    const written = [];
+    const entries = await fs_extra_1.default.readdir(srcDir);
+    for (const name of entries) {
+        const srcPath = node_path_1.default.join(srcDir, name);
+        const stat = await fs_extra_1.default.stat(srcPath);
+        if (!stat.isFile())
+            continue;
+        if (!name.toLowerCase().endsWith('.md') && !name.toLowerCase().endsWith('.mdc')) {
+            continue;
+        }
+        const raw = await fs_extra_1.default.readFile(srcPath, 'utf8');
+        const rewritten = rewriteHarnessReferences(raw, input.harnessDirName);
+        const content = input.adapter.ruleTransform
+            ? input.adapter.ruleTransform(rewritten, name)
+            : rewritten;
+        const dstName = node_path_1.default.parse(name).name + ruleExt;
+        const dstPath = node_path_1.default.join(dstDir, dstName);
+        if ((await fs_extra_1.default.pathExists(dstPath)) && !input.force) {
+            logger_1.logger.warn(`运行期 rule 已存在，跳过：${node_path_1.default.relative(input.targetRoot, dstPath)}`);
+            continue;
+        }
+        await fs_extra_1.default.outputFile(dstPath, content, 'utf8');
+        written.push(node_path_1.default.relative(input.targetRoot, dstPath));
+    }
+    return written;
+}
+async function copyRuntimeSkills(input) {
+    const srcDir = node_path_1.default.join(input.harnessRoot, 'agent-env', 'skills');
+    if (!(await fs_extra_1.default.pathExists(srcDir))) {
+        logger_1.logger.info(`harness 中未找到 agent-env/skills，跳过运行期 skills 注入`);
+        return [];
+    }
+    const dstDir = node_path_1.default.join(input.targetRoot, input.adapter.skillsDir);
+    await fs_extra_1.default.ensureDir(dstDir);
+    const written = [];
+    const entries = await fs_extra_1.default.readdir(srcDir);
+    for (const skillName of entries) {
+        if (input.skipSkills?.has(skillName))
+            continue;
+        const srcSkillDir = node_path_1.default.join(srcDir, skillName);
+        const stat = await fs_extra_1.default.stat(srcSkillDir);
+        if (!stat.isDirectory())
+            continue;
+        const srcSkillFile = await resolveSkillSourceFile(srcSkillDir);
+        if (!srcSkillFile) {
+            logger_1.logger.warn(`运行期 skill 缺少 SKILL 文件，跳过：${skillName}`);
+            continue;
+        }
+        const raw = await fs_extra_1.default.readFile(srcSkillFile, 'utf8');
+        const rewritten = rewriteHarnessReferences(raw, input.harnessDirName);
+        const content = input.adapter.transform
+            ? input.adapter.transform(rewritten, node_path_1.default.basename(srcSkillFile))
+            : rewritten;
+        const dstSkillDir = node_path_1.default.join(dstDir, skillName);
+        const dstSkillFile = node_path_1.default.join(dstSkillDir, 'SKILL' + input.adapter.skillExt);
+        if ((await fs_extra_1.default.pathExists(dstSkillFile)) && !input.force) {
+            logger_1.logger.warn(`运行期 skill 已存在，跳过：${node_path_1.default.relative(input.targetRoot, dstSkillFile)}`);
+            continue;
+        }
+        await fs_extra_1.default.ensureDir(dstSkillDir);
+        await fs_extra_1.default.outputFile(dstSkillFile, content, 'utf8');
+        written.push(node_path_1.default.relative(input.targetRoot, dstSkillFile));
+    }
+    return written;
+}
+async function injectThinMainSkill(input) {
+    const templatePath = node_path_1.default.join(input.templatesRoot, '_shared', 'apply-skills', `${DISPATCHER_SKILL_NAME}.md`);
+    if (!(await fs_extra_1.default.pathExists(templatePath))) {
+        throw new Error(`apply-main 模板缺失：${templatePath}`);
+    }
+    const dstDir = node_path_1.default.join(input.targetRoot, input.adapter.skillsDir, DISPATCHER_SKILL_NAME);
+    const dstFile = node_path_1.default.join(dstDir, 'SKILL' + input.adapter.skillExt);
+    if (await fs_extra_1.default.pathExists(dstDir)) {
+        if (!input.force) {
+            throw new Error(`目标 skill 目录已存在：${dstDir}\n  使用 --force 覆盖，或先清理目标目录。`);
+        }
+        await fs_extra_1.default.remove(dstDir);
+    }
+    const raw = await fs_extra_1.default.readFile(templatePath, 'utf8');
+    const rendered = raw
+        .replace(/__HARNESS_ROOT_REL__/g, `./${input.harnessDirName}`)
+        .replace(/__HARNESS_DIR_NAME__/g, input.harnessDirName);
+    const content = input.adapter.transform
+        ? input.adapter.transform(rendered, `${DISPATCHER_SKILL_NAME}.md`)
+        : rendered;
+    await fs_extra_1.default.ensureDir(dstDir);
+    await fs_extra_1.default.outputFile(dstFile, content, 'utf8');
+    return dstFile;
+}
+async function updateGitIgnore(input) {
+    const gitignorePath = node_path_1.default.join(input.targetRoot, '.gitignore');
+    const raw = (await fs_extra_1.default.pathExists(gitignorePath))
+        ? await fs_extra_1.default.readFile(gitignorePath, 'utf8')
+        : '';
+    const existing = new Set(raw
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0));
+    const candidates = new Set();
+    candidates.add(`/${input.harnessDirName}/`);
+    candidates.add(`/${toPosix(input.adapter.skillsDir).replace(/^\/+/, '').replace(/\/?$/, '/')}`);
+    if (input.adapter.rulesDir) {
+        candidates.add(`/${toPosix(input.adapter.rulesDir).replace(/^\/+/, '').replace(/\/?$/, '/')}`);
+    }
+    const added = [];
+    for (const entry of candidates) {
+        if (!existing.has(entry)) {
+            existing.add(entry);
+            added.push(entry);
+        }
+    }
+    if (added.length === 0)
+        return [];
+    const appendix = '\n# svharness apply injected assets\n' + added.map((line) => `${line}\n`).join('');
+    const next = raw.endsWith('\n') || raw.length === 0 ? raw + appendix : raw + '\n' + appendix;
+    await fs_extra_1.default.outputFile(gitignorePath, next, 'utf8');
+    return added;
+}
+async function validateInjectedReferences(input) {
+    const failures = [];
+    for (const file of input.files) {
+        if (!(await fs_extra_1.default.pathExists(file)))
+            continue;
+        const content = await fs_extra_1.default.readFile(file, 'utf8');
+        const refs = collectReferencedPaths(content);
+        for (const ref of refs) {
+            const normalized = toPosix(ref).replace(/^\.\//, '');
+            const shouldValidate = normalized === input.harnessDirName ||
+                normalized.startsWith(`${input.harnessDirName}/`) ||
+                PATH_KEYS.some((k) => normalized.startsWith(k) || normalized === k);
+            if (!shouldValidate)
+                continue;
+            const resolved = resolveRefCandidate(file, ref, input.targetRoot, input.harnessDirName);
+            if (!(await fs_extra_1.default.pathExists(resolved))) {
+                failures.push(`${node_path_1.default.relative(input.targetRoot, file)} -> ${ref} (missing: ${resolved})`);
+            }
+        }
+    }
+    return failures;
+}
+async function saveBuildSkillsToBuildAgentEnv(input) {
+    const destRoot = node_path_1.default.join(input.targetRoot, 'build-agent-env', 'skills');
+    await fs_extra_1.default.ensureDir(destRoot);
+    const sourceSkillsRoot = node_path_1.default.join(node_path_1.default.dirname(input.harnessRoot), input.adapter.skillsDir);
+    const harnessPrefix = normalizeHarnessPrefix(input.harnessRootRel);
+    const written = [];
+    for (const templateName of BUILD_SKILL_TEMPLATE_FILES) {
+        const skillName = templateName.replace(/\.md$/i, '');
+        const dstSkillDir = node_path_1.default.join(destRoot, skillName);
+        const dstSkillFile = node_path_1.default.join(dstSkillDir, 'SKILL' + input.adapter.skillExt);
+        if ((await fs_extra_1.default.pathExists(dstSkillFile)) && !input.force) {
+            logger_1.logger.warn(`build skill 已存在，跳过：${node_path_1.default.relative(input.targetRoot, dstSkillFile)}`);
+            continue;
+        }
+        let raw;
+        const harnessSkillDir = node_path_1.default.join(sourceSkillsRoot, skillName);
+        if (await fs_extra_1.default.pathExists(harnessSkillDir)) {
+            const srcSkillFile = await resolveSkillSourceFile(harnessSkillDir);
+            if (srcSkillFile) {
+                raw = await fs_extra_1.default.readFile(srcSkillFile, 'utf8');
+            }
+        }
+        if (!raw) {
+            const templatePath = node_path_1.default.join(input.templatesRoot, '_shared', 'build-skills', templateName);
+            if (!(await fs_extra_1.default.pathExists(templatePath))) {
+                logger_1.logger.warn(`build skill 模板缺失，跳过：${templateName}`);
+                continue;
+            }
+            raw = await fs_extra_1.default.readFile(templatePath, 'utf8');
+            raw = raw
+                .replace(/__HARNESS_ROOT__/g, harnessPrefix)
+                .replace(/__HARNESS_BUILD_RULES_DIR__/g, input.adapter.rulesDir ?? '')
+                .replace(/__HARNESS_BUILD_SKILLS_DIR__/g, 'build-agent-env/skills');
+            if (skillName === 'harness-build-skills-main') {
+                const binding = js_yaml_1.default
+                    .dump({
+                    harness_root_rel: harnessPrefix,
+                    harness_name: input.harnessName,
+                    harness_version: input.harnessVersion,
+                    arch: input.harnessArch ?? 'unknown',
+                    agent: input.agent,
+                    build_rules_dir: input.adapter.rulesDir ?? '',
+                    build_skills_dir: 'build-agent-env/skills',
+                    generated_at: input.generatedAt,
+                    generated_by: `svharness@${input.cliVersion}`,
+                }, { lineWidth: 120, noRefs: true })
+                    .trimEnd();
+                raw = raw.replace('{{BINDING_YAML_BLOCK}}', binding);
+            }
+        }
+        const content = input.adapter.transform
+            ? input.adapter.transform(raw, templateName)
+            : raw;
+        await fs_extra_1.default.ensureDir(dstSkillDir);
+        await fs_extra_1.default.outputFile(dstSkillFile, content, 'utf8');
+        written.push(node_path_1.default.relative(input.targetRoot, dstSkillFile));
+    }
+    return written;
+}
 /**
  * Entry point for `svharnessbuild apply`.
  *
@@ -106,23 +462,22 @@ async function runApply(opts) {
     if (!(await fs_extra_1.default.pathExists(targetRoot))) {
         throw new Error(`目标项目目录不存在：${targetRoot}`);
     }
-    // 2b. Optional clone: copy the entire harness directory into the target
-    //     project root. After cloning, `effectiveHarnessRoot` points to the
-    //     cloned copy so binding.yaml resolves to the local path.
+    // 2b. Apply now defaults to copy harness into target.
+    if (opts.clone) {
+        logger_1.logger.warn('`--clone` 已退化为兼容参数：apply 默认执行拷贝。');
+    }
     let effectiveHarnessRoot = harnessRoot;
-    const cloneMode = !!opts.clone;
+    const cloneMode = true;
     const harnessDirName = node_path_1.default.basename(harnessRoot);
     const cloneDest = node_path_1.default.join(targetRoot, harnessDirName);
-    if (cloneMode) {
-        // Guard: never copy a directory onto itself (would recurse forever).
-        const sameDir = node_path_1.default.resolve(cloneDest).toLowerCase() ===
-            node_path_1.default.resolve(harnessRoot).toLowerCase();
-        if (sameDir) {
-            logger_1.logger.warn(`源 harness 与克隆目标路径相同，跳过拷贝：${cloneDest}`);
-        }
-        else {
-            effectiveHarnessRoot = cloneDest;
-        }
+    // Guard: never copy a directory onto itself (would recurse forever).
+    const sameDir = node_path_1.default.resolve(cloneDest).toLowerCase() ===
+        node_path_1.default.resolve(harnessRoot).toLowerCase();
+    if (sameDir) {
+        logger_1.logger.warn(`源 harness 与拷贝目标路径相同，跳过拷贝：${cloneDest}`);
+    }
+    else {
+        effectiveHarnessRoot = cloneDest;
     }
     // 3. Resolve agent (explicit > state file).
     let agent = opts.agent;
@@ -150,6 +505,8 @@ async function runApply(opts) {
     }
     const harnessName = deriveHarnessName(harnessRoot);
     const harnessVersion = await readHarnessVersion(harnessRoot);
+    const harnessArch = await readArchFromState(harnessRoot);
+    const templatesRoot = resolveTemplatesRoot();
     // harness_root / harness_root_rel are always computed against the
     // effective (possibly cloned) location, so agents always resolve to the
     // on-disk harness the user actually has.
@@ -163,12 +520,12 @@ async function runApply(opts) {
         { label: 'harness 版本', value: harnessVersion },
         { label: '目标项目', value: targetRoot },
         { label: 'agent', value: agent },
-        { label: '模式', value: cloneMode ? 'clone（拷贝整个 harness 到目标项目）' : 'bind-only（仅绑定，不拷贝）' },
+        { label: '模式', value: 'copy（默认强制拷贝 harness）' },
     ];
     if (cloneMode && effectiveHarnessRoot !== harnessRoot) {
         configRows.push({ label: '克隆目标', value: effectiveHarnessRoot });
     }
-    configRows.push({ label: '注入 skill', value: node_path_1.default.relative(targetRoot, skillFile) }, { label: '绑定元数据（冗余副本）', value: node_path_1.default.relative(targetRoot, bindingFile) }, { label: '项目根 AI 入口', value: adapter.projectEntryFile }, { label: '工具版本', value: `svharness@${cliVersion}` });
+    configRows.push({ label: '注入 skill', value: node_path_1.default.relative(targetRoot, skillFile) }, { label: '运行期 skills 注入', value: adapter.skillsDir }, { label: '运行期 rules 注入', value: adapter.rulesDir ?? '（agent 未声明 rulesDir）' }, { label: '.gitignore', value: '将追加注入路径（幂等）' }, { label: '项目根 AI 入口', value: `${adapter.projectEntryFile}（由 AGENTS_APPLY.md 重命名）` }, { label: '工具版本', value: `svharness@${cliVersion}` });
     logger_1.logger.configBox('apply 配置确认', configRows);
     if (!opts.yes) {
         const { ok } = await (0, prompts_1.default)({
@@ -191,11 +548,11 @@ async function runApply(opts) {
         await fs_extra_1.default.remove(dispatcherDir);
     }
     // 7b. Clone step — copy the whole harness into the target project first,
-    //     so subsequent skill injection and binding resolve to the local copy.
-    const totalSteps = cloneMode && effectiveHarnessRoot !== harnessRoot ? 3 : 2;
+    //     so subsequent injections resolve to the local copy.
+    const totalSteps = 5;
     let stepNo = 1;
     if (cloneMode && effectiveHarnessRoot !== harnessRoot) {
-        logger_1.logger.section(`步骤 ${stepNo}/${totalSteps} - 克隆 harness 到目标项目`);
+        logger_1.logger.section(`步骤 ${stepNo}/${totalSteps} - 拷贝 harness 到目标项目`);
         if (await fs_extra_1.default.pathExists(cloneDest)) {
             if (!opts.force) {
                 throw new Error(`克隆目标已存在：${cloneDest}\n  使用 --force 覆盖，或改用 bind-only（去掉 --clone）。`);
@@ -207,110 +564,93 @@ async function runApply(opts) {
             overwrite: true,
             errorOnExist: false,
         });
-        logger_1.logger.success(`已克隆 harness：${node_path_1.default.relative(targetRoot, cloneDest)}`);
+        logger_1.logger.success(`已拷贝 harness：${node_path_1.default.relative(targetRoot, cloneDest)}`);
         stepNo++;
     }
-    // 8. Build binding metadata first (needed for both inline rendering into
-    //    the skill body and the redundant sidecar file).
-    const skillRegistry = await (0, reference_apply_skills_1.loadApplySkillRegistry)(effectiveHarnessRoot);
-    const applySkillRegistry = skillRegistry
-        ? (0, reference_apply_skills_1.registryEntriesForBinding)(skillRegistry)
-        : [];
-    const binding = {
-        harness_name: harnessName,
-        harness_root: effectiveHarnessRoot,
-        harness_root_rel: harnessRootRel,
-        harness_version: harnessVersion,
-        target_project: targetRoot,
-        agent,
-        mode: cloneMode ? 'clone' : 'bind-only',
-        applied_at: appliedAt,
-        applied_by: `svharness@${cliVersion}`,
-        apply_skill_registry: applySkillRegistry,
-    };
-    const bindingYaml = '# Generated by `svharness apply`. DO NOT edit by hand.\n' +
-        '# Re-run `svharness apply --force` to refresh.\n' +
-        js_yaml_1.default.dump(binding, { lineWidth: 120, noRefs: true });
-    // 8b. Write skill content with binding inlined into the template body
-    //     (agent-specific transform keeps frontmatter rules consistent across
-    //     IDEs). The inlined `## 绑定元数据` block is the runtime source of
-    //     truth — agents parse it from the skill content itself, never from
-    //     the sidecar file.
-    logger_1.logger.section(`步骤 ${stepNo}/${totalSteps} - 注入 dispatcher skill`);
-    const rawSkill = await fs_extra_1.default.readFile(templatePath, 'utf8');
-    const bindingPlaceholder = '{{BINDING_YAML_BLOCK}}';
-    if (!rawSkill.includes(bindingPlaceholder)) {
-        throw new Error(`dispatcher skill 模板缺少占位符 ${bindingPlaceholder}：${templatePath}\n` +
-            '  请升级 svharness 到同时包含内联 binding 机制的版本。');
-    }
-    const bindingBlock = '```yaml\n' +
-        js_yaml_1.default.dump(binding, { lineWidth: 120, noRefs: true }).trimEnd() +
-        '\n```';
-    const renderedSkill = rawSkill.replace(bindingPlaceholder, bindingBlock);
-    const skillContent = adapter.transform
-        ? adapter.transform(renderedSkill, `${DISPATCHER_SKILL_NAME}.md`)
-        : renderedSkill;
-    await fs_extra_1.default.ensureDir(dispatcherDir);
-    await fs_extra_1.default.outputFile(skillFile, skillContent, 'utf8');
-    logger_1.logger.success(`已写入 ${node_path_1.default.relative(targetRoot, skillFile)}`);
+    logger_1.logger.section(`步骤 ${stepNo}/${totalSteps} - 注入薄入口与运行期 skills/rules`);
+    const thinMainPath = await injectThinMainSkill({
+        templatesRoot,
+        targetRoot,
+        adapter,
+        harnessDirName,
+        force: !!opts.force,
+    });
+    const runtimeRules = await copyRuntimeRules({
+        harnessRoot: effectiveHarnessRoot,
+        targetRoot,
+        adapter,
+        harnessDirName,
+        force: !!opts.force,
+    });
+    const runtimeSkills = await copyRuntimeSkills({
+        harnessRoot: effectiveHarnessRoot,
+        targetRoot,
+        adapter,
+        harnessDirName,
+        force: !!opts.force,
+        skipSkills: new Set([DISPATCHER_SKILL_NAME]),
+    });
+    logger_1.logger.success(`已写入薄入口：${node_path_1.default.relative(targetRoot, thinMainPath)}`);
+    logger_1.logger.success(`已注入运行期 rules ${runtimeRules.length} 条`);
+    logger_1.logger.success(`已注入运行期 skills ${runtimeSkills.length} 条`);
     stepNo++;
-    // 9. Write binding.yaml as a redundant sidecar copy (scheme B tooling:
-    //    detach / status / re-apply detection). Runtime dispatcher does NOT
-    //    read this file — the authoritative source is the inlined block
-    //    written in step 8b.
-    logger_1.logger.section(`步骤 ${stepNo}/${totalSteps} - 写入 harness 绑定元数据（冗余副本）`);
-    await fs_extra_1.default.outputFile(bindingFile, bindingYaml, 'utf8');
-    logger_1.logger.success(`已写入 ${node_path_1.default.relative(targetRoot, bindingFile)}（冗余副本）`);
-    if (applySkillRegistry.length > 0) {
-        logger_1.logger.success(`已内联 apply_skill_registry ${applySkillRegistry.length} 条（references 内容由 apply-main 路由）`);
-    }
-    else {
-        logger_1.logger.info('未找到 references/apply-skills-registry.yaml，apply_skill_registry 为空');
-        logger_1.logger.info('  请在 S60 为「内容引用」登记 registry 后重新 apply');
-    }
-    // 9b. Inject AGENTS_APPLY.md into target project root (if present in harness).
-    const agentsApplySrc = node_path_1.default.join(harnessRoot, 'AGENTS_APPLY.md');
-    if (await fs_extra_1.default.pathExists(agentsApplySrc)) {
-        const agentsApplyDest = node_path_1.default.join(targetRoot, 'AGENTS_APPLY.md');
-        let shouldCopy = true;
-        if (await fs_extra_1.default.pathExists(agentsApplyDest)) {
-            if (!opts.force) {
-                logger_1.logger.warn(`目标项目已存在 AGENTS_APPLY.md，跳过（使用 --force 覆盖）`);
-                shouldCopy = false;
-            }
-        }
-        if (shouldCopy) {
-            await fs_extra_1.default.copy(agentsApplySrc, agentsApplyDest, { overwrite: true });
-            logger_1.logger.success(`已写入 ${node_path_1.default.relative(targetRoot, agentsApplyDest)}`);
-        }
-    }
-    else {
-        logger_1.logger.debug('harness 中未找到 AGENTS_APPLY.md，跳过注入');
-    }
+    logger_1.logger.section(`步骤 ${stepNo}/${totalSteps} - 写入项目根 AI 入口`);
     await (0, apply_project_entry_1.writeApplyProjectEntry)({
         projectRoot: targetRoot,
+        harnessRoot: effectiveHarnessRoot,
+        harnessDirName,
         adapter,
-        harnessRootRel,
-        harnessName,
-        harnessVersion,
-        agent,
-        mode: cloneMode ? 'clone' : 'bind-only',
         force: !!opts.force,
     });
+    const entryFile = node_path_1.default.join(targetRoot, adapter.projectEntryFile);
+    stepNo++;
+    logger_1.logger.section(`步骤 ${stepNo}/${totalSteps} - 更新 .gitignore`);
+    const ignoreAdded = await updateGitIgnore({
+        targetRoot,
+        harnessDirName,
+        adapter,
+    });
+    if (ignoreAdded.length === 0) {
+        logger_1.logger.info('.gitignore 无新增条目（已是最新）');
+    }
+    else {
+        logger_1.logger.success(`.gitignore 已新增 ${ignoreAdded.length} 条注入路径`);
+    }
+    stepNo++;
+    logger_1.logger.section(`步骤 ${stepNo}/${totalSteps} - 校验注入文件引用关系`);
+    const filesToCheck = [
+        entryFile,
+        thinMainPath,
+        ...runtimeRules.map((rel) => node_path_1.default.join(targetRoot, rel)),
+        ...runtimeSkills.map((rel) => node_path_1.default.join(targetRoot, rel)),
+    ];
+    const refFailures = await validateInjectedReferences({
+        targetRoot,
+        harnessDirName,
+        files: filesToCheck,
+    });
+    if (refFailures.length > 0) {
+        const preview = refFailures.slice(0, 20).join('\n');
+        logger_1.logger.warn(`引用校验发现 ${refFailures.length} 条潜在问题（请人工复核）：\n${preview}\n` +
+            (refFailures.length > 20 ? '...（其余省略）' : ''));
+    }
+    else {
+        logger_1.logger.success('引用关系校验通过');
+    }
     // 10. Next steps hint.
     logger_1.logger.plain('');
     logger_1.logger.plain('✨ harness 已绑定到当前项目');
     logger_1.logger.plain('');
     logger_1.logger.plain('  下一步：在 agent 中输入');
     logger_1.logger.plain(`    应用 ${DISPATCHER_SKILL_NAME} 完成 <你的功能> 功能开发`);
-    logger_1.logger.plain(`  或阅读 ${adapter.projectEntryFile} 与 AGENTS_APPLY.md 了解完整的 harness 应用工作流`);
+    logger_1.logger.plain(`  或阅读 ${adapter.projectEntryFile} 了解完整的 harness 应用工作流`);
     logger_1.logger.plain('');
-    if (cloneMode && effectiveHarnessRoot !== harnessRoot) {
-        logger_1.logger.plain(`  harness 内容已克隆至：${node_path_1.default.relative(targetRoot, effectiveHarnessRoot)}/（已纳入目标项目）`);
-        logger_1.logger.plain(`  源 harness 仍保留在：${harnessRoot}（可独立演进后再次 apply --clone --force 更新）`);
+    if (effectiveHarnessRoot !== harnessRoot) {
+        logger_1.logger.plain(`  harness 内容已拷贝至：${node_path_1.default.relative(targetRoot, effectiveHarnessRoot)}/（已纳入目标项目）`);
+        logger_1.logger.plain(`  源 harness 保留在：${harnessRoot}`);
     }
     else {
-        logger_1.logger.plain(`  harness 内容仍位于：${harnessRoot}（未拷贝；如需完整内聚请加 --clone）`);
+        logger_1.logger.plain(`  harness 内容位于：${harnessRoot}（已在目标目录内，跳过拷贝）`);
     }
     logger_1.logger.plain(`  解绑命令：手动删除 ${node_path_1.default.relative(targetRoot, dispatcherDir)}`);
     logger_1.logger.plain('');