@birdie_moblie/open_spec 2.1.7

package/dist/cli/commands/opsx.js

@@ -0,0 +1,324 @@
+import { readSource } from '../../core/source-operations.js';
+import { taskContextRel } from '../../core/worker.js';
+import { Option } from 'commander';
+import { runWorkerCheck, recordWorkerReview, reviewRounds, repairRounds } from '../../core/worker-evidence.js';
+import { readJson } from '../../shared/fs.js';
+import { resolveInside } from '../../shared/paths.js';
+import { controlSummary, inferWorkflow } from '../../core/instructions.js';
+import { artifactRel } from '../../core/change.js';
+import { abortUpdate, acceptWorker, answerWorker, addSources, approveGate, archiveChange, buildInstructions, cancelWorker, changedFilesFromState, collect, collectPendingWork, renderPendingWork, createWorker, isKnownGate, parseSourceArg, parseSourceFileArg, project, recordEvidence, rejectGate, renderReportMarkdown, requestFix, requireChange, resolveChangeName, runVerifyCommands, writeReport, } from '../../index.js';
+import { isWorkflow } from '../../delivery/skills.js';
+import { AppError } from '../../shared/errors.js';
+import { emitJson, jsonMode } from '../output.js';
+import { registerFigma } from './figma.js';
+export function registerOpsx(program) {
+    program.command('todo').description('汇总当前 change 的非阻塞待办')
+        .requiredOption('--change <name>', 'change 名称')
+        .action((options, command) => {
+        const { projectRoot, config } = project();
+        const pending = collectPendingWork(projectRoot, options.change, config);
+        emitJson(jsonMode(command), pending, () => renderPendingWork(pending));
+    });
+    const sources = program.command('sources').description('登记与采集来源');
+    registerFigma(sources);
+    sources.command('read').description('无损读取原文，或调用绑定 adapter 的定向读取')
+        .requiredOption('--change <name>', 'change 名称')
+        .requiredOption('--source <id>', '来源 id')
+        .option('--input <path>', '项目内 JSON 输入文件')
+        .option('--use <selector>', '为旧账本或手工来源显式指定 adapter')
+        .action((options) => {
+        const { projectRoot } = project();
+        const result = readSource(projectRoot, options.change, options.source, options.input, options.use);
+        emitJson(true, result, () => JSON.stringify(result));
+    });
+    sources
+        .command('add')
+        .requiredOption('--change <name>', 'change 名称')
+        .option('--notes <text>', '目标说明')
+        .option('--source <spec>', 'capability=locator，可重复', collectOption, [])
+        .option('--source-file <spec>', 'capability=path，可重复（capability: requirements/interfaces/design；path: 项目内已有文件的相对路径）', collectOption, [])
+        .addOption(viewOption())
+        .action((options, command) => {
+        const { projectRoot } = project();
+        const sourcesInput = [
+            ...options.source.map(parseSourceArg),
+            ...options.sourceFile.map(parseSourceFileArg),
+        ];
+        const ledger = addSources(projectRoot, options.change, { notes: options.notes, sources: sourcesInput });
+        const payload = options.view === 'summary' ? controlSummary(requireChange(projectRoot, options.change), {
+            revision: ledger.revision,
+            sourcesPath: artifactRel(options.change, `sources/sources-r${ledger.revision}.json`),
+            sources: ledger.items.map(({ id, capability, kind, artifact }) => ({ id, capability, kind, artifact })),
+        }) : ledger;
+        emitJson(options.view === 'summary' || jsonMode(command), payload, () => `sources r${ledger.revision}`);
+    });
+    sources
+        .command('collect')
+        .requiredOption('--change <name>', 'change 名称')
+        .option('--refresh', '忽略本次未完成采集的成功记录，重新采集')
+        .addOption(viewOption())
+        .action((options, command) => {
+        const { projectRoot, config } = project();
+        const result = collect(projectRoot, options.change, config, { refresh: options.refresh });
+        const payload = options.view === 'summary' ? controlSummary(requireChange(projectRoot, options.change), {
+            revision: result.ledger.revision,
+            sourcesPath: artifactRel(options.change, `sources/sources-r${result.ledger.revision}.json`),
+            artifacts: result.artifacts, deferred: result.deferred, covered: result.covered, warnings: result.warnings,
+        }) : result;
+        emitJson(options.view === 'summary' || jsonMode(command), payload, () => `collected r${result.ledger.revision}`);
+    });
+    sources
+        .command('abort-update')
+        .requiredOption('--change <name>', 'change 名称')
+        .option('--reason <text>', '原因', 'withdrawn')
+        .action((options, command) => {
+        const { projectRoot } = project();
+        const ledger = abortUpdate(projectRoot, options.change, options.reason);
+        emitJson(jsonMode(command), ledger, () => `aborted to r${ledger.revision}`);
+    });
+    const worker = program.command('worker').description('创建、验收或取消 worker');
+    worker
+        .command('create')
+        .requiredOption('--change <name>', 'change 名称')
+        .requiredOption('--step <id>', 'parse | tech | plan | code-<id> | verify')
+        .option('--refresh', '显式重建活动 Worker 的 Hook 绑定，保留原始差异基线；检查需重跑')
+        .addOption(viewOption())
+        .action((options, command) => {
+        const { projectRoot, config } = project();
+        const result = createWorker(projectRoot, options.change, options.step, config, { refresh: options.refresh });
+        // 控制会话只靠这些字段路由 code task 的四个阶段，不必读取 packet 正文。
+        const codeTask = result.packet.task ? {
+            category: result.packet.task.category,
+            taskContext: result.packet.refs.taskContext ?? null,
+            taskContextPath: taskContextRel(result.packet.changeName, result.packet.task.id),
+            reviewRounds: reviewRounds(projectRoot, options.change, result.packet),
+            repairRounds: repairRounds(projectRoot, options.change, result.packet),
+        } : {};
+        const payload = options.view === 'summary' ? controlSummary(requireChange(projectRoot, options.change), {
+            workerId: result.packet.workerId, stepId: result.packet.stepId,
+            packetPath: result.path, resultPath: result.packet.expectedResult,
+            ...codeTask,
+        }) : result;
+        emitJson(options.view === 'summary' || jsonMode(command), payload, () => `created ${result.packet.workerId}`);
+    });
+    worker.command('check').description('执行阶段检查并保存真实回执；插件调用不缓存')
+        .requiredOption('--change <name>', 'change 名称')
+        .requiredOption('--id <id>', '稳定检查 id；重试沿用同一 id')
+        .option('--command <command>', '检查命令；command Hook 可省略')
+        .option('--force', '强制重跑，不复用成功回执')
+        .option('--input <path>', '插件 command Hook 的项目内 JSON 输入文件')
+        .action((options) => {
+        const { projectRoot } = project();
+        const receipt = runWorkerCheck(projectRoot, options.change, options.id, options.command, options.force, options.input);
+        emitJson(true, receipt, () => receipt.log);
+        if (!receipt.ok)
+            process.exitCode = 1;
+    });
+    worker.command('review').description('控制会话批量登记或解决返修问题；遗漏的旧问题保持未解决')
+        .requiredOption('--change <name>', 'change 名称')
+        .requiredOption('--file <path>', '问题更新 JSON 数组，项目内路径')
+        .option('--repair', '登记实际代码返修后的审查；首轮与只刷新证据时省略')
+        .addOption(viewOption())
+        .action((options) => {
+        const { projectRoot } = project();
+        const receipt = recordWorkerReview(projectRoot, options.change, readJson(resolveInside(projectRoot, options.file)), options.repair);
+        // --view summary keeps the same shape as create/accept so the controller does not need a second call.
+        const payload = options.view === 'summary' ? controlSummary(requireChange(projectRoot, options.change), receipt) : receipt;
+        emitJson(true, payload, () => receipt.path);
+    });
+    worker
+        .command('accept')
+        .requiredOption('--change <name>', 'change 名称')
+        .requiredOption('--result <path>', 'result JSON 路径')
+        .addOption(viewOption())
+        .action((options, command) => {
+        const { projectRoot, config } = project();
+        const active = requireChange(projectRoot, options.change).activeWorker;
+        const state = acceptWorker(projectRoot, options.change, options.result, config);
+        const payload = options.view === 'summary' ? controlSummary(state, {
+            workerId: active?.workerId, stepId: active?.stepId,
+            packetPath: active?.packet, resultPath: active?.expectedResult,
+        }) : state;
+        emitJson(options.view === 'summary' || jsonMode(command), payload, () => `accepted → ${state.node}`);
+    });
+    worker
+        .command('answer')
+        .description('记录用户对 blocked worker 的答复，写入 packet.decisions 后可重新 create 同一 step')
+        .requiredOption('--change <name>', 'change 名称')
+        .requiredOption('--answer <text>', '答复，可重复；建议与 questions 一一对应', (value, previous = []) => [...previous, value])
+        .addOption(viewOption())
+        .action((options, command) => {
+        const { projectRoot } = project();
+        const result = answerWorker(projectRoot, options.change, options.answer);
+        const payload = options.view === 'summary' ? controlSummary(result.state, {
+            workerId: result.packet.workerId, stepId: result.packet.stepId,
+            packetPath: result.path, resultPath: result.packet.expectedResult,
+        }) : result;
+        emitJson(options.view === 'summary' || jsonMode(command), payload, () => `answered ${result.packet.workerId}`);
+    });
+    worker
+        .command('cancel')
+        .requiredOption('--change <name>', 'change 名称')
+        .option('--reason <text>', '原因', 'cancelled')
+        .action((options, command) => {
+        const { projectRoot } = project();
+        const state = cancelWorker(projectRoot, options.change, options.reason);
+        emitJson(jsonMode(command), state, () => 'cancelled');
+    });
+    const gate = program.command('gate').description('批准或拒绝 Gate');
+    gate
+        .command('approve <gate>')
+        .requiredOption('--change <name>', 'change 名称')
+        .option('--comment <text>', '说明', '')
+        .action((gateId, options, command) => {
+        if (!isKnownGate(gateId))
+            throw new AppError('invalid_gate', `未知 gate: ${gateId}`);
+        const { projectRoot } = project();
+        const state = approveGate(projectRoot, options.change, gateId, options.comment);
+        emitJson(jsonMode(command), state, () => `approved ${gateId}`);
+    });
+    gate
+        .command('reject <gate>')
+        .requiredOption('--change <name>', 'change 名称')
+        .requiredOption('--reason <text>', '原因')
+        .action((gateId, options, command) => {
+        if (!isKnownGate(gateId))
+            throw new AppError('invalid_gate', `未知 gate: ${gateId}`);
+        const { projectRoot } = project();
+        const state = rejectGate(projectRoot, options.change, gateId, options.reason);
+        emitJson(jsonMode(command), state, () => `rejected ${gateId}`);
+    });
+    const verify = program.command('verify').description('验证钩子与报告');
+    verify
+        .command('commands')
+        .requiredOption('--change <name>', 'change 名称')
+        .action((options, command) => {
+        const { projectRoot, config } = project();
+        const state = requireChange(projectRoot, options.change);
+        const runs = runVerifyCommands(projectRoot, options.change, config, changedFilesFromState(state));
+        emitJson(jsonMode(command), { commands: runs }, () => `ran ${runs.length} commands`);
+    });
+    verify
+        .command('skill-evidence')
+        .requiredOption('--change <name>', 'change 名称')
+        .requiredOption('--hook <id>', 'hook id')
+        .requiredOption('--status <status>', 'passed | failed | skipped')
+        .option('--notes <text>', '说明')
+        .action((options, command) => {
+        const { projectRoot, config } = project();
+        const record = recordEvidence(projectRoot, options.change, {
+            hookId: options.hook,
+            type: 'skill',
+            status: evidenceStatus(options.status),
+            notes: options.notes,
+        }, config);
+        emitJson(jsonMode(command), record, () => `recorded ${record.hookId}`);
+    });
+    verify
+        .command('hook-result')
+        .requiredOption('--change <name>', 'change 名称')
+        .requiredOption('--hook <id>', 'hook id')
+        .requiredOption('--status <status>', 'passed | failed | skipped')
+        .option('--notes <text>', '说明')
+        .action((options, command) => {
+        const { projectRoot, config } = project();
+        const record = recordEvidence(projectRoot, options.change, {
+            hookId: options.hook,
+            type: 'file',
+            status: evidenceStatus(options.status),
+            notes: options.notes,
+        }, config);
+        emitJson(jsonMode(command), record, () => `recorded ${record.hookId}`);
+    });
+    verify
+        .command('check-result')
+        .requiredOption('--change <name>', 'change 名称')
+        .requiredOption('--hook <id>', 'hook id')
+        .requiredOption('--status <status>', 'passed | failed | skipped')
+        .option('--notes <text>', '说明')
+        .action((options, command) => {
+        const { projectRoot, config } = project();
+        const record = recordEvidence(projectRoot, options.change, {
+            hookId: options.hook,
+            type: 'check',
+            status: evidenceStatus(options.status),
+            notes: options.notes,
+        }, config);
+        emitJson(jsonMode(command), record, () => `recorded ${record.hookId}`);
+    });
+    verify
+        .command('report')
+        .requiredOption('--change <name>', 'change 名称')
+        .option('--format <fmt>', 'json | md', 'json')
+        .action((options, command) => {
+        const { projectRoot, config } = project();
+        if (!['json', 'md'].includes(options.format))
+            throw new AppError('invalid_format', `未知报告格式: ${options.format}`);
+        const state = requireChange(projectRoot, options.change);
+        const result = writeReport(projectRoot, options.change, config, {
+            changedFiles: changedFilesFromState(state),
+        });
+        if (result.status === 'failed')
+            process.exitCode = 1;
+        if (options.format === 'md') {
+            console.log(renderReportMarkdown(result.report));
+            return;
+        }
+        emitJson(jsonMode(command), result, () => `report ${result.status}`);
+    });
+    verify
+        .command('fix')
+        .requiredOption('--change <name>', 'change 名称')
+        .option('--reason <text>', '原因', 'qa failed')
+        .action((options, command) => {
+        const { projectRoot } = project();
+        const state = requestFix(projectRoot, options.change, options.reason);
+        emitJson(jsonMode(command), state, () => `fix → ${state.node}`);
+    });
+    program
+        .command('archive [change]')
+        .description('归档已完成的 change')
+        .action((changeName, options, command) => {
+        const { projectRoot } = project();
+        const name = resolveChangeName(projectRoot, changeName);
+        const result = archiveChange(projectRoot, name);
+        emitJson(jsonMode(command), result, () => `archived ${result.to}`);
+        void options;
+    });
+    program
+        .command('instructions [workflow]')
+        .description('返回当前节点的轻量指令')
+        .option('--change <name>', 'change 名称')
+        .option('--protocol <n>', '协议版本', '1')
+        .action((workflow, options, command) => {
+        const { projectRoot } = project();
+        const name = resolveChangeName(projectRoot, options.change);
+        const state = requireChange(projectRoot, name);
+        if (options.protocol !== '1')
+            throw new AppError('unsupported_protocol', `不支持 protocol: ${options.protocol}`);
+        let wf;
+        if (workflow) {
+            if (!isWorkflow(workflow))
+                throw new AppError('invalid_workflow', `未知 workflow: ${workflow}`);
+            wf = workflow;
+        }
+        else {
+            wf = inferWorkflow(state);
+        }
+        const payload = buildInstructions(wf, state);
+        emitJson(true, payload, () => JSON.stringify(payload));
+        void command;
+    });
+}
+function evidenceStatus(value) {
+    if (!['passed', 'failed', 'skipped'].includes(value))
+        throw new AppError('invalid_evidence_status', `未知 evidence status: ${value}`);
+    return value;
+}
+function collectOption(value, previous) {
+    return [...previous, value];
+}
+function viewOption() {
+    return new Option('--view <view>', '完整或精简响应').choices(['full', 'summary']).default('full');
+}
+//# sourceMappingURL=opsx.js.map

