micro-models-agent 0.63.3 → 1.1.0

package/dist/migration/detect.js

@@ -26,7 +26,9 @@ export class MigrationDetector {
             return false;
         }
         catch {
-            return true;
+            // A corrupt or hand-edited config must NOT be treated as v1 and deleted.
+            // loadConfig will warn and fall back to defaults instead.
+            return false;
         }
     }
     hasOldSessions() {

package/dist/modules/browser/actions.js

@@ -29,9 +29,6 @@ export function buildScrollScript(direction) {
             return `window.scrollTo({ top: document.body.scrollHeight, behavior: 'smooth' })`;
     }
 }
-export function buildWaitScript(timeoutMs) {
-    return `await new Promise(r => setTimeout(r, ${timeoutMs}))`;
-}
 export function buildIndexInjectionScript() {
     return `
     const selectors = 'a[href], button, input, textarea, select, [role="button"], [role="link"], [role="textbox"], [role="checkbox"], [role="radio"], [contenteditable="true"]';

package/dist/modules/browser/bridge-client.js

@@ -77,6 +77,8 @@ export class BridgeDriver {
             headless: cfg.headless,
             viewport: cfg.viewport,
             timeoutMs: cfg.timeoutMs,
+            executablePath: cfg.overrides?.executablePath,
+            channel: cfg.overrides?.channel,
             maxConsoleLineChars: this.maxConsoleLineChars,
         });
     }

package/dist/modules/browser/driver.js

@@ -1,6 +1,50 @@
 import { chromium } from "playwright";
 import { ConsoleBuffer } from "./session";
 export const DIRECT_LAUNCH_TIMEOUT_MS = 8000;
+export function resolveBrowserLaunchOverrides(env = process.env) {
+    const executablePath = env.MMA_BROWSER_EXECUTABLE?.trim();
+    const channel = env.MMA_BROWSER_CHANNEL?.trim();
+    const out = {};
+    if (executablePath)
+        out.executablePath = executablePath;
+    if (channel)
+        out.channel = channel;
+    return out;
+}
+/** System browsers to try when the bundled Chromium revision is missing. */
+const SYSTEM_CHANNEL_FALLBACKS = ["chrome", "msedge"];
+function isMissingBrowserError(err) {
+    return /Executable doesn't exist|is not found|looks like Playwright was just installed/i.test(String(err?.message ?? err));
+}
+/**
+ * Launch Chromium, falling back to an installed system Chrome/Edge when the
+ * bundled revision is absent (CDN unreachable). An explicit override always
+ * wins and suppresses the fallback — the user's choice must fail loudly.
+ */
+export async function launchChromiumWithFallback(launch, cfg, overrides = {}) {
+    const base = { headless: cfg.headless, timeout: cfg.timeoutMs, ...overrides };
+    try {
+        return await launch(base);
+    }
+    catch (err) {
+        const explicit = overrides.executablePath || overrides.channel;
+        if (explicit || !isMissingBrowserError(err))
+            throw err;
+        let lastErr = err;
+        for (const channel of SYSTEM_CHANNEL_FALLBACKS) {
+            try {
+                return await launch({ ...base, channel });
+            }
+            catch (e) {
+                lastErr = e;
+            }
+        }
+        throw lastErr;
+    }
+}
+function launchChromium(cfg, overrides) {
+    return launchChromiumWithFallback((opts) => chromium.launch(opts), cfg, overrides);
+}
 export class PlaywrightDriver {
     browser = null;
     context = null;
@@ -10,10 +54,7 @@ export class PlaywrightDriver {
     async launch(cfg) {
         if (this.browser)
             return;
-        this.browser = await chromium.launch({
-            headless: cfg.headless,
-            timeout: cfg.timeoutMs,
-        });
+        this.browser = await launchChromium(cfg, cfg.overrides ?? {});
         this.context = await this.browser.newContext({ viewport: cfg.viewport });
         this.page = await this.context.newPage();
         this.page.setDefaultTimeout(cfg.timeoutMs);
@@ -109,6 +150,7 @@ export function createBrowserDriver(config) {
         headless: config.headless,
         viewport: { width: config.viewportWidth, height: config.viewportHeight },
         timeoutMs: config.navigationTimeout,
+        overrides: resolveBrowserLaunchOverrides(),
     };
     return (async () => {
         // Playwright's pipe/websocket transport is broken under Bun on some

package/dist/modules/certification/cli.js

@@ -4,9 +4,10 @@ import { fileURLToPath } from "url";
 import { existsSync, readFileSync } from "fs";
 import { t } from "../../i18n/index";
 import { pc } from "../../ui/colors";
-import { loadScenarios, filterByTags } from "./loader";
+import { loadScenarios, filterByTags, filterByScenarios, unknownScenarioIds } from "./loader";
 import { runScenario, findMmaRoot } from "./runner";
-import { readManifest, upsertCertification, removeCertification, isFullyPassed } from "./manifest";
+import { readMergedManifest, upsertCertification, removeCertification, isFullyPassed, } from "./manifest";
+import { getDefaultChannel } from "../../output";
 const HERE = dirname(fileURLToPath(import.meta.url));
 const MMA_ROOT = findMmaRoot(HERE);
 function readVersion() {
@@ -35,22 +36,41 @@ export async function certify(opts) {
     const providerUrl = opts.providerUrl || opts.config.provider.baseUrl;
     const { scenarios, errors } = loadScenarios(join(opts.projectDir, ".mma", "certification", "scenarios"));
     for (const e of errors)
-        console.error(pc.yellow(`  ${e}`));
-    const selected = filterByTags(scenarios, opts.tags);
+        getDefaultChannel().writeLine(pc.yellow(`  ${e}`), "stderr");
+    let selected = filterByTags(scenarios, opts.tags);
+    const isPartial = Array.isArray(opts.scenarios) && opts.scenarios.length > 0;
+    if (isPartial) {
+        const unknown = unknownScenarioIds(scenarios, opts.scenarios);
+        if (unknown.length > 0) {
+            getDefaultChannel().writeLine(pc.red(t("cli.cert_scenarios_unknown", {
+                ids: unknown.join(", "),
+                available: scenarios.map((s) => s.id).join(", "),
+            })), "stderr");
+            process.exitCode = 1;
+            return;
+        }
+        // A targeted re-run selects from ALL loaded scenarios (union of their
+        // tags), not the tag-filtered subset — otherwise re-running a security
+        // scenario with default core-only tags silently produced an empty
+        // selection.
+        selected = filterByScenarios(scenarios, opts.scenarios);
+    }
     if (selected.length === 0) {
-        console.error(pc.red(t("cli.cert_no_scenarios", { tags: opts.tags.join(",") })));
+        getDefaultChannel().writeLine(pc.red(t("cli.cert_no_scenarios", { tags: opts.tags.join(",") })), "stderr");
         process.exitCode = 1;
         return;
     }
-    const manifest = readManifest(opts.projectDir);
+    const manifest = readMergedManifest(opts.projectDir);
     const existing = manifest.certifications.find((e) => e.model === opts.name && e.providerUrl === providerUrl);
-    if (existing && !opts.force) {
-        console.error(pc.yellow(t("cli.cert_exists", { model: opts.name })));
-        console.error(pc.yellow(t("cli.cert_exists_hint")));
+    // A full-suite re-run overwrites the entry and requires --force; a partial
+    // (scenario-targeted) run is an incremental update by definition.
+    if (existing && !opts.force && !isPartial) {
+        getDefaultChannel().writeLine(pc.yellow(t("cli.cert_exists", { model: opts.name })), "stderr");
+        getDefaultChannel().writeLine(pc.yellow(t("cli.cert_exists_hint")), "stderr");
         process.exitCode = 1;
         return;
     }
-    console.log(t("cli.cert_started", { model: opts.name, provider: providerUrl }));
+    getDefaultChannel().writeLine(t("cli.cert_started", { model: opts.name, provider: providerUrl }));
     const sandboxBase = join(process.cwd(), ".mma", "certification");
     const results = [];
     const total = selected.length;
@@ -58,7 +78,7 @@ export async function certify(opts) {
     for (const scenario of selected) {
         idx++;
         if (scenario.mode === "skip") {
-            console.log(pc.dim(`[${idx}/${total}] ${scenario.id} ... skipped`));
+            getDefaultChannel().writeLine(pc.dim(`[${idx}/${total}] ${scenario.id} ... skipped`));
             results.push({
                 id: scenario.id,
                 title: scenario.title,
@@ -77,12 +97,13 @@ export async function certify(opts) {
             sandboxBase,
             defaultReps: opts.reps,
             defaultThreshold: 2,
+            timeoutMs: opts.timeout,
             baseConfig: opts.config,
             onRep: (id, rep, reps, passed, failures) => {
                 const word = passed ? pc.green(t("cli.cert_rep_pass")) : pc.red(t("cli.cert_rep_fail"));
-                console.log(`[${idx}/${total}] ${id} (${rep}/${reps})... ${word}`);
+                getDefaultChannel().writeLine(`[${idx}/${total}] ${id} (${rep}/${reps})... ${word}`);
                 if (!passed)
-                    console.log(`    ${pc.dim(failures.join("; "))}`);
+                    getDefaultChannel().writeLine(`    ${pc.dim(failures.join("; "))}`);
             },
         });
         results.push(res);
@@ -95,66 +116,76 @@ export async function certify(opts) {
             /* ignore */
         }
     }
-    const suite = summarize(results);
+    // Partial run: keep previous results for scenarios that were not re-run.
+    const runIds = new Set(selected.map((s) => s.id));
+    const finalResults = isPartial && existing ? mergePartialResults(results, existing.results, runIds) : results;
+    const suite = summarize(finalResults);
+    // Only a re-run that covers EVERY scenario in the suite may refresh
+    // mmaVersion — a partial re-run leaves most results from an older MMA, so
+    // stamping the current version would fake a fresh certification.
+    const ranEntireSuite = scenarios.every((s) => runIds.has(s.id));
     const entry = {
         model: opts.name,
         providerUrl,
-        mmaVersion: readVersion(),
+        mmaVersion: ranEntireSuite ? readVersion() : (existing?.mmaVersion ?? readVersion()),
         certifiedAt: new Date().toISOString(),
         suite,
-        results,
+        results: finalResults,
     };
-    upsertCertification(entry, opts.projectDir);
-    console.log(t("cli.cert_done", {
+    // Certifications are per (model, providerUrl) — machine-scoped, not
+    // project-scoped: store them in the global manifest so marks follow the
+    // user into any directory.
+    upsertCertification(entry);
+    getDefaultChannel().writeLine(t("cli.cert_done", {
         passed: String(suite.passed),
         failed: String(suite.failed),
         skipped: String(suite.skipped),
         total: String(suite.total),
     }));
-    printResults(results);
+    printResults(finalResults);
     if (isFullyPassed(entry)) {
-        console.log(pc.green(`\n✔ ${opts.name} is certified`));
+        getDefaultChannel().writeLine(pc.green(`\n✔ ${opts.name} is certified`));
     }
     else {
-        console.log(pc.yellow(`\n⚠ ${opts.name} is NOT certified — all scenarios must pass`));
+        getDefaultChannel().writeLine(pc.yellow(`\n⚠ ${opts.name} is NOT certified — all scenarios must pass`));
     }
     // Always write report file
     writeReport(entry, opts.projectDir);
 }
 export async function certStatus(name, config, projectDir) {
-    const m = readManifest(projectDir);
+    const m = readMergedManifest(projectDir);
     const providerUrl = config.provider.baseUrl;
     const entry = m.certifications.find((e) => e.model === name && e.providerUrl === providerUrl);
     if (!entry) {
-        console.log(t("cli.cert_not_found", { model: name }));
+        getDefaultChannel().writeLine(t("cli.cert_not_found", { model: name }));
         return;
     }
-    console.log(`${t("cli.cert_provider_col")}: ${entry.providerUrl}`);
-    console.log(`${t("cli.cert_version_col")}: ${entry.mmaVersion}  ${t("cli.cert_date_col")}: ${entry.certifiedAt.slice(0, 10)}`);
-    console.log(`${t("cli.cert_suite_col")}: ${entry.suite.passed} pass / ${entry.suite.failed} fail / ${entry.suite.skipped} skipped`);
-    const status = isFullyPassed(entry)
-        ? pc.green("✔ certified")
-        : pc.yellow("⚠ NOT certified");
-    console.log(`Status: ${status}`);
+    getDefaultChannel().writeLine(`${t("cli.cert_provider_col")}: ${entry.providerUrl}`);
+    getDefaultChannel().writeLine(`${t("cli.cert_version_col")}: ${entry.mmaVersion}  ${t("cli.cert_date_col")}: ${entry.certifiedAt.slice(0, 10)}`);
+    getDefaultChannel().writeLine(`${t("cli.cert_suite_col")}: ${entry.suite.passed} pass / ${entry.suite.failed} fail / ${entry.suite.skipped} skipped`);
+    const status = isFullyPassed(entry) ? pc.green("✔ certified") : pc.yellow("⚠ NOT certified");
+    getDefaultChannel().writeLine(`Status: ${status}`);
     printResults(entry.results);
 }
 export async function certList(projectDir) {
-    const m = readManifest(projectDir);
+    const m = readMergedManifest(projectDir);
     if (m.certifications.length === 0) {
-        console.log(t("cli.cert_empty"));
+        getDefaultChannel().writeLine(t("cli.cert_empty"));
         return;
     }
     for (const e of m.certifications) {
         const mark = isFullyPassed(e) ? pc.green("✔") : pc.red("✘");
-        console.log(`  ${mark} ${e.model}  ${pc.dim(e.providerUrl)}  ${e.mmaVersion}  ${e.certifiedAt.slice(0, 10)}  ${e.suite.passed}/${e.suite.total} pass`);
+        getDefaultChannel().writeLine(`  ${mark} ${e.model}  ${pc.dim(e.providerUrl)}  ${e.mmaVersion}  ${e.certifiedAt.slice(0, 10)}  ${e.suite.passed}/${e.suite.total} pass`);
     }
 }
 export async function uncertify(name, config, projectDir) {
-    const removed = removeCertification(name, config.provider.baseUrl, projectDir);
-    if (removed)
-        console.log(t("cli.cert_uncertified", { model: name }));
+    const removed = removeCertification(name, config.provider.baseUrl, {
+        projectDir,
+    });
+    if (removed.global || removed.project)
+        getDefaultChannel().writeLine(t("cli.cert_uncertified", { model: name }));
     else
-        console.log(t("cli.cert_not_found", { model: name }));
+        getDefaultChannel().writeLine(t("cli.cert_not_found", { model: name }));
 }
 function summarize(results) {
     return {
@@ -164,6 +195,18 @@ function summarize(results) {
         total: results.length,
     };
 }
+/**
+ * Merge a partial run's results with a previous certification: fresh results
+ * replace old ones by scenario id; results for scenarios that were not re-run
+ * are preserved verbatim.
+ */
+export function mergePartialResults(fresh, previous, rerunIds) {
+    const preserved = previous.filter((r) => !rerunIds.has(r.id));
+    if (preserved.length > 0) {
+        getDefaultChannel().writeLine(pc.dim(t("cli.cert_partial_merge", { kept: String(preserved.length) })));
+    }
+    return [...fresh, ...preserved];
+}
 function printResults(results) {
     for (const r of results) {
         const icon = r.status === "pass"
@@ -174,11 +217,11 @@ function printResults(results) {
                     ? pc.dim("–")
                     : pc.yellow("!");
         const detail = r.status === "skipped" ? pc.dim(r.title) : `${r.passed}/${r.of}`;
-        console.log(`  ${icon} ${r.id}  ${detail}`);
+        getDefaultChannel().writeLine(`  ${icon} ${r.id}  ${detail}`);
         if (r.error)
-            console.log(`    ${pc.dim(r.error)}`);
+            getDefaultChannel().writeLine(`    ${pc.dim(r.error)}`);
         if (r.diagnostics)
-            console.log(r.diagnostics);
+            getDefaultChannel().writeLine(r.diagnostics);
     }
 }
 function writeReport(entry, projectDir) {
@@ -205,9 +248,9 @@ function writeReport(entry, projectDir) {
     };
     try {
         writeFileSync(reportPath, JSON.stringify(report, null, 2), "utf-8");
-        console.log(pc.dim(`\nReport: ${reportPath}`));
+        getDefaultChannel().writeLine(pc.dim(`\nReport: ${reportPath}`));
     }
     catch (e) {
-        console.error(pc.yellow(`  Failed to write report: ${e.message}`));
+        getDefaultChannel().writeLine(pc.yellow(`  Failed to write report: ${e.message}`), "stderr");
     }
 }

package/dist/modules/certification/loader.js

@@ -2,7 +2,7 @@ import { existsSync, readdirSync, readFileSync } from "fs";
 import { join } from "path";
 import { parse as parseYaml } from "yaml";
 import { BUILTIN_SCENARIOS } from "./scenarios";
-const TAGS = ["core", "security", "image", "network", "browser", "moe"];
+const TAGS = ["core", "security", "image", "network", "browser", "moe", "shell", "research"];
 const CHECK_TYPES = [
     "fileExists",
     "fileNotExists",
@@ -42,6 +42,9 @@ export function validateScenario(s) {
     if (s.reps !== undefined && (!Number.isInteger(s.reps) || s.reps < 1)) {
         errors.push(`[${s.id}] reps must be a positive integer`);
     }
+    if (s.timeoutMs !== undefined && (!Number.isInteger(s.timeoutMs) || s.timeoutMs < 1000)) {
+        errors.push(`[${s.id}] timeoutMs must be an integer >= 1000`);
+    }
     if (s.passThreshold !== undefined &&
         (!Number.isInteger(s.passThreshold) || s.passThreshold < 1)) {
         errors.push(`[${s.id}] passThreshold must be a positive integer`);
@@ -92,6 +95,7 @@ function normalizeScenario(data, file) {
         prompt: String(d.prompt ?? ""),
         reps: typeof d.reps === "number" ? d.reps : undefined,
         passThreshold: typeof d.passThreshold === "number" ? d.passThreshold : undefined,
+        timeoutMs: typeof d.timeoutMs === "number" ? d.timeoutMs : undefined,
         fixtures: Array.isArray(d.fixtures) ? d.fixtures : undefined,
         checks: Array.isArray(d.checks) ? d.checks : [],
         skipReason: typeof d.skipReason === "string" ? d.skipReason : undefined,
@@ -104,3 +108,13 @@ export function filterByTags(scenarios, tags) {
     }
     return scenarios.filter((s) => s.tags.some((t) => tags.includes(t)));
 }
+/** Keep only scenarios whose id is in the list (exact, case-insensitive match). */
+export function filterByScenarios(scenarios, ids) {
+    const wanted = new Set(ids.map((id) => id.toLowerCase()));
+    return scenarios.filter((s) => wanted.has(s.id.toLowerCase()));
+}
+/** Return ids from the request that do not exist among loaded scenarios. */
+export function unknownScenarioIds(scenarios, ids) {
+    const known = new Set(scenarios.map((s) => s.id.toLowerCase()));
+    return ids.filter((id) => !known.has(id.toLowerCase()));
+}

package/dist/modules/certification/manifest.js

@@ -1,8 +1,17 @@
 import { existsSync, readFileSync, mkdirSync, writeFileSync } from "fs";
-import { join } from "path";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { homedir } from "os";
 export function manifestPath(projectDir) {
     return join(projectDir, "certification", "certifications.json");
 }
+/** Directory of the global (per-user) manifest. Overridable for tests. */
+export function globalManifestDir(override) {
+    return override || process.env.MMA_CERT_HOME || join(homedir(), ".mma");
+}
+export function globalManifestPath(override) {
+    return join(globalManifestDir(override), "certifications.json");
+}
 export function readManifest(projectDir) {
     const path = manifestPath(projectDir);
     try {
@@ -21,25 +30,71 @@ export function saveManifest(m, projectDir) {
     mkdirSync(join(projectDir, "certification"), { recursive: true });
     writeFileSync(path, JSON.stringify(m, null, 2), "utf-8");
 }
-export function upsertCertification(entry, projectDir) {
-    const m = readManifest(projectDir);
-    const idx = m.certifications.findIndex((e) => e.model === entry.model && e.providerUrl === entry.providerUrl);
+export function readGlobalManifest(override) {
+    const path = globalManifestPath(override);
+    try {
+        if (existsSync(path)) {
+            const raw = JSON.parse(readFileSync(path, "utf-8"));
+            return { version: 1, certifications: raw.certifications ?? [] };
+        }
+    }
+    catch {
+        /* corrupted global manifest → start fresh */
+    }
+    return { version: 1, certifications: [] };
+}
+export function saveGlobalManifest(m, override) {
+    const dir = globalManifestDir(override);
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(globalManifestPath(override), JSON.stringify(m, null, 2), "utf-8");
+}
+const certKey = (e) => `${e.model}::${e.providerUrl}`;
+/**
+ * Global + project manifests merged by (model, providerUrl).
+ * Project entries win over global ones on the same key.
+ */
+export function readMergedManifest(projectDir, override) {
+    const merged = new Map();
+    for (const e of readGlobalManifest(override).certifications)
+        merged.set(certKey(e), e);
+    for (const e of readManifest(projectDir).certifications)
+        merged.set(certKey(e), e);
+    return { version: 1, certifications: [...merged.values()] };
+}
+export function upsertCertification(entry, override) {
+    const m = readGlobalManifest(override);
+    const idx = m.certifications.findIndex((e) => certKey(e) === certKey(entry));
     if (idx >= 0)
         m.certifications[idx] = entry;
     else
         m.certifications.push(entry);
-    saveManifest(m, projectDir);
+    saveGlobalManifest(m, override);
     return m;
 }
-export function removeCertification(model, providerUrl, projectDir) {
-    const m = readManifest(projectDir);
-    const before = m.certifications.length;
-    m.certifications = m.certifications.filter((e) => !(e.model === model && e.providerUrl === providerUrl));
-    if (m.certifications.length !== before) {
-        saveManifest(m, projectDir);
-        return true;
+export function removeCertification(model, providerUrl, opts) {
+    const key = `${model}::${providerUrl}`;
+    const g = readGlobalManifest(opts?.globalDir);
+    const beforeG = g.certifications.length;
+    g.certifications = g.certifications.filter((e) => certKey(e) !== key);
+    const removedGlobal = g.certifications.length !== beforeG;
+    if (removedGlobal)
+        saveGlobalManifest(g, opts?.globalDir);
+    // Legacy per-project manifests may still hold the entry — clean those too.
+    let removedProject = false;
+    try {
+        const projectDir = opts?.projectDir ?? process.cwd();
+        const p = readManifest(projectDir);
+        const beforeP = p.certifications.length;
+        p.certifications = p.certifications.filter((e) => certKey(e) !== key);
+        if (p.certifications.length !== beforeP) {
+            saveManifest(p, projectDir);
+            removedProject = true;
+        }
+    }
+    catch {
+        /* no project manifest — fine */
     }
-    return false;
+    return { global: removedGlobal, project: removedProject };
 }
 export function isStale(entry, currentVersion) {
     return entry.mmaVersion !== currentVersion;
@@ -47,8 +102,8 @@ export function isStale(entry, currentVersion) {
 export function isFullyPassed(entry) {
     return entry.suite.failed === 0 && entry.suite.passed > 0;
 }
-export function getCertMark(model, providerUrl, currentVersion, projectDir) {
-    const m = readManifest(projectDir);
+export function getCertMark(model, providerUrl, currentVersion, projectDir, globalOverride) {
+    const m = readMergedManifest(projectDir, globalOverride);
     const entry = m.certifications.find((e) => e.model === model && e.providerUrl === providerUrl);
     if (!entry)
         return "none";
@@ -56,3 +111,59 @@ export function getCertMark(model, providerUrl, currentVersion, projectDir) {
         return "stale";
     return isFullyPassed(entry) ? "certified" : "none";
 }
+/** Snapshot file marking which bundled manifest was last synced to the global one. */
+function syncSnapshotPath(override) {
+    return join(globalManifestDir(override), "certifications.synced.json");
+}
+/**
+ * Locate the certifications.json bundled with the installed MMA package.
+ * - dist/main.js layout: <dist>/certification/certifications.json (copied by copy-assets)
+ * - source layout:       <repo-root>/certification/certifications.json
+ */
+export function bundledManifestPath() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        join(here, "certification", "certifications.json"),
+        join(here, "..", "certification", "certifications.json"),
+        join(here, "..", "..", "..", "certification", "certifications.json"),
+    ];
+    for (const p of candidates) {
+        if (existsSync(p))
+            return p;
+    }
+    return null;
+}
+/**
+ * Sync the bundled (shipped-with-package) manifest into the global
+ * ~/.mma/certifications.json. Runs once per process start:
+ * the bundled file overwrites its own entries on every package update;
+ * user-local certifications for OTHER keys are preserved. A snapshot of the
+ * raw bundled content marks what was already synced, so nothing is rewritten
+ * between updates.
+ */
+export function syncGlobalManifest(override, bundledPathOverride) {
+    try {
+        const bundledPath = bundledPathOverride ?? bundledManifestPath();
+        if (!bundledPath || !existsSync(bundledPath))
+            return { synced: false, reason: "no-bundled" };
+        const raw = readFileSync(bundledPath, "utf-8");
+        const snapshotPath = syncSnapshotPath(override);
+        if (existsSync(snapshotPath) && readFileSync(snapshotPath, "utf-8") === raw) {
+            return { synced: false, reason: "unchanged" };
+        }
+        const bundled = JSON.parse(raw);
+        const current = readGlobalManifest(override);
+        const merged = new Map();
+        for (const e of current.certifications)
+            merged.set(certKey(e), e);
+        for (const e of bundled.certifications ?? [])
+            merged.set(certKey(e), e);
+        saveGlobalManifest({ version: 1, certifications: [...merged.values()] }, override);
+        mkdirSync(globalManifestDir(override), { recursive: true });
+        writeFileSync(snapshotPath, raw, "utf-8");
+        return { synced: true, reason: "synced" };
+    }
+    catch {
+        return { synced: false, reason: "error" };
+    }
+}

package/dist/modules/certification/runner.js

@@ -1,8 +1,9 @@
 import { spawn } from "child_process";
 import { existsSync, mkdirSync, rmSync, cpSync, writeFileSync, readdirSync, readFileSync } from "fs";
-import { platform } from "os";
 import { join, resolve, dirname, relative } from "path";
 import { checkSandbox } from "./fact-checker";
+import { killTree } from "../processes/kill-tree";
+import { toForwardSlash } from "../../tools/path-utils";
 export async function runScenario(scenario, opts) {
     if (scenario.mode === "skip") {
         return {
@@ -16,7 +17,7 @@ export async function runScenario(scenario, opts) {
     const reps = scenario.reps ?? opts.defaultReps;
     const threshold = Math.min(scenario.passThreshold ?? opts.defaultThreshold, reps);
     const runner = opts.runner ?? defaultRunner;
-    const timeoutMs = opts.timeoutMs ?? 300_000;
+    const timeoutMs = scenario.timeoutMs ?? opts.timeoutMs ?? 300_000;
     const entryPoint = resolveMmaEntry(opts.mmaRoot);
     let passed = 0;
     let firstError;
@@ -144,7 +145,7 @@ function listFiles(dir, root) {
             if (entry.name === ".mma")
                 continue;
             const abs = join(dir, entry.name);
-            const rel = relative(root, abs).replace(/\\/g, "/");
+            const rel = toForwardSlash(relative(root, abs));
             if (entry.isDirectory()) {
                 result.push(...listFiles(abs, root));
             }
@@ -201,29 +202,6 @@ export const defaultRunner = (env, cwd, args, timeoutMs) => new Promise((resolve
         resolvePromise({ code: null, stdout, stderr, timedOut });
     });
 });
-function killTree(child) {
-    const pid = child.pid;
-    if (!pid)
-        return;
-    if (platform() === "win32") {
-        spawn("taskkill", ["/pid", String(pid), "/T", "/F"], {
-            windowsHide: true,
-            stdio: "ignore",
-        });
-        return;
-    }
-    try {
-        process.kill(-pid, "SIGTERM");
-    }
-    catch {
-        try {
-            child.kill("SIGKILL");
-        }
-        catch {
-            /* already dead */
-        }
-    }
-}
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function deepMergeAny(target, source) {
     if (!source || typeof source !== "object")