@hongmaple0820/scale-engine 0.27.0 → 0.28.0

package/dist/runtime/AiOsRuntime.js

@@ -1,10 +1,14 @@
-import { resolve } from 'node:path';
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
 import { buildContextPack, scanContextBudget, } from '../context/ContextBudget.js';
 import { createGovernanceRoiReport, } from '../governance/GovernanceRoi.js';
 import { evaluateProgressiveGovernance, } from '../governance/ProgressiveGovernance.js';
 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());
     const scaleDir = input.scaleDir ?? '.scale';
@@ -93,6 +97,1032 @@ export async function createAiOsPlan(input) {
         recommendations: recommendations({ governance, context, memoryRecall, skillPlan }),
     };
 }
+export async function createAiOsRun(input) {
+    const projectDir = resolve(input.projectDir ?? process.cwd());
+    const scaleDir = input.scaleDir ?? '.scale';
+    const mode = input.mode ?? 'dry-run';
+    const plan = await createAiOsPlan({ ...input, projectDir, scaleDir });
+    const generatedAt = new Date().toISOString();
+    const runReportPath = resolveRunReportPath(projectDir, scaleDir, plan.task.taskId ?? `AIOS-RUN-${Date.now()}`);
+    const steps = buildRunSteps(plan);
+    const verification = await runGuardedVerification({
+        projectDir,
+        scaleDir,
+        plan,
+        steps,
+        commands: input.verificationCommands ?? [],
+        timeout: input.commandTimeoutMs,
+        allowShell: input.allowShell,
+        enabled: mode === 'guarded',
+    });
+    const failureCandidates = buildFailureLearningCandidates(plan, steps);
+    const evidence = summarizeRunEvidence(steps);
+    const status = steps.some(step => step.status === 'blocked') ? 'blocked' : 'ready';
+    const report = {
+        version: SCALE_ENGINE_VERSION,
+        generatedAt,
+        mode,
+        dryRun: mode === 'dry-run',
+        status,
+        plan,
+        steps,
+        evidence,
+        verification,
+        failureLearning: {
+            status: failureCandidates.length > 0 ? 'candidate-created' : 'idle',
+            candidates: failureCandidates,
+        },
+        artifacts: {
+            runReport: runReportPath,
+        },
+        nextActions: buildRunNextActions(steps, mode),
+    };
+    writeAiOsRunReport(runReportPath, report);
+    return report;
+}
+export function createAiOsDashboard(input = {}) {
+    const projectDir = resolve(input.projectDir ?? process.cwd());
+    const scaleDir = input.scaleDir ?? '.scale';
+    const runsDir = resolveRunsDir(projectDir, scaleDir);
+    const warnings = [];
+    const reports = readAiOsRunReports(runsDir, warnings);
+    const latestRuns = reports
+        .sort((a, b) => Date.parse(b.generatedAt) - Date.parse(a.generatedAt))
+        .slice(0, input.limit ?? 10)
+        .map(toDashboardRunSummary);
+    const summary = {
+        totalRuns: reports.length,
+        readyRuns: reports.filter(report => report.status === 'ready').length,
+        blockedRuns: reports.filter(report => report.status === 'blocked').length,
+        dryRunRuns: reports.filter(report => report.mode === 'dry-run').length,
+        guardedRuns: reports.filter(report => report.mode === 'guarded').length,
+        verificationCommands: reports.reduce((sum, report) => sum + report.verification.commands.length, 0),
+        failedVerificationCommands: reports.reduce((sum, report) => sum + report.verification.commands.filter(command => command.status === 'failed').length, 0),
+        pendingEvidence: reports.reduce((sum, report) => sum + report.evidence.pending.length, 0),
+        failureLearningCandidates: reports.reduce((sum, report) => sum + report.failureLearning.candidates.length, 0),
+    };
+    const health = summarizeDashboardHealth(summary);
+    return {
+        version: SCALE_ENGINE_VERSION,
+        generatedAt: new Date().toISOString(),
+        runsDir,
+        summary,
+        health,
+        latestRuns,
+        recommendations: dashboardRecommendations(summary),
+        warnings,
+    };
+}
+export async function createAiOsBenchmark(input = {}) {
+    const projectDir = resolve(input.projectDir ?? process.cwd());
+    const scaleDir = input.scaleDir ?? '.scale';
+    const scenarios = defaultBenchmarkScenarios(input.budget);
+    const results = [];
+    for (const scenario of scenarios) {
+        const plan = await createAiOsPlan({
+            projectDir,
+            scaleDir,
+            taskId: `BENCH-${scenario.id}`,
+            task: scenario.task,
+            level: scenario.level,
+            files: scenario.files,
+            services: scenario.services,
+            budget: scenario.budget,
+        });
+        results.push({
+            id: scenario.id,
+            task: scenario.task,
+            level: scenario.level,
+            governanceMode: plan.governance.effectiveMode,
+            metrics: {
+                estimatedTokens: plan.context.totalEstimatedTokens,
+                budget: plan.context.task.budget,
+                estimatedTokenSavings: plan.context.compiler?.estimatedTokenSavings ?? 0,
+                memoryItems: plan.memory.items.length,
+                selectedProviders: plan.memory.selectedProviders,
+                skillSteps: plan.skillPlan.executionPlan.steps.length,
+                requiredSkillSteps: plan.skillPlan.executionPlan.steps.filter(step => step.required).length,
+                gates: plan.adaptiveWorkflow.gates.length,
+                roiModules: plan.roi.modules.length,
+            },
+        });
+    }
+    const summary = summarizeBenchmark(results);
+    const generatedAt = new Date().toISOString();
+    const benchmarkReport = resolveBenchmarkReportPath(projectDir, scaleDir);
+    const report = {
+        version: SCALE_ENGINE_VERSION,
+        generatedAt,
+        scenarios: results,
+        summary,
+        dashboard: createAiOsDashboard({ projectDir, scaleDir }),
+        artifacts: {
+            benchmarkReport,
+        },
+        recommendations: benchmarkRecommendations(summary),
+    };
+    writeAiOsBenchmarkReport(benchmarkReport, report);
+    return report;
+}
+export function createAiOsMigration(input = {}) {
+    const projectDir = resolve(input.projectDir ?? process.cwd());
+    const scaleDir = input.scaleDir ?? '.scale';
+    const scaleRoot = isAbsolute(scaleDir) ? scaleDir : join(projectDir, scaleDir);
+    const requiredDirs = [
+        join(scaleRoot, 'ai-os'),
+        join(scaleRoot, 'ai-os', 'runs'),
+        join(scaleRoot, 'ai-os', 'benchmarks'),
+        join(scaleRoot, 'ai-os', 'migrations'),
+    ];
+    const created = [];
+    const existing = [];
+    for (const dir of requiredDirs) {
+        if (existsSync(dir)) {
+            existing.push(normalizeProjectPath(projectDir, dir));
+            continue;
+        }
+        mkdirSync(dir, { recursive: true });
+        created.push(normalizeProjectPath(projectDir, dir));
+    }
+    const migrationReport = join(scaleRoot, 'ai-os', 'migrations', 'migration.json');
+    const report = {
+        version: SCALE_ENGINE_VERSION,
+        generatedAt: new Date().toISOString(),
+        status: created.length > 0 ? 'migrated' : 'compatible',
+        scaleRoot,
+        created,
+        existing,
+        files: {
+            migrationReport,
+        },
+        warnings: [],
+        nextActions: created.length > 0
+            ? ['Run `scale ai-os run --dry-run --json` to create the first AI OS runtime report.']
+            : ['AI OS runtime directories are compatible; continue with run, dashboard, or benchmark commands.'],
+    };
+    writeFileSync(migrationReport, JSON.stringify(report, null, 2), 'utf-8');
+    return report;
+}
+export function createAiOsDoctor(input = {}) {
+    const projectDir = resolve(input.projectDir ?? process.cwd());
+    const scaleDir = input.scaleDir ?? '.scale';
+    const scaleRoot = resolveScaleRoot(projectDir, scaleDir);
+    const benchmarkMaxAgeHours = input.benchmarkMaxAgeHours ?? 24;
+    const lang = input.lang ?? 'en';
+    const warnings = [];
+    const dashboard = createAiOsDashboard({ projectDir, scaleDir });
+    const benchmark = inspectBenchmarkReport(projectDir, scaleDir, benchmarkMaxAgeHours, warnings);
+    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 checks = [
+        {
+            id: 'ai-os-runtime-dirs',
+            title: 'AI OS runtime directories',
+            status: missingDirs.length === 0 ? 'passed' : 'blocked',
+            summary: missingDirs.length === 0
+                ? 'Required AI OS runtime directories exist.'
+                : `Missing AI OS runtime directories: ${missingDirs.join(', ')}.`,
+            evidence: missingDirs.length === 0 ? requiredDirs.map(dir => normalizeProjectPath(projectDir, dir)) : missingDirs,
+        },
+        {
+            id: 'ai-os-run-history',
+            title: 'AI OS run history',
+            status: dashboard.summary.totalRuns > 0 ? 'passed' : 'warning',
+            summary: dashboard.summary.totalRuns > 0
+                ? `${dashboard.summary.totalRuns} run report(s), ${dashboard.summary.guardedRuns} guarded.`
+                : 'No AI OS run reports found yet.',
+            evidence: dashboard.latestRuns.map(run => run.runReport),
+        },
+        {
+            id: 'ai-os-dashboard-health',
+            title: 'AI OS dashboard health',
+            status: dashboard.health.status === 'blocked'
+                ? 'blocked'
+                : dashboard.health.status === 'healthy' ? 'passed' : 'warning',
+            summary: `${dashboard.health.status} (${dashboard.health.score}): ${dashboard.health.reasons.join('; ')}`,
+            evidence: dashboard.health.reasons,
+        },
+        {
+            id: 'ai-os-benchmark',
+            title: 'AI OS benchmark evidence',
+            status: benchmark.status === 'fresh' ? 'passed' : benchmark.status === 'invalid' ? 'blocked' : 'warning',
+            summary: summarizeBenchmarkDoctor(benchmark),
+            evidence: [benchmark.reportPath],
+        },
+    ];
+    const summary = {
+        totalChecks: checks.length,
+        passedChecks: checks.filter(check => check.status === 'passed').length,
+        warningChecks: checks.filter(check => check.status === 'warning').length,
+        blockedChecks: checks.filter(check => check.status === 'blocked').length,
+    };
+    const status = summary.blockedChecks > 0
+        ? 'blocked'
+        : summary.warningChecks > 0 ? 'warning' : 'ready';
+    return {
+        version: SCALE_ENGINE_VERSION,
+        generatedAt: new Date().toISOString(),
+        status,
+        projectDir,
+        scaleRoot,
+        dashboard,
+        benchmark,
+        checks,
+        summary,
+        warnings: [...warnings, ...dashboard.warnings],
+        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 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,
+        verificationRecommendations,
+        nextActions: aiOsStatusNextActions(status, checks, lang, verificationRecommendations),
+        warnings: [...warnings, ...doctor.warnings],
+    };
+}
+function buildRunSteps(plan) {
+    const steps = new Map();
+    const upsert = (step) => steps.set(step.id, step);
+    upsert({
+        id: 'runtime-plan',
+        kind: 'plan',
+        title: 'Create unified AI OS runtime plan',
+        status: 'passed',
+        required: true,
+        summary: `Governance mode ${plan.governance.effectiveMode}; ${plan.skillPlan.executionPlan.steps.length} skill step(s).`,
+        evidence: ['governance', 'context', 'memory', 'skillPlan', 'roi'],
+    });
+    upsert({
+        id: 'context-compiler',
+        kind: 'context',
+        title: 'Compile task context',
+        status: 'passed',
+        required: true,
+        summary: `${plan.context.totalEstimatedTokens}/${plan.context.task.budget} estimated tokens; saved ${plan.context.compiler?.estimatedTokenSavings ?? 0}.`,
+        evidence: ['context.compiler', 'context.includedSections', 'context.omittedSections'],
+        dependsOn: ['runtime-plan'],
+    });
+    upsert({
+        id: 'memory-provider-recall',
+        kind: 'memory',
+        title: 'Recall provider-backed memory',
+        status: 'passed',
+        required: true,
+        summary: `${plan.memory.items.length} recalled item(s); providers ${plan.memory.providerOrder.join(' -> ')}.`,
+        evidence: ['memory.providerOrder', 'memory.selectedProviders', 'memory.items'],
+        dependsOn: ['runtime-plan'],
+    });
+    for (const gate of plan.adaptiveWorkflow.gates) {
+        if (steps.has(gate))
+            continue;
+        upsert({
+            id: gate,
+            kind: gate === 'runtime-evidence' ? 'evidence' : 'gate',
+            title: `Satisfy ${gate} gate`,
+            status: 'planned',
+            required: true,
+            summary: `Required by ${plan.adaptiveWorkflow.strategy} in ${plan.adaptiveWorkflow.mode} mode.`,
+            evidence: [`gate.${gate}`],
+            dependsOn: ['runtime-plan'],
+        });
+    }
+    for (const skillStep of plan.skillPlan.executionPlan.steps) {
+        upsert({
+            id: `skill:${skillStep.id}`,
+            kind: 'skill',
+            title: `${skillStep.kind}: ${skillStep.id}`,
+            status: 'planned',
+            required: skillStep.required,
+            summary: `${skillStep.reason} Fallback: ${skillStep.fallback}.`,
+            evidence: [skillStep.evidenceRequired],
+            dependsOn: ['skill-evidence'],
+        });
+    }
+    upsert({
+        id: 'failure-learning',
+        kind: 'learning',
+        title: 'Prepare failure learning settlement',
+        status: 'planned',
+        required: false,
+        summary: 'Create lesson or rule candidates only when a gate, verification step, or evidence requirement fails.',
+        evidence: ['failureLearning.candidates'],
+        dependsOn: ['runtime-evidence'],
+    });
+    return [...steps.values()];
+}
+async function runGuardedVerification(options) {
+    if (!options.enabled || options.commands.length === 0) {
+        return { commands: [], allPassed: options.commands.length === 0 };
+    }
+    const ledger = new RuntimeEvidenceLedger({
+        projectDir: options.projectDir,
+        scaleDir: options.scaleDir,
+    });
+    const reports = [];
+    for (const [index, command] of options.commands.entries()) {
+        const stepId = `verify-command:${index + 1}`;
+        let result;
+        try {
+            result = await runSafeCommand(command, {
+                cwd: options.projectDir,
+                timeout: options.timeout ?? 120_000,
+                allowShell: options.allowShell,
+            });
+        }
+        catch (error) {
+            result = {
+                exitCode: 1,
+                stdout: '',
+                stderr: error instanceof Error ? error.message : String(error),
+            };
+        }
+        const passed = result.exitCode === 0;
+        const evidence = ledger.record({
+            taskId: options.plan.task.taskId,
+            kind: 'command',
+            title: `AI OS verification command ${index + 1}`,
+            status: passed ? 'passed' : 'failed',
+            command,
+            exitCode: result.exitCode,
+            summary: passed
+                ? `Guarded verification command passed: ${command}`
+                : `Guarded verification command failed with exit code ${result.exitCode}: ${command}`,
+            metadata: {
+                aiOsRun: true,
+                stepId,
+                stdoutPreview: truncate(result.stdout),
+                stderrPreview: truncate(result.stderr),
+            },
+        });
+        reports.push({
+            command,
+            status: passed ? 'passed' : 'failed',
+            exitCode: result.exitCode,
+            stdout: result.stdout,
+            stderr: result.stderr,
+            evidenceId: evidence.id,
+        });
+        options.steps.push({
+            id: stepId,
+            kind: 'evidence',
+            title: `Run verification command ${index + 1}`,
+            status: passed ? 'passed' : 'blocked',
+            required: true,
+            summary: passed
+                ? `Command passed and runtime evidence was recorded as ${evidence.id}.`
+                : `Command failed and runtime evidence was recorded as ${evidence.id}.`,
+            evidence: [evidence.id],
+            dependsOn: ['runtime-evidence'],
+        });
+    }
+    const runtimeEvidenceStep = options.steps.find(step => step.id === 'runtime-evidence');
+    if (runtimeEvidenceStep) {
+        const allPassed = reports.every(report => report.status === 'passed');
+        runtimeEvidenceStep.status = allPassed ? 'passed' : 'blocked';
+        runtimeEvidenceStep.summary = allPassed
+            ? `${reports.length} guarded verification command(s) passed and were recorded as runtime evidence.`
+            : `${reports.filter(report => report.status === 'failed').length}/${reports.length} guarded verification command(s) failed.`;
+        runtimeEvidenceStep.evidence = reports.map(report => report.evidenceId);
+    }
+    return {
+        commands: reports,
+        allPassed: reports.every(report => report.status === 'passed'),
+    };
+}
+function summarizeRunEvidence(steps) {
+    const required = new Set();
+    const produced = new Set();
+    const pending = new Set();
+    for (const step of steps) {
+        if (step.required) {
+            for (const item of evidenceCategory(step))
+                required.add(item);
+        }
+        if (step.status === 'passed') {
+            for (const item of evidenceCategory(step))
+                produced.add(item);
+        }
+        else if (step.required && step.status === 'planned') {
+            for (const item of evidenceCategory(step))
+                pending.add(item);
+        }
+    }
+    return {
+        required: [...required],
+        produced: [...produced],
+        pending: [...pending],
+    };
+}
+function evidenceCategory(step) {
+    if (step.id === 'runtime-plan')
+        return ['ai-os-plan'];
+    if (step.id === 'context-compiler')
+        return ['context-compiler'];
+    if (step.id === 'memory-provider-recall')
+        return ['memory-provider-recall'];
+    if (step.id === 'skill-evidence' || step.kind === 'skill')
+        return ['skill-routing-engine'];
+    if (step.id === 'runtime-evidence' || step.kind === 'evidence')
+        return ['runtime-evidence'];
+    if (step.kind === 'gate')
+        return [`gate:${step.id}`];
+    return [step.id];
+}
+function buildFailureLearningCandidates(plan, steps) {
+    const hasBlockedVerification = steps.some(step => step.status === 'blocked' && step.id.startsWith('verify-command:'));
+    const failed = steps.filter(step => step.status === 'blocked' && !(hasBlockedVerification && step.id === 'runtime-evidence'));
+    return failed.map(step => ({
+        id: `AIO-FLC-${safePathSegment(plan.task.taskId ?? step.id)}-${safePathSegment(step.id)}`,
+        source: 'failed-step',
+        title: `Failure learning candidate: ${step.title}`,
+        summary: step.summary,
+        recommendedAction: 'resolve-before-promotion',
+        evidenceRefs: step.evidence,
+        promotable: false,
+    }));
+}
+function buildRunNextActions(steps, mode) {
+    const actions = [];
+    for (const step of steps) {
+        if (step.status !== 'planned' || !step.required)
+            continue;
+        if (step.kind === 'skill')
+            actions.push(`Execute required skill step "${step.title}" and attach evidence: ${step.evidence.join(', ')}.`);
+        else if (step.kind === 'evidence')
+            actions.push(`Record runtime evidence for "${step.id}" before claiming completion.`);
+        else if (step.kind === 'gate')
+            actions.push(`Satisfy gate "${step.id}" before ship.`);
+    }
+    if (mode === 'dry-run')
+        actions.push('Re-run with guarded execution only after reviewing the dry-run report.');
+    return actions;
+}
+function resolveRunReportPath(projectDir, scaleDir, taskId) {
+    return join(resolveRunsDir(projectDir, scaleDir), `${safePathSegment(taskId)}.json`);
+}
+function writeAiOsRunReport(path, report) {
+    const dir = dirname(path);
+    if (dir && !existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    writeFileSync(path, JSON.stringify(report, null, 2), 'utf-8');
+}
+function safePathSegment(value) {
+    return value.replace(/[^a-zA-Z0-9._-]/g, '-').slice(0, 120) || 'ai-os-run';
+}
+function truncate(value, max = 1000) {
+    return value.length > max ? `${value.slice(0, max)}...` : value;
+}
+function normalizeProjectPath(projectDir, path) {
+    const normalizedProject = resolve(projectDir);
+    const normalizedPath = resolve(path);
+    if (normalizedPath.startsWith(normalizedProject)) {
+        return normalizedPath.slice(normalizedProject.length + 1).replace(/\\/g, '/');
+    }
+    return normalizedPath.replace(/\\/g, '/');
+}
+function resolveScaleRoot(projectDir, scaleDir) {
+    return isAbsolute(scaleDir) ? scaleDir : join(projectDir, scaleDir);
+}
+function resolveRunsDir(projectDir, scaleDir) {
+    return join(resolveScaleRoot(projectDir, scaleDir), 'ai-os', 'runs');
+}
+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))
+        return { status: 'missing', reportPath };
+    try {
+        const parsed = JSON.parse(readFileSync(reportPath, 'utf-8'));
+        if (!parsed.generatedAt || !parsed.summary || typeof parsed.summary.scenarios !== 'number') {
+            warnings.push(`Invalid AI OS benchmark report: ${reportPath}`);
+            return { status: 'invalid', reportPath };
+        }
+        const generatedAtMs = Date.parse(parsed.generatedAt);
+        const ageHours = Number(((Date.now() - generatedAtMs) / 3_600_000).toFixed(2));
+        const fileAgeHours = Number(((Date.now() - statSync(reportPath).mtimeMs) / 3_600_000).toFixed(2));
+        const effectiveAgeHours = Number.isFinite(ageHours) ? ageHours : fileAgeHours;
+        return {
+            status: effectiveAgeHours <= maxAgeHours ? 'fresh' : 'stale',
+            reportPath,
+            generatedAt: parsed.generatedAt,
+            ageHours: effectiveAgeHours,
+            scenarios: parsed.summary.scenarios,
+        };
+    }
+    catch (error) {
+        warnings.push(`Unreadable AI OS benchmark report: ${reportPath} (${error instanceof Error ? error.message : String(error)})`);
+        return { status: 'invalid', reportPath };
+    }
+}
+function summarizeBenchmarkDoctor(benchmark) {
+    if (benchmark.status === 'missing')
+        return 'No AI OS benchmark report found.';
+    if (benchmark.status === 'invalid')
+        return 'AI OS benchmark report is invalid or unreadable.';
+    const age = benchmark.ageHours === undefined ? 'unknown age' : `${benchmark.ageHours}h old`;
+    return `${benchmark.scenarios ?? 0} benchmark scenario(s); ${age}; status ${benchmark.status}.`;
+}
+function aiOsDoctorNextActions(input) {
+    if (input.lang === 'zh')
+        return aiOsDoctorNextActionsZh(input);
+    return aiOsDoctorNextActionsEn(input);
+}
+function aiOsDoctorNextActionsEn(input) {
+    const actions = [];
+    if (input.checks.some(check => check.id === 'ai-os-runtime-dirs' && check.status === 'blocked')) {
+        actions.push('Run `scale ai-os migrate --json` before using the AI OS beta runtime.');
+    }
+    if (input.dashboard.summary.totalRuns === 0) {
+        actions.push('Run `scale ai-os run --dry-run --json` to create the first AI OS run report.');
+    }
+    if (input.dashboard.summary.blockedRuns > 0) {
+        actions.push('Resolve blocked AI OS runs before claiming the project is ready.');
+    }
+    if (input.benchmark.status === 'missing' || input.benchmark.status === 'stale') {
+        actions.push('Run `scale ai-os benchmark --json` before release or milestone review.');
+    }
+    if (input.status === 'ready')
+        actions.push('AI OS beta runtime is ready for guarded project tasks.');
+    return actions;
+}
+function aiOsDoctorNextActionsZh(input) {
+    const actions = [];
+    if (input.checks.some(check => check.id === 'ai-os-runtime-dirs' && check.status === 'blocked')) {
+        actions.push('先运行 `scale ai-os migrate --json`，再接入 AI OS beta runtime。');
+    }
+    if (input.dashboard.summary.totalRuns === 0) {
+        actions.push('运行 `scale ai-os run --dry-run --json` 生成第一份 AI OS 运行报告。');
+    }
+    if (input.dashboard.summary.blockedRuns > 0) {
+        actions.push('先处理 blocked 的 AI OS run，再声明项目运行态就绪。');
+    }
+    if (input.benchmark.status === 'missing' || input.benchmark.status === 'stale') {
+        actions.push('发版或阶段验收前运行 `scale ai-os benchmark --json`。');
+    }
+    if (input.status === 'ready')
+        actions.push('AI OS beta runtime 已可用于 guarded 项目任务。');
+    return actions;
+}
+function writeAiOsBenchmarkReport(path, report) {
+    const dir = dirname(path);
+    if (dir && !existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    writeFileSync(path, JSON.stringify(report, null, 2), 'utf-8');
+}
+function readAiOsRunReports(runsDir, warnings) {
+    if (!existsSync(runsDir))
+        return [];
+    return readdirSync(runsDir)
+        .filter(file => file.endsWith('.json'))
+        .flatMap(file => {
+        const path = join(runsDir, file);
+        try {
+            const parsed = JSON.parse(readFileSync(path, 'utf-8'));
+            if (!parsed || !parsed.plan || !parsed.evidence || !parsed.verification) {
+                warnings.push(`Ignored invalid AI OS run report: ${path}`);
+                return [];
+            }
+            return [parsed];
+        }
+        catch (error) {
+            warnings.push(`Ignored unreadable AI OS run report: ${path} (${error instanceof Error ? error.message : String(error)})`);
+            return [];
+        }
+    });
+}
+function toDashboardRunSummary(report) {
+    return {
+        taskId: report.plan.task.taskId,
+        task: report.plan.task.task,
+        mode: report.mode,
+        status: report.status,
+        generatedAt: report.generatedAt,
+        runReport: report.artifacts.runReport,
+        verificationCommands: report.verification.commands.length,
+        failedVerificationCommands: report.verification.commands.filter(command => command.status === 'failed').length,
+        pendingEvidence: report.evidence.pending.length,
+        failureLearningCandidates: report.failureLearning.candidates.length,
+    };
+}
+function summarizeDashboardHealth(summary) {
+    if (summary.totalRuns === 0) {
+        return { status: 'empty', score: 0, reasons: ['No AI OS run reports found.'] };
+    }
+    const reasons = [];
+    if (summary.blockedRuns > 0)
+        reasons.push(`${summary.blockedRuns} blocked AI OS run(s).`);
+    if (summary.failedVerificationCommands > 0)
+        reasons.push(`${summary.failedVerificationCommands} failed guarded verification command(s).`);
+    if (summary.failureLearningCandidates > 0)
+        reasons.push(`${summary.failureLearningCandidates} failure learning candidate(s) need review.`);
+    const score = Math.max(0, Math.round(((summary.readyRuns / summary.totalRuns) * 100) - (summary.failedVerificationCommands * 10) - (summary.failureLearningCandidates * 5)));
+    if (summary.blockedRuns === summary.totalRuns)
+        return { status: 'blocked', score, reasons };
+    if (reasons.length > 0)
+        return { status: 'attention', score, reasons };
+    return { status: 'healthy', score: 100, reasons: ['All AI OS runs are ready.'] };
+}
+function dashboardRecommendations(summary) {
+    const recommendations = [];
+    if (summary.totalRuns === 0) {
+        recommendations.push('Run `scale ai-os run --dry-run` to create the first AI OS execution report.');
+        return recommendations;
+    }
+    if (summary.blockedRuns > 0)
+        recommendations.push('Resolve blocked AI OS run reports before promoting lessons or shipping.');
+    if (summary.failedVerificationCommands > 0)
+        recommendations.push('Inspect failed guarded verification runtime evidence and fix the underlying command or code issue.');
+    if (summary.failureLearningCandidates > 0)
+        recommendations.push('Review failure learning candidates before turning them into durable rules.');
+    if (summary.guardedRuns === 0)
+        recommendations.push('Add guarded verification runs for at least one representative task to validate evidence flow.');
+    return recommendations;
+}
+function defaultBenchmarkScenarios(budget = 8_000) {
+    return [
+        {
+            id: 'docs-governance',
+            task: 'Update bilingual governance documentation and keep README, docs map, and strategy aligned',
+            level: 'M',
+            files: ['README.md', 'README.en.md', 'docs/README.md', 'docs/AI_ENGINEERING_OS_POSITIONING.md'],
+            services: ['docs'],
+            budget,
+        },
+        {
+            id: 'security-code-change',
+            task: 'Harden auth token handling and verify runtime evidence for a security-sensitive code change',
+            level: 'L',
+            files: ['src/auth/token.ts', 'src/runtime/AiOsRuntime.ts', 'tests/runtime/aiOsRuntime.test.ts'],
+            services: ['runtime', 'security'],
+            budget,
+        },
+        {
+            id: 'browser-ui-flow',
+            task: 'Verify a browser callback UI flow with screenshots, runtime evidence, and guarded workflow gates',
+            level: 'L',
+            files: ['src/ui/callback.tsx', 'tests/api/aiOsCli.test.ts'],
+            services: ['ui', 'browser'],
+            budget,
+        },
+    ];
+}
+function summarizeBenchmark(results) {
+    const totalBudget = results.reduce((sum, result) => sum + result.metrics.budget, 0);
+    const totalEstimatedTokens = results.reduce((sum, result) => sum + result.metrics.estimatedTokens, 0);
+    return {
+        scenarios: results.length,
+        totalEstimatedTokens,
+        totalBudget,
+        totalEstimatedTokenSavings: results.reduce((sum, result) => sum + result.metrics.estimatedTokenSavings, 0),
+        totalMemoryItems: results.reduce((sum, result) => sum + result.metrics.memoryItems, 0),
+        totalSkillSteps: results.reduce((sum, result) => sum + result.metrics.skillSteps, 0),
+        requiredSkillSteps: results.reduce((sum, result) => sum + result.metrics.requiredSkillSteps, 0),
+        governanceModes: [...new Set(results.map(result => result.governanceMode))],
+        averageTokenUtilization: totalBudget > 0 ? Number((totalEstimatedTokens / totalBudget).toFixed(4)) : 0,
+    };
+}
+function benchmarkRecommendations(summary) {
+    const recommendations = ['Use benchmark deltas in release notes only after comparing the same scenario set across versions.'];
+    if (summary.totalSkillSteps === 0)
+        recommendations.push('Skill routing did not produce steps; inspect skill policy detection.');
+    if (summary.averageTokenUtilization > 0.9)
+        recommendations.push('Context utilization is high; lower budgets or improve relevance filtering before scaling.');
+    if (!summary.governanceModes.includes('critical') && !summary.governanceModes.includes('expanded')) {
+        recommendations.push('Add at least one high-risk benchmark scenario before claiming adaptive governance coverage.');
+    }
+    return recommendations;
+}
 function createAdaptiveWorkflow(governance, skillPlan) {
     const gates = new Set();
     gates.add('context-compiler');