svharness 0.8.0 → 0.11.0

package/dist/commands/convert.js

@@ -0,0 +1,369 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runConvert = runConvert;
+/**
+ * `svharness convert`
+ *
+ * Upload local source documents (pdf / docx / pptx / xlsx / html / txt / ...)
+ * to a remotely-deployed `markitdown_serve` instance and persist the returned
+ * Markdown under `<harness>/requirements/md/`.
+ *
+ * Design rules (aligned with the approved plan):
+ *   - The CLI is a pure HTTP client. It never spawns / installs / manages the
+ *     Python-side service.
+ *   - Independent subcommand — does NOT run as part of `build`.
+ *   - Single-file failures do not abort the whole batch; the summary prints
+ *     success / skipped / failed counts at the end.
+ *   - Existing output files are kept by default and receive a `-N` suffix on
+ *     name collision; pass `--force` to overwrite instead.
+ */
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const node_path_1 = __importDefault(require("node:path"));
+const prompts_1 = __importDefault(require("prompts"));
+const logger_1 = require("../utils/logger");
+const validate_args_1 = require("../utils/validate-args");
+const markitdown_client_1 = require("../core/markitdown-client");
+const doc_intake_paths_1 = require("../core/doc-intake-paths");
+/**
+ * Extensions recognised by Microsoft MarkItDown (v0.x). Anything outside this
+ * whitelist is skipped client-side to avoid a round-trip that is guaranteed to
+ * return 415. Keep in sync with the server-side whitelist in
+ * `markitdown_serve/app/main.py`.
+ */
+const SUPPORTED_EXTS = new Set([
+    '.pdf',
+    '.docx',
+    '.doc',
+    '.pptx',
+    '.ppt',
+    '.xlsx',
+    '.xls',
+    '.html',
+    '.htm',
+    '.epub',
+    '.csv',
+    '.json',
+    '.xml',
+    '.txt',
+    '.md',
+    '.rtf',
+    '.msg',
+    '.eml',
+    '.zip',
+    '.jpg',
+    '.jpeg',
+    '.png',
+    '.bmp',
+    '.tiff',
+    '.mp3',
+    '.wav',
+    '.m4a',
+]);
+async function runConvert(opts) {
+    (0, logger_1.setVerbose)(!!opts.verbose);
+    const v = (0, validate_args_1.validateConvertArgs)({
+        input: opts.input,
+        harness: opts.harness,
+        output: opts.output,
+        endpoint: opts.endpoint,
+        concurrency: opts.concurrency,
+        maxFileMB: opts.maxFileMB,
+        timeoutSec: opts.timeoutSec,
+        type: opts.type,
+    });
+    const cwd = opts.cwd ?? process.cwd();
+    const outDir = node_path_1.default.join(v.harness, v.type, 'md');
+    await fs_extra_1.default.ensureDir(outDir);
+    logger_1.logger.configBox('svharness convert', [
+        { label: 'harness    ', value: v.harness },
+        { label: 'endpoint   ', value: v.endpoint },
+        { label: 'type       ', value: v.type },
+        { label: 'output dir ', value: outDir },
+        { label: 'concurrency', value: String(v.concurrency) },
+        { label: 'max file   ', value: `${v.maxFileMB} MB` },
+        { label: 'timeout    ', value: `${v.timeoutSec}s` },
+        { label: 'force      ', value: opts.force ? 'yes' : 'no' },
+    ]);
+    // 1. Collect candidate files.
+    const candidates = await collectFiles(v.input, cwd);
+    if (candidates.length === 0) {
+        logger_1.logger.warn('no files matched the given --input patterns');
+        return;
+    }
+    logger_1.logger.info(`discovered ${candidates.length} candidate file(s)`);
+    // 2. Partition into convertible vs skipped (size / ext).
+    const limitBytes = v.maxFileMB * 1024 * 1024;
+    const plan = await buildPlan(candidates, limitBytes);
+    const skipped = plan.filter((p) => p.status === 'skipped');
+    const toUpload = plan.filter((p) => p.status !== 'skipped');
+    for (const s of skipped) {
+        logger_1.logger.debug(`skip ${s.source}: ${s.reason}`);
+    }
+    if (skipped.length > 0) {
+        logger_1.logger.warn(`skipping ${skipped.length} file(s) locally (unsupported ext or oversized)`);
+    }
+    if (toUpload.length === 0) {
+        logger_1.logger.warn('nothing to upload after local filtering');
+        printSummary(skipped.map(planToResult));
+        return;
+    }
+    // 3. Interactive confirmation (skipped with -y).
+    if (!opts.yes) {
+        const ans = await (0, prompts_1.default)({
+            type: 'confirm',
+            name: 'go',
+            message: `Upload ${toUpload.length} file(s) to ${v.endpoint}?`,
+            initial: true,
+        });
+        if (!ans.go) {
+            logger_1.logger.info('aborted by user');
+            return;
+        }
+    }
+    // 4. Probe health endpoint before any upload.
+    try {
+        const h = await (0, markitdown_client_1.ping)(v.endpoint);
+        logger_1.logger.debug(`healthz ok: status=${h.status} markitdown=${h.markitdown_version ?? 'n/a'}`);
+    }
+    catch (err) {
+        const e = err;
+        logger_1.logger.error(`markitdown_serve unreachable at ${v.endpoint}: ${e.message}`);
+        logger_1.logger.plain('');
+        logger_1.logger.plain('  - confirm the service is deployed and reachable from this machine');
+        logger_1.logger.plain('  - pass --endpoint <url> or set env SVHARNESS_MARKITDOWN_ENDPOINT');
+        logger_1.logger.plain('  - check the server code under svharnessbuild/markitdown_serve/');
+        process.exitCode = 1;
+        return;
+    }
+    // 5. Bounded-concurrency upload.
+    const results = skipped.map(planToResult);
+    const used = new Set();
+    const queue = toUpload.slice();
+    const workers = [];
+    const runOne = async () => {
+        while (queue.length > 0) {
+            const item = queue.shift();
+            if (!item)
+                break;
+            results.push(await uploadOne(item.source, outDir, used, v, opts));
+        }
+    };
+    for (let i = 0; i < Math.min(v.concurrency, toUpload.length); i++) {
+        workers.push(runOne());
+    }
+    await Promise.all(workers);
+    // 6. Summary.
+    printSummary(results);
+    const relocated = await (0, doc_intake_paths_1.relocateMisplacedConvertedMd)(v.harness, v.type);
+    if (relocated > 0) {
+        logger_1.logger.warn(`已将 ${relocated} 个误落在 raw/**/converted_md/ 下的 .md 移至 ${v.type}/md/`);
+    }
+    const failed = results.filter((r) => r.status === 'failed');
+    if (failed.length > 0) {
+        process.exitCode = 1;
+    }
+}
+/** Walk glob patterns / explicit paths / directories into an absolute file list. */
+async function collectFiles(patterns, cwd) {
+    const out = new Set();
+    for (const p of patterns) {
+        if (isGlob(p)) {
+            const matched = await globExpand(p, cwd);
+            for (const m of matched)
+                out.add(m);
+            continue;
+        }
+        const abs = node_path_1.default.isAbsolute(p) ? p : node_path_1.default.resolve(cwd, p);
+        if (!(await fs_extra_1.default.pathExists(abs))) {
+            logger_1.logger.warn(`input not found, skipped: ${p}`);
+            continue;
+        }
+        const st = await fs_extra_1.default.stat(abs);
+        if (st.isDirectory()) {
+            for (const f of await walkDir(abs))
+                out.add(f);
+        }
+        else if (st.isFile()) {
+            out.add(abs);
+        }
+    }
+    return [...out].sort();
+}
+function isGlob(p) {
+    return /[*?[\]{}]/.test(p);
+}
+/**
+ * Minimal glob expander to avoid pulling in a dependency. Supports the
+ * common forms users actually type: `./docs/*.pdf`, `docs/**\/*.docx`,
+ * `a/{x,y}.md`. Falls back to treating the pattern as a literal path if no
+ * metachars remain after expansion.
+ *
+ * Implementation: split pattern into base directory (up to first metachar)
+ * and the glob tail, then walk the base directory and regex-match each file.
+ */
+async function globExpand(pattern, cwd) {
+    // Expand simple brace groups `{a,b,c}` into multiple patterns first.
+    const expanded = expandBraces(pattern);
+    const results = new Set();
+    for (const pat of expanded) {
+        for (const f of await globOne(pat, cwd))
+            results.add(f);
+    }
+    return [...results];
+}
+function expandBraces(pattern) {
+    const m = /\{([^{}]+)\}/.exec(pattern);
+    if (!m)
+        return [pattern];
+    const [whole, inner] = m;
+    const options = inner.split(',');
+    const head = pattern.slice(0, m.index);
+    const tail = pattern.slice(m.index + whole.length);
+    return options.flatMap((opt) => expandBraces(head + opt + tail));
+}
+async function globOne(pattern, cwd) {
+    const norm = pattern.replace(/\\/g, '/');
+    const firstMeta = norm.search(/[*?[]/);
+    if (firstMeta === -1) {
+        const abs = node_path_1.default.isAbsolute(norm) ? norm : node_path_1.default.resolve(cwd, norm);
+        return (await fs_extra_1.default.pathExists(abs)) ? [abs] : [];
+    }
+    const lastSlashBeforeMeta = norm.lastIndexOf('/', firstMeta);
+    const basePart = lastSlashBeforeMeta === -1 ? '.' : norm.slice(0, lastSlashBeforeMeta) || '/';
+    const tail = lastSlashBeforeMeta === -1 ? norm : norm.slice(lastSlashBeforeMeta + 1);
+    const baseAbs = node_path_1.default.isAbsolute(basePart)
+        ? basePart
+        : node_path_1.default.resolve(cwd, basePart);
+    if (!(await fs_extra_1.default.pathExists(baseAbs)))
+        return [];
+    const re = globToRegex(tail);
+    const all = await walkDir(baseAbs);
+    return all.filter((f) => re.test(node_path_1.default.relative(baseAbs, f).replace(/\\/g, '/')));
+}
+function globToRegex(glob) {
+    let re = '^';
+    for (let i = 0; i < glob.length; i++) {
+        const c = glob[i];
+        if (c === '*') {
+            if (glob[i + 1] === '*') {
+                re += '.*';
+                i++;
+                if (glob[i + 1] === '/')
+                    i++;
+            }
+            else {
+                re += '[^/]*';
+            }
+        }
+        else if (c === '?') {
+            re += '[^/]';
+        }
+        else if ('.+^$()|\\'.includes(c)) {
+            re += '\\' + c;
+        }
+        else {
+            re += c;
+        }
+    }
+    re += '$';
+    return new RegExp(re);
+}
+async function walkDir(dir) {
+    const out = [];
+    const entries = await fs_extra_1.default.readdir(dir, { withFileTypes: true });
+    for (const e of entries) {
+        const abs = node_path_1.default.join(dir, e.name);
+        if (e.isDirectory()) {
+            // Skip harness artifact dirs and noisy dot-dirs.
+            if ((0, doc_intake_paths_1.shouldSkipRawSubdir)(e.name)) {
+                continue;
+            }
+            out.push(...(await walkDir(abs)));
+        }
+        else if (e.isFile()) {
+            out.push(abs);
+        }
+    }
+    return out;
+}
+function planToResult(p) {
+    return p.status === 'skipped'
+        ? { source: p.source, status: 'skipped', reason: p.reason }
+        : { source: p.source, status: 'ok' };
+}
+async function buildPlan(files, limitBytes) {
+    const out = [];
+    for (const f of files) {
+        const ext = node_path_1.default.extname(f).toLowerCase();
+        if (!SUPPORTED_EXTS.has(ext)) {
+            out.push({ source: f, status: 'skipped', reason: `unsupported ext ${ext || '(none)'}` });
+            continue;
+        }
+        const st = await fs_extra_1.default.stat(f);
+        if (st.size > limitBytes) {
+            out.push({
+                source: f,
+                status: 'skipped',
+                reason: `exceeds max-file-mb (${Math.round(st.size / 1024 / 1024)}MB)`,
+            });
+            continue;
+        }
+        out.push({ source: f, status: 'ready' });
+    }
+    return out;
+}
+async function uploadOne(source, outDir, used, v, opts) {
+    const basename = node_path_1.default.basename(source, node_path_1.default.extname(source));
+    const outPath = await resolveOutputPath(outDir, basename, used, !!opts.force);
+    used.add(outPath);
+    logger_1.logger.debug(`upload ${source} -> ${outPath}`);
+    try {
+        const resp = await (0, markitdown_client_1.postConvertWithRetry)(v.endpoint, source, v.timeoutSec * 1000);
+        await fs_extra_1.default.writeFile(outPath, resp.markdown, 'utf8');
+        const bytes = Buffer.byteLength(resp.markdown, 'utf8');
+        logger_1.logger.success(`${node_path_1.default.basename(source)} -> ${node_path_1.default.basename(outPath)} (${bytes}B)`);
+        return { source, output: outPath, status: 'ok', bytes };
+    }
+    catch (err) {
+        const e = err;
+        const reason = e.message;
+        logger_1.logger.error(`failed: ${node_path_1.default.basename(source)} — ${reason}`);
+        return { source, status: 'failed', reason };
+    }
+}
+/**
+ * Decide the final .md path. With `--force` we always write to
+ * `<basename>.md`; otherwise we append `-1`, `-2`, ... until a free slot is
+ * found (also respecting files reserved by the current run via `used`).
+ */
+async function resolveOutputPath(outDir, basename, used, force) {
+    const primary = node_path_1.default.join(outDir, `${basename}.md`);
+    if (force)
+        return primary;
+    if (!used.has(primary) && !(await fs_extra_1.default.pathExists(primary)))
+        return primary;
+    for (let i = 1; i < 1000; i++) {
+        const cand = node_path_1.default.join(outDir, `${basename}-${i}.md`);
+        if (!used.has(cand) && !(await fs_extra_1.default.pathExists(cand)))
+            return cand;
+    }
+    throw new Error(`unable to allocate unique output filename for ${basename} under ${outDir}`);
+}
+function printSummary(results) {
+    const ok = results.filter((r) => r.status === 'ok').length;
+    const failed = results.filter((r) => r.status === 'failed').length;
+    const skipped = results.filter((r) => r.status === 'skipped').length;
+    logger_1.logger.section('convert summary');
+    logger_1.logger.plain(`  ok      : ${ok}`);
+    logger_1.logger.plain(`  skipped : ${skipped}`);
+    logger_1.logger.plain(`  failed  : ${failed}`);
+    if (failed > 0) {
+        logger_1.logger.plain('');
+        for (const r of results.filter((x) => x.status === 'failed')) {
+            logger_1.logger.plain(`  - ${node_path_1.default.basename(r.source)}: ${r.reason}`);
+        }
+    }
+}

package/dist/commands/init.js

@@ -16,8 +16,12 @@ 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 build_project_entry_1 = require("../core/build-project-entry");
 const repomix_pack_1 = require("../core/repomix-pack");
+const extra_assets_intake_1 = require("../core/extra-assets-intake");
 const baseline_copy_1 = require("../utils/baseline-copy");
+const doc_intake_paths_1 = require("../core/doc-intake-paths");
+const convert_1 = require("./convert");
 const wiki_1 = require("../wiki");
 /**
  * Resolve the absolute path to the bundled templates/ directory.
@@ -26,6 +30,42 @@ const wiki_1 = require("../wiki");
 function resolveTemplatesRoot() {
     return node_path_1.default.resolve(__dirname, '..', '..', 'templates');
 }
+async function runBuildAutoConvert(targetRoot, rawDir, type, opts) {
+    logger_1.logger.info(`开始自动转换 ${type}：${rawDir} -> ${node_path_1.default.join(targetRoot, type, 'md')}`);
+    const prevExitCode = process.exitCode;
+    process.exitCode = undefined;
+    try {
+        await (0, convert_1.runConvert)({
+            input: [rawDir],
+            output: targetRoot,
+            type,
+            endpoint: opts.convertEndpoint,
+            concurrency: opts.convertConcurrency,
+            maxFileMB: opts.convertMaxFileMB,
+            timeoutSec: opts.convertTimeoutSec,
+            force: opts.convertForce,
+            yes: true,
+            verbose: opts.verbose,
+            cwd: opts.cwd,
+        });
+        const relocated = await (0, doc_intake_paths_1.relocateMisplacedConvertedMd)(targetRoot, type);
+        if (relocated > 0) {
+            logger_1.logger.warn(`已将 ${relocated} 个误落在 raw/**/converted_md/ 下的 .md 移至 ${type}/md/`);
+        }
+        if ((process.exitCode ?? 0) !== 0) {
+            logger_1.logger.warn(`自动转换 ${type} 存在失败项，已继续 build 流程`);
+        }
+        else {
+            logger_1.logger.success(`自动转换 ${type} 完成`);
+        }
+    }
+    catch (err) {
+        logger_1.logger.warn(`自动转换 ${type} 失败，已继续 build：${err.message}`);
+    }
+    finally {
+        process.exitCode = prevExitCode;
+    }
+}
 async function runInit(opts) {
     (0, logger_1.setVerbose)(!!opts.verbose);
     // 0. Mutual-exclusion between wiki modes.
@@ -49,11 +89,11 @@ async function runInit(opts) {
     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
+    // Baseline code lands at <target>/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 baselineCodeDir = node_path_1.default.join(targetRoot, '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)
@@ -79,6 +119,24 @@ async function runInit(opts) {
         { label: 'Agent', value: validated.agent },
         { label: '目标路径', value: targetRoot },
     ];
+    if (opts.requirements) {
+        configItems.push({
+            label: 'Requirements 路径',
+            value: node_path_1.default.resolve(cwd, opts.requirements),
+        });
+    }
+    if (opts.references) {
+        configItems.push({
+            label: 'References 路径',
+            value: node_path_1.default.resolve(cwd, opts.references),
+        });
+    }
+    if ((opts.extraSkills?.length ?? 0) > 0) {
+        configItems.push({
+            label: 'Extra 资源',
+            value: opts.extraSkills.map((item) => node_path_1.default.resolve(cwd, item)).join(', '),
+        });
+    }
     if (validated.baseline) {
         const modeTag = validated.baselineMode === 'git' ? 'git' : 'local';
         configItems.push({ label: `基线 (${modeTag})`, value: validated.baseline });
@@ -166,6 +224,8 @@ async function runInit(opts) {
         arch: validated.arch,
         agent: validated.agent,
         sourcePath: validated.baseline ?? '',
+        requirementsPath: opts.requirements ? node_path_1.default.resolve(cwd, opts.requirements) : '',
+        referencesPath: opts.references ? node_path_1.default.resolve(cwd, opts.references) : '',
         createdAt,
         version: cliVersion,
     };
@@ -175,16 +235,35 @@ async function runInit(opts) {
     //   optional: baseline copy, repomix pack, wiki generation
     //   last: state file
     let stepCursor = 4;
+    const hasExtraAssets = (opts.extraSkills?.length ?? 0) > 0;
+    const stepExtraAssets = hasExtraAssets ? ++stepCursor : 0;
     const stepBaseline = hasBaseline ? ++stepCursor : 0;
     const stepRepomix = hasBaseline ? ++stepCursor : 0;
     const stepWiki = wikiEnabled ? ++stepCursor : 0;
     const stepState = ++stepCursor;
     const totalSteps = stepCursor;
     let baselineMeta;
+    let extraAssetsResult;
     try {
         logger_1.logger.section(`步骤 1/${totalSteps} - 生成目录骨架`);
         const copied = await (0, scaffold_1.scaffoldLayered)(skeletonSrcs, targetRoot);
         logger_1.logger.success(`已拷贝骨架文件 ${copied.length} 个`);
+        if (opts.requirements) {
+            const requirementRawDir = node_path_1.default.join(targetRoot, 'requirements', 'raw');
+            const copiedReq = await (0, doc_intake_paths_1.copySeedInputToRaw)(node_path_1.default.resolve(cwd, opts.requirements), requirementRawDir, 'requirements');
+            logger_1.logger.success(`已注入 requirements 输入到 raw：${copiedReq} 项`);
+            if (copiedReq > 0) {
+                await runBuildAutoConvert(targetRoot, requirementRawDir, 'requirements', opts);
+            }
+        }
+        if (opts.references) {
+            const referenceRawDir = node_path_1.default.join(targetRoot, 'references', 'raw');
+            const copiedRef = await (0, doc_intake_paths_1.copySeedInputToRaw)(node_path_1.default.resolve(cwd, opts.references), referenceRawDir, 'references');
+            logger_1.logger.success(`已注入 references 输入到 raw：${copiedRef} 项`);
+            if (copiedRef > 0) {
+                await runBuildAutoConvert(targetRoot, referenceRawDir, 'references', opts);
+            }
+        }
         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(', ')}`);