package/dist/cli/commands/usage.d.ts

@@ -0,0 +1,3 @@
+import { type Command } from 'commander';
+export declare function registerUsage(program: Command): void;
+//# sourceMappingURL=usage.d.ts.map

package/dist/cli/commands/usage.js

@@ -0,0 +1,21 @@
+import { Option } from 'commander';
+import { readJson } from '../../shared/fs.js';
+import { analyzeUsage, renderUsageMarkdown } from '../../usage/analyze.js';
+export function registerUsage(program) {
+    program.command('usage').description('只读用量分析').command('analyze')
+        .requiredOption('--change <name>', '报告所属 change，不静默过滤未归属用量')
+        .requiredOption('--session <path...>', 'Codex/Claude JSONL，可重复', (value, previous) => [...previous, value], [])
+        .addOption(new Option('--format <format>', '报告格式').choices(['json', 'md']).default('json'))
+        .option('--events <path>', 'OpenSpec events.jsonl，补充阶段归属')
+        .option('--expect-model <model>', '用于比较的固定模型')
+        .option('--expect-effort <effort>', '用于比较的固定推理配置')
+        .option('--rates <path>', '有来源的每百万 token 费率 JSON')
+        .option('--billing <path>', '按 threadId 归属的实际账单 JSON')
+        .action((options) => {
+        const report = analyzeUsage({ changeName: options.change, sessions: options.session, events: options.events,
+            expectedModel: options.expectModel, expectedEffort: options.expectEffort,
+            rates: options.rates ? readJson(options.rates) : undefined, billing: options.billing ? readJson(options.billing) : undefined });
+        console.log(options.format === 'md' ? renderUsageMarkdown(report) : JSON.stringify(report, null, 2));
+    });
+}
+//# sourceMappingURL=usage.js.map

