@hongmaple0820/scale-engine 0.27.1 → 0.29.0

package/dist/runtime/AiOsRuntime.js

@@ -7,6 +7,7 @@ import { MemoryFabric, recallMemoryProviders, } from '../memory/index.js';
 import { createSkillPlan, loadSkillRoutingPolicy, } from '../skills/routing/index.js';
 import { runSafeCommand } from '../tools/SafeCommandRunner.js';
 import { SCALE_ENGINE_VERSION } from '../version.js';
+import { resolveVerificationTargets, } from '../workflow/VerificationProfile.js';
 import { RuntimeEvidenceLedger } from './RuntimeEvidenceLedger.js';
 export async function createAiOsPlan(input) {
     const projectDir = resolve(input.projectDir ?? process.cwd());
@@ -337,6 +338,392 @@ export function createAiOsDoctor(input = {}) {
         nextActions: aiOsDoctorNextActions({ status, checks, dashboard, benchmark, lang }),
     };
 }
+export async function createAiOsAdoption(input) {
+    const projectDir = resolve(input.projectDir ?? process.cwd());
+    const scaleDir = input.scaleDir ?? '.scale';
+    const scaleRoot = resolveScaleRoot(projectDir, scaleDir);
+    const generatedAt = new Date().toISOString();
+    const migration = createAiOsMigration({ projectDir, scaleDir });
+    const run = await createAiOsRun({
+        ...input,
+        projectDir,
+        scaleDir,
+        taskId: input.taskId ?? `AIOS-ADOPT-${Date.now()}`,
+        mode: 'dry-run',
+    });
+    const benchmark = await createAiOsBenchmark({
+        projectDir,
+        scaleDir,
+        budget: input.budget,
+    });
+    const doctor = createAiOsDoctor({
+        projectDir,
+        scaleDir,
+        benchmarkMaxAgeHours: input.benchmarkMaxAgeHours,
+        lang: input.lang,
+    });
+    const phases = [
+        {
+            id: 'migrate',
+            status: migration.status === 'migrated' || migration.status === 'compatible' ? 'passed' : 'blocked',
+            summary: migration.status === 'migrated'
+                ? `Created ${migration.created.length} AI OS runtime path(s).`
+                : 'AI OS runtime paths were already compatible.',
+            evidence: [migration.files.migrationReport, ...migration.created, ...migration.existing],
+        },
+        {
+            id: 'first-run',
+            status: run.status === 'ready' ? 'passed' : 'blocked',
+            summary: `Created first ${run.mode} AI OS run report with ${run.steps.length} step(s).`,
+            evidence: [run.artifacts.runReport, ...run.evidence.produced],
+        },
+        {
+            id: 'benchmark',
+            status: benchmark.summary.scenarios > 0 ? 'passed' : 'blocked',
+            summary: `Created AI OS benchmark report with ${benchmark.summary.scenarios} scenario(s).`,
+            evidence: [benchmark.artifacts.benchmarkReport],
+        },
+        {
+            id: 'doctor',
+            status: doctor.status === 'ready' ? 'passed' : doctor.status === 'warning' ? 'warning' : 'blocked',
+            summary: `AI OS doctor status is ${doctor.status}: ${doctor.summary.passedChecks}/${doctor.summary.totalChecks} checks passed.`,
+            evidence: doctor.checks.flatMap(check => check.evidence),
+        },
+    ];
+    const status = phases.some(phase => phase.status === 'blocked')
+        ? 'blocked'
+        : phases.some(phase => phase.status === 'warning') ? 'warning' : 'ready';
+    const adoptionReport = resolveAdoptionReportPath(projectDir, scaleDir);
+    const report = {
+        version: SCALE_ENGINE_VERSION,
+        generatedAt,
+        status,
+        projectDir,
+        scaleRoot,
+        phases,
+        migration,
+        run,
+        benchmark,
+        doctor,
+        artifacts: {
+            migrationReport: migration.files.migrationReport,
+            runReport: run.artifacts.runReport,
+            benchmarkReport: benchmark.artifacts.benchmarkReport,
+            adoptionReport,
+        },
+        warnings: [...migration.warnings, ...doctor.warnings],
+        nextActions: aiOsAdoptionNextActions(status, input.lang ?? 'en'),
+    };
+    writeFileSync(adoptionReport, JSON.stringify(report, null, 2), 'utf-8');
+    return report;
+}
+export function createAiOsStatus(input = {}) {
+    const projectDir = resolve(input.projectDir ?? process.cwd());
+    const scaleDir = input.scaleDir ?? '.scale';
+    const lang = input.lang ?? 'en';
+    const scaleRoot = resolveScaleRoot(projectDir, scaleDir);
+    const warnings = [];
+    const runsDir = resolveRunsDir(projectDir, scaleDir);
+    const runReports = readAiOsRunReports(runsDir, warnings);
+    const dashboard = createAiOsDashboard({ projectDir, scaleDir });
+    const doctor = createAiOsDoctor({
+        projectDir,
+        scaleDir,
+        benchmarkMaxAgeHours: input.benchmarkMaxAgeHours,
+        lang,
+    });
+    const requiredDirs = [
+        join(scaleRoot, 'ai-os'),
+        join(scaleRoot, 'ai-os', 'runs'),
+        join(scaleRoot, 'ai-os', 'benchmarks'),
+        join(scaleRoot, 'ai-os', 'migrations'),
+    ];
+    const missingDirs = requiredDirs.filter(dir => !existsSync(dir)).map(dir => normalizeProjectPath(projectDir, dir));
+    const runEvidence = runReports.map(report => report.artifacts.runReport);
+    const verificationEvidence = runReports
+        .filter(report => report.verification.commands.length > 0)
+        .flatMap(report => [report.artifacts.runReport, ...report.verification.commands.map(command => command.evidenceId)]);
+    const verificationRecommendations = buildVerificationRecommendations(projectDir, scaleDir, lang);
+    const benchmarkReport = resolveBenchmarkReportPath(projectDir, scaleDir);
+    const adoptionReport = resolveAdoptionReportPath(projectDir, scaleDir);
+    const intelligence = buildAiOsIntelligenceReport({
+        projectDir,
+        scaleDir,
+        runReports,
+        benchmark: readAiOsBenchmarkReport(benchmarkReport, warnings),
+        benchmarkStatus: doctor.benchmark.status,
+        benchmarkReport,
+        lang,
+    });
+    const checks = [
+        {
+            id: 'runtime-dirs',
+            title: 'Runtime directories',
+            status: missingDirs.length === 0 ? 'ready' : 'blocked',
+            summary: missingDirs.length === 0
+                ? 'AI OS runtime directories exist.'
+                : `${missingDirs.length} AI OS runtime director${missingDirs.length === 1 ? 'y is' : 'ies are'} missing.`,
+            evidence: missingDirs.length === 0 ? requiredDirs.map(dir => normalizeProjectPath(projectDir, dir)) : missingDirs,
+        },
+        {
+            id: 'plan-evidence',
+            title: 'Plan evidence',
+            status: runReports.length > 0 ? 'ready' : 'blocked',
+            summary: runReports.length > 0
+                ? `${runReports.length} run report(s) include embedded AI OS plans.`
+                : 'No AI OS plan evidence is persisted through a run report.',
+            evidence: runEvidence,
+        },
+        {
+            id: 'run-evidence',
+            title: 'Run evidence',
+            status: runReports.length > 0 ? 'ready' : 'blocked',
+            summary: runReports.length > 0
+                ? `${runReports.length} AI OS run report(s) found.`
+                : 'No AI OS run reports found.',
+            evidence: runEvidence,
+        },
+        {
+            id: 'verification-evidence',
+            title: 'Verification evidence',
+            status: verificationEvidence.length > 0 ? 'ready' : 'blocked',
+            summary: verificationEvidence.length > 0
+                ? `${verificationEvidence.length} guarded verification evidence reference(s) found.`
+                : 'No guarded verification evidence found.',
+            evidence: verificationEvidence,
+        },
+        {
+            id: 'dashboard-health',
+            title: 'Dashboard health',
+            status: dashboard.health.status === 'healthy'
+                ? 'ready'
+                : dashboard.health.status === 'empty' || dashboard.health.status === 'blocked' ? 'blocked' : 'warning',
+            summary: `${dashboard.health.status} (${dashboard.health.score}): ${dashboard.health.reasons.join('; ')}`,
+            evidence: [runsDir],
+        },
+        {
+            id: 'benchmark-evidence',
+            title: 'Benchmark evidence',
+            status: doctor.benchmark.status === 'fresh' ? 'ready' : doctor.benchmark.status === 'stale' ? 'warning' : 'blocked',
+            summary: summarizeBenchmarkDoctor(doctor.benchmark),
+            evidence: [benchmarkReport],
+        },
+        {
+            id: 'adoption-evidence',
+            title: 'Adoption evidence',
+            status: existsSync(adoptionReport) ? 'ready' : 'blocked',
+            summary: existsSync(adoptionReport)
+                ? 'AI OS adoption report exists.'
+                : 'No AI OS adoption report found.',
+            evidence: [adoptionReport],
+        },
+    ];
+    const summary = {
+        total: checks.length,
+        ready: checks.filter(check => check.status === 'ready').length,
+        warning: checks.filter(check => check.status === 'warning').length,
+        blocked: checks.filter(check => check.status === 'blocked').length,
+    };
+    const status = summary.blocked > 0 ? 'blocked' : summary.warning > 0 ? 'warning' : 'ready';
+    return {
+        version: SCALE_ENGINE_VERSION,
+        generatedAt: new Date().toISOString(),
+        status,
+        projectDir,
+        scaleRoot,
+        checks,
+        summary,
+        dashboard,
+        doctor,
+        intelligence,
+        verificationRecommendations,
+        nextActions: aiOsStatusNextActions(status, checks, lang, verificationRecommendations),
+        warnings: [...warnings, ...doctor.warnings],
+    };
+}
+function buildAiOsIntelligenceReport(input) {
+    const runMemoryItems = input.runReports.flatMap(report => report.plan.memory.items);
+    const benchmarkMemoryItems = input.benchmark?.summary.totalMemoryItems ?? 0;
+    const runProviders = input.runReports.flatMap(report => report.plan.memory.selectedProviders);
+    const benchmarkProviders = input.benchmark?.scenarios.flatMap(scenario => scenario.metrics.selectedProviders) ?? [];
+    const selectedProviders = [...new Set([...runProviders, ...benchmarkProviders])].sort();
+    const runTokenSavings = input.runReports.reduce((sum, report) => sum + (report.plan.context.compiler?.estimatedTokenSavings ?? 0), 0);
+    const benchmarkTokenSavings = input.benchmark?.summary.totalEstimatedTokenSavings ?? 0;
+    const estimatedTokenSavings = runTokenSavings + benchmarkTokenSavings;
+    const runSkillSteps = input.runReports.reduce((sum, report) => sum + report.plan.skillPlan.executionPlan.steps.length, 0);
+    const benchmarkSkillSteps = input.benchmark?.summary.totalSkillSteps ?? 0;
+    const skillSteps = runSkillSteps + benchmarkSkillSteps;
+    const totalMemoryItems = runMemoryItems.length + benchmarkMemoryItems;
+    const memoryQuality = summarizeMemoryQuality(runMemoryItems);
+    const contextQuality = summarizeContextQuality(input.runReports);
+    const contextSignalStatus = contextQuality.compressionRisk === 'high'
+        ? 'warning'
+        : estimatedTokenSavings > 0 ? 'ready' : input.runReports.length > 0 || input.benchmark ? 'warning' : 'blocked';
+    const memoryEvidence = [
+        ...runMemoryItems.map(item => `${item.provider}:${item.id}`),
+        ...(benchmarkMemoryItems > 0 ? [`benchmark:${input.benchmarkReport}:${benchmarkMemoryItems}`] : []),
+    ];
+    const contextEvidence = [
+        ...input.runReports.map(report => `${report.artifacts.runReport}:saved=${report.plan.context.compiler?.estimatedTokenSavings ?? 0}`),
+        ...(input.benchmark ? [`${input.benchmarkReport}:saved=${input.benchmark.summary.totalEstimatedTokenSavings}`] : []),
+    ];
+    const skillEvidence = [
+        ...input.runReports.flatMap(report => report.plan.skillPlan.executionPlan.steps.map(step => `${report.artifacts.runReport}:${step.id}`)),
+        ...(input.benchmark ? [`${input.benchmarkReport}:steps=${input.benchmark.summary.totalSkillSteps}`] : []),
+    ];
+    const benchmarkEvidence = input.benchmark ? [
+        `${input.benchmarkReport}:scenarios=${input.benchmark.summary.scenarios}`,
+        `${input.benchmarkReport}:memory=${input.benchmark.summary.totalMemoryItems}`,
+        `${input.benchmarkReport}:skills=${input.benchmark.summary.totalSkillSteps}`,
+    ] : [input.benchmarkReport];
+    const signals = [
+        {
+            id: 'memory-recall',
+            status: totalMemoryItems > 0 ? 'ready' : selectedProviders.length > 0 ? 'warning' : 'blocked',
+            summary: totalMemoryItems > 0
+                ? `${totalMemoryItems} memory item(s) recalled through ${selectedProviders.join(', ') || 'configured providers'}; quality ${memoryQuality.score}/100.`
+                : selectedProviders.length > 0
+                    ? `Memory providers were selected (${selectedProviders.join(', ')}) but no relevant item was recalled.`
+                    : 'No memory recall evidence found in AI OS runs or benchmarks.',
+            evidence: memoryEvidence,
+            recommendations: totalMemoryItems > 0
+                ? ['Keep recording memory item ids with every run so later context assembly can explain recall.']
+                : ['Run an AI OS task that should match durable project memory before claiming memory intelligence.'],
+        },
+        {
+            id: 'context-savings',
+            status: contextSignalStatus,
+            summary: estimatedTokenSavings > 0
+                ? `${estimatedTokenSavings} estimated token(s) saved by context compilation evidence; compression risk ${contextQuality.compressionRisk}.`
+                : 'Context compiler evidence exists but has not shown measurable token savings yet.',
+            evidence: contextEvidence,
+            recommendations: contextQuality.evidenceLossWarnings.length > 0
+                ? ['Review omitted evidence-bearing context before claiming the task has enough context.']
+                : estimatedTokenSavings > 0
+                    ? ['Track savings deltas across releases before publishing token reduction claims.']
+                    : ['Add larger representative tasks to benchmark context slicing and token savings.'],
+        },
+        {
+            id: 'skill-routing',
+            status: skillSteps > 0 ? 'ready' : input.runReports.length > 0 || input.benchmark ? 'warning' : 'blocked',
+            summary: skillSteps > 0
+                ? `${skillSteps} skill routing step(s) planned across runs and benchmark scenarios.`
+                : 'No skill routing step evidence found.',
+            evidence: skillEvidence,
+            recommendations: skillSteps > 0
+                ? ['Use skill routing evidence in reviews to check why a skill, MCP, or CLI path was selected.']
+                : ['Create a task with files or services that should trigger required skill routing.'],
+        },
+        {
+            id: 'benchmark-intelligence',
+            status: input.benchmark && input.benchmarkStatus === 'fresh'
+                ? 'ready'
+                : input.benchmark && input.benchmarkStatus === 'stale' ? 'warning' : 'blocked',
+            summary: input.benchmark
+                ? `${input.benchmark.summary.scenarios} benchmark scenario(s); benchmark status ${input.benchmarkStatus}.`
+                : 'No AI OS benchmark report available for intelligence metrics.',
+            evidence: benchmarkEvidence,
+            recommendations: input.benchmark && input.benchmarkStatus === 'fresh'
+                ? ['Use intelligence signals alongside benchmark deltas for release readiness reviews.']
+                : ['Run `scale ai-os benchmark --json` to refresh memory/context/skill intelligence metrics.'],
+        },
+    ];
+    const summary = {
+        ready: signals.filter(signal => signal.status === 'ready').length,
+        warning: signals.filter(signal => signal.status === 'warning').length,
+        blocked: signals.filter(signal => signal.status === 'blocked').length,
+        totalMemoryItems,
+        selectedProviders,
+        memoryQuality,
+        contextQuality,
+        estimatedTokenSavings,
+        skillSteps,
+    };
+    const status = summary.blocked > 0 ? 'blocked' : summary.warning > 0 ? 'warning' : 'ready';
+    const nextActions = aiOsIntelligenceNextActions(status, signals, input.lang);
+    return { status, summary, signals, nextActions };
+}
+function summarizeContextQuality(runReports) {
+    const omitted = runReports.flatMap(report => report.plan.context.omitted.map(item => {
+        const section = report.plan.context.sections.find(candidate => candidate.id === item.id);
+        return {
+            ...item,
+            category: section?.category,
+            runReport: report.artifacts.runReport,
+        };
+    }));
+    const totalOmittedTokens = omitted.reduce((sum, item) => sum + item.estimatedTokens, 0);
+    const highestOmittedTokens = omitted.reduce((max, item) => Math.max(max, item.estimatedTokens), 0);
+    const evidenceLossWarnings = omitted
+        .filter(item => item.category === 'evidence' || item.id.includes('evidence'))
+        .map(item => `${item.id} omitted from ${item.runReport} (${item.estimatedTokens} tokens; ${item.reason}).`);
+    const compressionRisk = evidenceLossWarnings.length > 0
+        ? 'high'
+        : omitted.length > 0 ? 'medium' : 'low';
+    return {
+        omittedSections: omitted.length,
+        totalOmittedTokens,
+        evidenceLossWarnings,
+        highestOmittedTokens,
+        compressionRisk,
+    };
+}
+function summarizeMemoryQuality(items) {
+    if (items.length === 0) {
+        return {
+            score: 0,
+            evidenceBackedItems: 0,
+            missingEvidenceItems: 0,
+            lowConfidenceItems: 0,
+            averageConfidence: 0,
+            averageRelevance: 0,
+        };
+    }
+    const evidenceBackedItems = items.filter(item => item.evidencePaths.length > 0).length;
+    const missingEvidenceItems = items.length - evidenceBackedItems;
+    const lowConfidenceItems = items.filter(item => item.confidence < 0.7).length;
+    const averageConfidence = average(items.map(item => clampUnit(item.confidence)));
+    const averageRelevance = average(items.map(item => clampUnit(item.score)));
+    const evidenceRatio = evidenceBackedItems / items.length;
+    const lowConfidenceRatio = lowConfidenceItems / items.length;
+    const score = Math.max(0, Math.round((averageConfidence * 40) + (averageRelevance * 30) + (evidenceRatio * 30) - (lowConfidenceRatio * 10)));
+    return {
+        score,
+        evidenceBackedItems,
+        missingEvidenceItems,
+        lowConfidenceItems,
+        averageConfidence: roundMetric(averageConfidence),
+        averageRelevance: roundMetric(averageRelevance),
+    };
+}
+function average(values) {
+    if (values.length === 0)
+        return 0;
+    return values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+function clampUnit(value) {
+    if (!Number.isFinite(value))
+        return 0;
+    return Math.max(0, Math.min(1, value));
+}
+function roundMetric(value) {
+    return Number(value.toFixed(3));
+}
+function aiOsIntelligenceNextActions(status, signals, lang) {
+    const actions = [];
+    if (signals.some(signal => signal.status === 'ready')) {
+        actions.push('Use intelligence signals during release review to prove memory, context, and skill routing gains.');
+    }
+    if (status === 'ready')
+        return actions;
+    const blocked = signals.filter(signal => signal.status === 'blocked').map(signal => signal.id);
+    if (lang === 'zh') {
+        actions.push(`Refresh AI OS intelligence evidence for: ${blocked.join(', ') || 'warning signals'}.`);
+        return actions;
+    }
+    actions.push(`Refresh AI OS intelligence evidence for: ${blocked.join(', ') || 'warning signals'}.`);
+    return actions;
+}
 function buildRunSteps(plan) {
     const steps = new Map();
     const upsert = (step) => steps.set(step.id, step);
@@ -586,6 +973,144 @@ function resolveRunsDir(projectDir, scaleDir) {
 function resolveBenchmarkReportPath(projectDir, scaleDir) {
     return join(resolveScaleRoot(projectDir, scaleDir), 'ai-os', 'benchmarks', 'latest.json');
 }
+function resolveAdoptionReportPath(projectDir, scaleDir) {
+    return join(resolveScaleRoot(projectDir, scaleDir), 'ai-os', 'adoption.json');
+}
+function aiOsAdoptionNextActions(status, lang) {
+    if (lang === 'zh') {
+        if (status === 'ready')
+            return ['AI OS runtime 接入完成；后续真实任务使用 `scale ai-os run --mode guarded`。'];
+        if (status === 'warning')
+            return ['AI OS runtime 已可用但仍有警告；先运行 `scale ai-os doctor --json --lang zh` 处理剩余项。'];
+        return ['AI OS runtime 接入被阻断；查看 adoption report 和 `scale ai-os doctor --json --lang zh` 的失败项。'];
+    }
+    if (status === 'ready')
+        return ['AI OS runtime adoption is complete; use `scale ai-os run --mode guarded` for governed work.'];
+    if (status === 'warning')
+        return ['AI OS runtime is usable with warnings; run `scale ai-os doctor --json --lang en` and resolve remaining items.'];
+    return ['AI OS runtime adoption is blocked; inspect the adoption report and `scale ai-os doctor --json --lang en` failures.'];
+}
+function aiOsStatusNextActions(status, checks, lang, verificationRecommendations) {
+    const blocked = new Set(checks.filter(check => check.status === 'blocked').map(check => check.id));
+    const firstVerificationCommand = verificationRecommendations[0]?.command ?? '<command>';
+    if (lang === 'zh') {
+        if (status === 'ready')
+            return ['AI OS 闭环已就绪，可使用 `scale ai-os run --mode guarded` 执行受治理任务。'];
+        if (blocked.has('runtime-dirs') || blocked.has('adoption-evidence')) {
+            return ['运行 `scale ai-os adopt --task "接入 AI OS runtime" --lang zh` 生成运行态、首份 dry-run、benchmark 和 doctor 报告。'];
+        }
+        if (blocked.has('verification-evidence'))
+            return ['运行 `scale ai-os run --mode guarded --verify "<command>"` 生成受治理验证证据。'];
+        if (blocked.has('benchmark-evidence'))
+            return ['运行 `scale ai-os benchmark --json` 生成闭环 benchmark 证据。'];
+        return ['查看 status checks，补齐 blocked 项后重新运行 `scale ai-os status --lang zh`。'];
+    }
+    if (status === 'ready')
+        return ['AI OS closed loop is ready for guarded project work.'];
+    if (blocked.has('runtime-dirs') || blocked.has('adoption-evidence')) {
+        return ['Run `scale ai-os adopt --task "Adopt AI OS runtime" --lang en` to create runtime state, first dry-run, benchmark, and doctor reports.'];
+    }
+    if (blocked.has('verification-evidence'))
+        return [`Run \`scale ai-os run --mode guarded --verify "${escapeCliDoubleQuoted(firstVerificationCommand)}"\` to produce governed verification evidence.`];
+    if (blocked.has('benchmark-evidence'))
+        return ['Run `scale ai-os benchmark --json` to produce closed-loop benchmark evidence.'];
+    return ['Inspect status checks, resolve blocked items, then rerun `scale ai-os status --lang en`.'];
+}
+const VERIFICATION_COMMAND_ORDER = ['build', 'lint', 'test', 'smoke', 'coverage'];
+function buildVerificationRecommendations(projectDir, scaleDir, lang) {
+    const recommendations = [];
+    const seen = new Set();
+    const add = (recommendation) => {
+        const key = `${recommendation.command}\n${recommendation.service ?? ''}`;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        recommendations.push(recommendation);
+    };
+    try {
+        const resolved = resolveVerificationTargets({ projectDir, scaleDir, service: 'all' });
+        for (const target of resolved.targets) {
+            for (const name of VERIFICATION_COMMAND_ORDER) {
+                const command = target.config[name];
+                if (!command)
+                    continue;
+                add({
+                    command,
+                    source: 'verification-profile',
+                    reason: verificationRecommendationReason(name, lang),
+                    profile: resolved.profileName,
+                    service: target.service?.name,
+                });
+            }
+        }
+    }
+    catch {
+        // Best effort only. Status should not fail just because verification config is invalid.
+    }
+    if (recommendations.length > 0)
+        return recommendations;
+    for (const item of packageScriptVerificationCommands(projectDir)) {
+        add({
+            command: item.command,
+            source: 'package-script',
+            reason: verificationRecommendationReason(item.name, lang),
+        });
+    }
+    if (recommendations.length > 0)
+        return recommendations;
+    return [{
+            command: 'scale preflight --preflight-profile quick --json',
+            source: 'fallback',
+            reason: lang === 'zh'
+                ? '未找到验证矩阵或 package script，先运行 SCALE 快速预检生成基础验证证据。'
+                : 'No verification matrix or package script was found; run SCALE quick preflight as baseline evidence.',
+        }];
+}
+function packageScriptVerificationCommands(projectDir) {
+    const packageJsonPath = join(projectDir, 'package.json');
+    if (!existsSync(packageJsonPath))
+        return [];
+    try {
+        const parsed = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+        const scripts = parsed.scripts ?? {};
+        const commands = [];
+        if (scripts.build)
+            commands.push({ name: 'build', command: 'npm run build' });
+        if (scripts.lint)
+            commands.push({ name: 'lint', command: 'npm run lint' });
+        if (scripts.test)
+            commands.push({ name: 'test', command: 'npm test' });
+        return commands;
+    }
+    catch {
+        return [];
+    }
+}
+function verificationRecommendationReason(name, lang) {
+    if (lang === 'zh') {
+        if (name === 'build')
+            return '构建验证可以证明代码仍可编译并生成发布产物。';
+        if (name === 'lint')
+            return 'Lint 验证可以捕获工程规范和静态质量问题。';
+        if (name === 'test')
+            return '测试验证可以证明核心行为没有回归。';
+        if (name === 'smoke')
+            return '冒烟验证可以证明关键产品路径仍可用。';
+        return '覆盖率验证可以补充测试充分性证据。';
+    }
+    if (name === 'build')
+        return 'Build verification proves the code still compiles and produces releasable artifacts.';
+    if (name === 'lint')
+        return 'Lint verification catches engineering-standard and static-quality issues.';
+    if (name === 'test')
+        return 'Test verification proves core behavior did not regress.';
+    if (name === 'smoke')
+        return 'Smoke verification proves critical product paths still work.';
+    return 'Coverage verification adds evidence for test adequacy.';
+}
+function escapeCliDoubleQuoted(value) {
+    return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
 function inspectBenchmarkReport(projectDir, scaleDir, maxAgeHours, warnings) {
     const reportPath = resolveBenchmarkReportPath(projectDir, scaleDir);
     if (!existsSync(reportPath))
@@ -613,6 +1138,22 @@ function inspectBenchmarkReport(projectDir, scaleDir, maxAgeHours, warnings) {
         return { status: 'invalid', reportPath };
     }
 }
+function readAiOsBenchmarkReport(reportPath, warnings) {
+    if (!existsSync(reportPath))
+        return undefined;
+    try {
+        const parsed = JSON.parse(readFileSync(reportPath, 'utf-8'));
+        if (!parsed || !parsed.summary || !Array.isArray(parsed.scenarios)) {
+            warnings.push(`Ignored invalid AI OS benchmark report: ${reportPath}`);
+            return undefined;
+        }
+        return parsed;
+    }
+    catch (error) {
+        warnings.push(`Ignored unreadable AI OS benchmark report: ${reportPath} (${error instanceof Error ? error.message : String(error)})`);
+        return undefined;
+    }
+}
 function summarizeBenchmarkDoctor(benchmark) {
     if (benchmark.status === 'missing')
         return 'No AI OS benchmark report found.';