@@ -193,16 +272,34 @@ async function runInit(opts) {
         // 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);
+        const buildSkillsBinding = {
+            harnessDirName,
+            harnessName: validated.name,
+            arch: validated.arch,
+            agent: validated.agent,
+            cliVersion,
+            generatedAt: createdAt,
+        };
+        const injected = await (0, agent_injector_1.injectSkillsLayered)(buildSkillsSrcs, targetRoot, adapter, cwd, buildSkillsBinding);
         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 (hasExtraAssets && opts.extraSkills) {
+            logger_1.logger.section(`步骤 ${stepExtraAssets}/${totalSteps} - 导入额外运行期资源到 _incoming`);
+            extraAssetsResult = await (0, extra_assets_intake_1.intakeExtraAssets)({
+                inputs: opts.extraSkills,
+                cwd,
+                harnessRoot: targetRoot,
+            });
+            logger_1.logger.success(`incoming 清单: ${extraAssetsResult.manifestRelPath}（总计 ${extraAssetsResult.incomingTotal}，` +
+                `skills ${extraAssetsResult.skillsCount}，rules ${extraAssetsResult.rulesCount}，unknown ${extraAssetsResult.unknownCount}）`);
+        }
         if (hasBaseline && validated.baseline && validated.baselineMode) {
             logger_1.logger.section(`步骤 ${stepBaseline}/${totalSteps} - 拷贝基线源码`);
-            const destDir = node_path_1.default.join(targetRoot, 'assets', 'baseline', 'code');
+            const destDir = node_path_1.default.join(targetRoot, 'baseline', 'code');
             baselineMeta = await (0, baseline_copy_1.copyBaseline)({
                 mode: validated.baselineMode,
                 source: validated.baseline,
@@ -222,6 +319,18 @@ async function runInit(opts) {
         await (0, scaffold_1.rollbackTarget)(targetRoot);
         throw err;
     }
+    {
+        const adapterEntry = (0, adapters_1.getAdapter)(validated.agent);
+        await (0, build_project_entry_1.writeBuildProjectEntry)({
+            projectRoot: cwd,
+            adapter: adapterEntry,
+            harnessDirName: node_path_1.default.basename(targetRoot),
+            harnessName: validated.name,
+            arch: validated.arch,
+            agent: validated.agent,
+            force: !!opts.force,
+        });
+    }
     // 6a. Repomix XML pack of baseline code (default when --baseline; non-fatal on failure).
     if (hasBaseline) {
         logger_1.logger.section(`步骤 ${stepRepomix}/${totalSteps} - 生成 baseline Repomix 包`);
@@ -258,7 +367,7 @@ async function runInit(opts) {
         try {
             const repoRootFs = wikiSourceRoot;
             const wikiOutputRootFs = targetRoot;
-            const wikiRelPath = node_path_1.default.join('assets', 'baseline', 'wiki');
+            const wikiRelPath = node_path_1.default.join('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.
@@ -311,12 +420,12 @@ async function runInit(opts) {
                 logger_1.logger.warn(`wiki 生成失败（不回滚 harness 骨架）：${err.message}`);
             }
         }
-        // If the full run failed, downgrade P1_wiki from DONE to PENDING
+        // If the full run failed, downgrade S10_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 接力补齐');
+            logger_1.logger.warn('S10_wiki 将标记为 PENDING，等待 agent 接力补齐');
         }
     }
     else if (wikiMode === 'tasks') {
@@ -324,7 +433,7 @@ async function runInit(opts) {
         try {
             const repoRootFs = wikiSourceRoot;
             const wikiOutputRootFs = targetRoot;
-            const wikiRelPath = node_path_1.default.join('assets', 'baseline', 'wiki');
+            const wikiRelPath = node_path_1.default.join('baseline', 'wiki');
             if (hasBaseline) {
                 const exists = await fs_extra_1.default.pathExists(repoRootFs);
                 const entries = exists ? await fs_extra_1.default.readdir(repoRootFs) : [];
@@ -400,6 +509,14 @@ async function runInit(opts) {
             wikiPhase: resolvedWikiPhase,
             wikiSource: resolvedWikiSource,
         });
+        if (extraAssetsResult) {
+            const s65 = state.phases.S65_customize_agent_env;
+            s65.incoming_manifest = extraAssetsResult.manifestRelPath;
+            s65.incoming_total = extraAssetsResult.incomingTotal;
+            s65.skills_count = extraAssetsResult.skillsCount;
+            s65.rules_count = extraAssetsResult.rulesCount;
+            s65.unknown_count = extraAssetsResult.unknownCount;
+        }
         const statePath = await (0, state_1.writeStateFile)(targetRoot, state);
         logger_1.logger.success(`状态文件: ${node_path_1.default.relative(targetRoot, statePath)}`);
     }

package/dist/commands/references-apply-skills.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runReferencesApplySkills = runReferencesApplySkills;
+const node_path_1 = __importDefault(require("node:path"));
+const prompts_1 = __importDefault(require("prompts"));
+const logger_1 = require("../utils/logger");
+const reference_apply_skills_1 = require("../core/reference-apply-skills");
+async function runReferencesApplySkills(opts) {
+    (0, logger_1.setVerbose)(!!opts.verbose);
+    const cwd = opts.cwd ?? process.cwd();
+    const harnessRoot = node_path_1.default.resolve(cwd, opts.harness);
+    logger_1.logger.configBox('references → apply skills', [
+        { label: 'harness', value: harnessRoot },
+        { label: 'force', value: opts.force ? 'yes' : 'no' },
+    ]);
+    if (!opts.yes) {
+        const { ok } = await (0, prompts_1.default)({
+            type: 'confirm',
+            name: 'ok',
+            message: '根据 references/yaml/index.yaml 生成 harness-apply-skills-* 并写入 registry？',
+            initial: true,
+        });
+        if (!ok) {
+            logger_1.logger.warn('用户取消');
+            return;
+        }
+    }
+    const result = await (0, reference_apply_skills_1.materializeReferenceApplySkills)(harnessRoot, {
+        force: opts.force,
+    });
+    logger_1.logger.success(`registry: ${node_path_1.default.relative(harnessRoot, result.registryPath)}`);
+    if (result.created.length > 0) {
+        logger_1.logger.success(`新建 skill: ${result.created.join(', ')}`);
+    }
+    if (result.updated.length > 0) {
+        logger_1.logger.success(`更新 skill: ${result.updated.join(', ')}`);
+    }
+    if (result.skipped.length > 0) {
+        logger_1.logger.warn(`跳过（已存在，未使用 --force）: ${result.skipped.join(', ')}`);
+    }
+    logger_1.logger.plain('');
+    logger_1.logger.plain('下一步：svharness apply --harness <path> --target <project> --yes');
+    logger_1.logger.plain('  apply 会把 registry 中的 skill 注入目标 Agent，并注册到 harness-apply-skills-main');
+}