package/dist/cli/output.d.ts

@@ -0,0 +1,8 @@
+export declare function emitJson(flag: boolean | undefined, data: unknown, text: () => string): void;
+export declare function jsonMode(command: {
+    opts: () => {
+        json?: boolean;
+    };
+    parent?: unknown;
+}): boolean;
+//# sourceMappingURL=output.d.ts.map

package/dist/cli/output.js

@@ -0,0 +1,17 @@
+export function emitJson(flag, data, text) {
+    if (flag)
+        console.log(JSON.stringify(data, null, 2));
+    else
+        console.log(text());
+}
+export function jsonMode(command) {
+    const self = command.opts().json;
+    let current = command;
+    while (current) {
+        if (current.opts?.().json)
+            return true;
+        current = current.parent;
+    }
+    return Boolean(self);
+}
+//# sourceMappingURL=output.js.map

package/dist/cli/program.d.ts

@@ -0,0 +1,4 @@
+import { Command } from 'commander';
+export declare function createProgram(): Command;
+export declare function run(argv?: string[]): Promise<void>;
+//# sourceMappingURL=program.d.ts.map

package/dist/cli/program.js

@@ -0,0 +1,42 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { isAppError } from '../shared/errors.js';
+import { VERSION } from '../shared/version.js';
+import { registerCommands } from './register.js';
+export function createProgram() {
+    const program = new Command();
+    program
+        .name('openspec')
+        .description('OpenSpec v2：确定性产品规格工作流')
+        .version(VERSION)
+        .showHelpAfterError()
+        .option('--json', '以 JSON 输出');
+    registerCommands(program);
+    return program;
+}
+export async function run(argv = process.argv) {
+    const program = createProgram();
+    program.exitOverride();
+    try {
+        await program.parseAsync(argv);
+    }
+    catch (error) {
+        const json = argv.includes('--json') || program.getOptionValue('json');
+        if (isCommanderSuccess(error))
+            return;
+        const payload = isAppError(error)
+            ? { ok: false, code: error.code, error: error.message, details: error.details }
+            : { ok: false, code: 'unexpected', error: error instanceof Error ? error.message : String(error) };
+        if (json)
+            console.error(JSON.stringify(payload, null, 2));
+        else
+            console.error(chalk.red(payload.error));
+        process.exitCode = 1;
+    }
+}
+function isCommanderSuccess(error) {
+    if (!error || typeof error !== 'object' || !('code' in error))
+        return false;
+    return ['commander.helpDisplayed', 'commander.version'].includes(error.code);
+}
+//# sourceMappingURL=program.js.map

package/dist/cli/register.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from 'commander';
+export declare function registerCommands(program: Command): void;
+//# sourceMappingURL=register.d.ts.map

package/dist/cli/register.js

@@ -0,0 +1,13 @@
+import { registerInit } from './commands/init.js';
+import { registerChange } from './commands/change.js';
+import { registerOpsx } from './commands/opsx.js';
+import { registerExt } from './commands/ext.js';
+import { registerUsage } from './commands/usage.js';
+export function registerCommands(program) {
+    registerInit(program);
+    registerChange(program);
+    registerOpsx(program);
+    registerExt(program);
+    registerUsage(program);
+}
+//# sourceMappingURL=register.js.map

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.js

@@ -0,0 +1,3 @@
+import { run } from './cli/program.js';
+await run();
+//# sourceMappingURL=cli.js.map

package/dist/config/load.d.ts

@@ -0,0 +1,7 @@
+import { type ProjectConfig } from './schema.js';
+export declare function findProjectRoot(start?: string): string;
+export declare function configPathOf(projectRoot: string): string | null;
+export declare function loadConfig(projectRoot: string): ProjectConfig;
+export declare function saveConfig(projectRoot: string, config: ProjectConfig): void;
+export declare function defaultConfig(): ProjectConfig;
+//# sourceMappingURL=load.d.ts.map

package/dist/config/load.js

@@ -0,0 +1,55 @@
+import path from 'node:path';
+import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
+import { exists, readText, writeText } from '../shared/fs.js';
+import { AppError } from '../shared/errors.js';
+import { CONFIG_FILES, OPENSPEC_DIR, resolveInside } from '../shared/paths.js';
+import { ProjectConfigSchema } from './schema.js';
+export function findProjectRoot(start = process.cwd()) {
+    let dir = path.resolve(start);
+    while (true) {
+        if (configPathOf(dir))
+            return dir;
+        const parent = path.dirname(dir);
+        if (parent === dir) {
+            throw new AppError('project_uninitialized', '未找到 openspec/config.yaml，请先运行 openspec init');
+        }
+        dir = parent;
+    }
+}
+export function configPathOf(projectRoot) {
+    for (const name of CONFIG_FILES) {
+        const file = resolveInside(projectRoot, path.posix.join(OPENSPEC_DIR, name), 'config_path_outside_project');
+        if (exists(file))
+            return file;
+    }
+    return null;
+}
+export function loadConfig(projectRoot) {
+    const file = configPathOf(projectRoot);
+    if (!file)
+        throw new AppError('project_uninitialized', '缺少 openspec/config.yaml');
+    let parsed;
+    try {
+        parsed = parseYaml(readText(file));
+    }
+    catch (error) {
+        throw new AppError('invalid_config', '项目配置 YAML 无法解析', error instanceof Error ? error.message : String(error));
+    }
+    const result = ProjectConfigSchema.safeParse(parsed);
+    if (!result.success) {
+        throw new AppError('invalid_config', '项目配置不合法', result.error.issues);
+    }
+    return result.data;
+}
+export function saveConfig(projectRoot, config) {
+    const parsed = ProjectConfigSchema.safeParse(config);
+    if (!parsed.success)
+        throw new AppError('invalid_config', '拒绝写入不合法的项目配置', parsed.error.issues);
+    const file = configPathOf(projectRoot)
+        ?? resolveInside(projectRoot, path.posix.join(OPENSPEC_DIR, 'config.yaml'), 'config_path_outside_project');
+    writeText(file, stringifyYaml(parsed.data, { lineWidth: 0 }));
+}
+export function defaultConfig() {
+    return { schema: 'spec-product' };
+}
+//# sourceMappingURL=load.js.map

package/dist/config/presets.d.ts

@@ -0,0 +1,129 @@
+import { z } from 'zod';
+import { type ProjectConfig } from './schema.js';
+declare const ScaffoldEntrySchema: z.ZodObject<{
+    path: z.ZodString;
+    template: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type ScaffoldEntry = z.infer<typeof ScaffoldEntrySchema>;
+export type ScaffoldResult = {
+    path: string;
+    status: 'created' | 'exists';
+    description?: string;
+};
+export declare const TeamPresetSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openspec.team-preset.v1">;
+    id: z.ZodString;
+    version: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    marketplaces: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        repo: z.ZodString;
+        ref: z.ZodString;
+    }, z.core.$strict>>>;
+    plugins: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        marketplace: z.ZodString;
+        minVersion: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    configPatch: z.ZodOptional<z.ZodObject<{
+        schema: z.ZodOptional<z.ZodLiteral<"spec-product">>;
+        taskCategories: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodObject<{
+            notes: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>>>;
+        hooks: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            stage: z.ZodEnum<{
+                collect: "collect";
+                parse: "parse";
+                tech: "tech";
+                plan: "plan";
+                execute: "execute";
+                verify: "verify";
+            }>;
+            type: z.ZodOptional<z.ZodEnum<{
+                command: "command";
+                skill: "skill";
+                notes: "notes";
+                file: "file";
+                check: "check";
+            }>>;
+            capability: z.ZodOptional<z.ZodEnum<{
+                requirements: "requirements";
+                interfaces: "interfaces";
+                design: "design";
+            }>>;
+            use: z.ZodOptional<z.ZodString>;
+            operation: z.ZodOptional<z.ZodLiteral<"preview">>;
+            input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            inputFiles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            name: z.ZodOptional<z.ZodString>;
+            notes: z.ZodOptional<z.ZodString>;
+            taskCategories: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            command: z.ZodOptional<z.ZodString>;
+            target: z.ZodOptional<z.ZodEnum<{
+                project: "project";
+                inScopeChangedFiles: "inScopeChangedFiles";
+            }>>;
+            include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            allowEmpty: z.ZodOptional<z.ZodBoolean>;
+            required: z.ZodOptional<z.ZodBoolean>;
+            purpose: z.ZodOptional<z.ZodString>;
+            path: z.ZodOptional<z.ZodString>;
+            category: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>>;
+        verify: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+            reviewScope: z.ZodOptional<z.ZodObject<{
+                includeDirs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                excludeDirs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>>;
+            failurePolicy: z.ZodOptional<z.ZodObject<{
+                failOnHookFailure: z.ZodOptional<z.ZodBoolean>;
+                failOnRequiredCommandFailure: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+        plugins: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            marketplace: z.ZodString;
+            minVersion: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>>;
+        marketplaces: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            repo: z.ZodString;
+            ref: z.ZodString;
+        }, z.core.$strict>>>>;
+        tools: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            claude: "claude";
+            codex: "codex";
+            cursor: "cursor";
+        }>>>>;
+    }, z.core.$strict>>;
+    scaffold: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        template: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    notes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type TeamPreset = z.infer<typeof TeamPresetSchema>;
+export declare function presetsDir(): string;
+export declare function listPresets(): TeamPreset[];
+export declare function loadPreset(id: string): TeamPreset;
+export declare function mergePreset(base: ProjectConfig, preset: TeamPreset): ProjectConfig;
+/**
+ * 把 preset 声明的模板文件放到项目里。已存在的文件一律不动——
+ * 团队填写后的内容不能被重复 init 覆盖；模板本身带 openspec:fill-me 标记，未填写时 file hook 不会放行。
+ */
+export declare function scaffoldPreset(projectRoot: string, preset: TeamPreset): ScaffoldResult[];
+/** 合并时保留了宿主 ref、且与 preset 基线不同的 marketplace，供 init / preset apply 提示。 */
+export declare function keptMarketplaceRefs(base: ProjectConfig, preset: TeamPreset): Array<{
+    name: string;
+    ref: string;
+    presetRef: string;
+}>;
+export {};
+//# sourceMappingURL=presets.d.ts.map