mu-agent 0.1.14 → 0.2.1

package/judge/manifest.json

@@ -1226,19 +1226,19 @@
 			"group": "turn",
 			"feature": "ttsr",
 			"title": {
-				"zh": "写偏即停（实验）",
-				"en": "Mid-stream correction (experimental)",
-				"zh-TW": "寫偏即停（實驗）",
-				"ja-JP": "出力中の軌道修正（実験的）",
-				"ko-KR": "출력 중 교정(실험)",
-				"de-DE": "Korrektur während der Ausgabe (Experiment)",
-				"fr-FR": "Correction en cours d’écriture (expérimental)",
-				"es-ES": "Corrección sobre la marcha (experimental)",
-				"pt-BR": "Correção durante a escrita (experimental)",
-				"ru-RU": "Исправление на лету (эксперимент)",
-				"uk-UA": "Виправлення на льоту (експеримент)",
-				"tr-TR": "Akış içinde düzeltme (deneysel)",
-				"fa-IR": "اصلاح در میانهٔ خروجی (آزمایشی)"
+				"zh": "写偏即停",
+				"en": "Mid-stream correction",
+				"zh-TW": "寫偏即停",
+				"ja-JP": "出力中の軌道修正",
+				"ko-KR": "출력 중 교정",
+				"de-DE": "Korrektur während der Ausgabe",
+				"fr-FR": "Correction en cours d’écriture",
+				"es-ES": "Corrección sobre la marcha",
+				"pt-BR": "Correção durante a escrita",
+				"ru-RU": "Исправление на лету",
+				"uk-UA": "Виправлення на льоту",
+				"tr-TR": "Akış içinde düzeltme",
+				"fa-IR": "اصلاح در میانهٔ خروجی"
 			},
 			"summary": {
 				"zh": "模型边输出，判定器边每隔几百字对照一次你的硬约束和下面配置的规则；确信写偏了就立刻掐断输出，告诉模型是哪一条，让它从断点接着写。只有开启了「写偏即停」功能才会运行。",
@@ -5619,19 +5619,19 @@
 		{
 			"name": "ttsr",
 			"title": {
-				"zh": "写偏即停（实验）",
-				"en": "Mid-stream correction (experimental)",
-				"zh-TW": "寫偏即停（實驗）",
-				"ja-JP": "出力中の軌道修正（実験的）",
-				"ko-KR": "출력 중 교정(실험)",
-				"de-DE": "Korrektur während der Ausgabe (Experiment)",
-				"fr-FR": "Correction en cours d’écriture (expérimental)",
-				"es-ES": "Corrección sobre la marcha (experimental)",
-				"pt-BR": "Correção durante a escrita (experimental)",
-				"ru-RU": "Исправление на лету (эксперимент)",
-				"uk-UA": "Виправлення на льоту (експеримент)",
-				"tr-TR": "Akış içinde düzeltme (deneysel)",
-				"fa-IR": "اصلاح در میانهٔ خروجی (آزمایشی)"
+				"zh": "写偏即停",
+				"en": "Mid-stream correction",
+				"zh-TW": "寫偏即停",
+				"ja-JP": "出力中の軌道修正",
+				"ko-KR": "출력 중 교정",
+				"de-DE": "Korrektur während der Ausgabe",
+				"fr-FR": "Correction en cours d’écriture",
+				"es-ES": "Corrección sobre la marcha",
+				"pt-BR": "Correção durante a escrita",
+				"ru-RU": "Исправление на лету",
+				"uk-UA": "Виправлення на льоту",
+				"tr-TR": "Akış içinde düzeltme",
+				"fa-IR": "اصلاح در میانهٔ خروجی"
 			},
 			"summary": {
 				"zh": "语义版 TTSR：不用正则，而由判定器发现模型写偏，中断输出、摆出规则、从原处继续。默认关闭；开启后每隔一段输出就会多一次判定调用。",

package/judge/mu/index.js

@@ -27471,6 +27471,20 @@ var BUILT_IN_JUDGES = {
     type: "local",
     profile: { capabilities: { relate: false, rate: false, meta: false, screen: false, intent: false } }
   },
+  // mude, the decision model trained for mu's judgment layer, on this Mac (`mu judge mude install`, Apple silicon):
+  // the System One server that comes in its package, on 127.0.0.1:8790, with the key the install wrote to the .env.
+  // Trusted on every capability: on mu's own dev scenarios (an internal benchmark, not public yet) it did as well as Jev
+  // or better on relate, rate, meta, screening tool output (`tool.admission`) and promises (`turn.continue`), and on
+  // classify but for one check: a tool's description screened for injected instructions (`tool.description`), where
+  // Jev did better. Nothing measured it on injections in fetched content (`tool.injection`). So with a judge behind it,
+  // `mu judge mude` routes those two checks to that judge (`routes` in mu.json). It answers in about 0.1 s here.
+  mude: {
+    type: "typesafe",
+    baseUrl: "http://127.0.0.1:8790/v1/systemone",
+    model: "mude",
+    apiKeyEnv: "MU_JUDGE_MUDE_KEY",
+    timeoutMs: 4e3
+  },
   mock: { type: "mock" }
 };
 var DEFAULT_CONFIG = {
@@ -29713,7 +29727,8 @@ var DEFAULT_TIMEOUT_MS2 = {
 var KEYS_FOR_ELSEWHERE = /* @__PURE__ */ new Set([
   "MU_JUDGE_OPENROUTER_API_KEY",
   "MU_JUDGE_CUSTOM_API_KEY",
-  "MU_JUDGE_CLM_API_KEY"
+  "MU_JUDGE_CLM_API_KEY",
+  "MU_JUDGE_MUDE_KEY"
 ]);
 function resolveJudgeConfig(name, config) {
   if (name.startsWith("llm:")) return { type: "llm", model: name.slice("llm:".length) };

package/kyrn/bin/kyrn-doctor

@@ -196,7 +196,10 @@ const CLASSIFIER_KEYS = {
 const fromFile = existsSync(envFile) ? parseEnvFile(readFileSync(envFile, "utf8")).entries : [];
 const has = (name) => Boolean(process.env[name]) || fromFile.some(([key, value]) => key === name && value !== "");
 const where = `to ${tilde(envFile)} or to your environment`;
-const jevTier = tiers.find((tier) => ["jev", "typesafe", "gateway"].includes((config?.judges?.[tier] ?? JEV_ROUTES[tier])?.type));
+// mude speaks System One too, but on this machine and with a key of its own (its rows are below).
+const jevTier = tiers.find(
+	(tier) => tier !== "mude" && ["jev", "typesafe", "gateway"].includes((config?.judges?.[tier] ?? JEV_ROUTES[tier])?.type),
+);
 if (jevTier && asksJudge) {
 	const judge = config?.judges?.[jevTier] ?? JEV_ROUTES[jevTier];
 	if (judge.type === "jev") {
@@ -237,6 +240,29 @@ if (jevTier && asksJudge) {
 	}
 }
 
+// mude on this Mac (mu judge mude): its server's /health, and the key mu sends it.
+if (asksJudge && tiers.includes("mude")) {
+	const fallback = tiers.filter((tier) => tier !== "mude");
+	const behind = fallback.length > 0 ? `until it answers, ${fallback.join(" > ")} decide${fallback.length === 1 ? "s" : ""} (what they read leaves this machine)` : "until it answers, decisions take their fallbacks";
+	if (process.platform !== "darwin") {
+		row("--", "mude 1.0", `not available on ${platformName({ platform: process.platform, wsl })}: mude 1.0 runs on a Mac with Apple silicon`);
+	} else {
+		const entry = config?.judges?.mude;
+		const address = (typeof entry?.baseUrl === "string" ? entry.baseUrl : "http://127.0.0.1:8790/v1/systemone").replace(/\/v1\/systemone\/?$/, "");
+		const startedAt = performance.now();
+		try {
+			const response = await fetch(`${address}/health`, { signal: AbortSignal.timeout(2000) });
+			const health = await response.json();
+			const ms = Math.round(performance.now() - startedAt);
+			row(health.status === "ready" ? "ok" : "--", "mude 1.0", `${address} · ${health.status} · ${ms} ms`);
+		} catch {
+			row("fix", "mude 1.0", `${address} isn't answering: run mu judge mude start   (first time: mu judge mude install)`);
+			row("--", "", behind);
+		}
+		if (!has("MU_JUDGE_MUDE_KEY")) row("fix", "mude 1.0 key", "MU_JUDGE_MUDE_KEY is not set, so mu can't ask mude 1.0: run mu judge mude enable");
+	}
+}
+
 // Classifier models of pi's catalog (Jev on OpenCode Zen or Cloudflare, Clef, …), for the tiers and routes that use them.
 const classifierOf = (tier) =>
 	tier.startsWith("classifier:")

package/kyrn/bin/mu.mjs

@@ -102,6 +102,8 @@ export function usage(platform) {
 		"  mu -c | -r               continue the last session | pick a session to resume",
 		"  mu setup                 connect a model (paste an API key or pick a service) and choose a judge",
 		"                           (see mu setup --help for scripting, reading a key from stdin and the supported services)",
+		"  mu judge mude install    run mude 1.0, mu's decision model optimized for coding, on this Mac as the judge (Apple silicon, 1.8 GB)",
+		"                           enable | disable | start | stop | status | uninstall (mu judge mude help)",
 		"  mu judge <cmd>           manage the local judge, Laya (macOS on Apple silicon): setup | start | stop | status | run",
 		"  mu ledger [n] [--json]   print the judge's verdicts from the last n sessions",
 		"  mu import <file>...      import Claude Code, Codex and ZCode conversations; --list shows them (mu import --help)",
@@ -321,8 +323,8 @@ export function layoutOf({ root, platform, exists }) {
 }
 
 /**
- * The files the npm package runs: pi, the judgment layer, the sign-in of `mu auth`, the importer of `mu import` and the
- * wizard of `mu setup`.
+ * The files the npm package runs: pi, the judgment layer, the sign-in of `mu auth`, the importer of `mu import`, the
+ * wizard of `mu setup` and `mu judge mude`.
  */
 export function packageEntries({ root, platform }) {
 	const path = pathFor(platform);
@@ -332,6 +334,7 @@ export function packageEntries({ root, platform }) {
 		auth: path.join(root, "judge", "dist", "auth.js"),
 		import: path.join(root, "judge", "dist", "import.js"),
 		setup: path.join(root, "judge", "dist", "setup.js"),
+		mude: path.join(root, "judge", "dist", "mude.js"),
 	};
 }
 
@@ -440,6 +443,28 @@ export function wantsLaya({ env, agentDir, platform, readFile }) {
 }
 
 /** The Core ML sidecar exists for macOS only. Anything else needs a server of its own behind MU_LOCAL_JUDGE_URL. */
+/**
+ * Whether the configuration asks for mude (mu judge mude): MU_JUDGE naming it, else `tiers` or a route in mu.json (or
+ * kyrn.json when there is no mu.json). Its server is then started when a session starts, as Laya's is.
+ */
+export function wantsMude({ env, agentDir, platform, readFile }) {
+	const judges = muEnv("JUDGE", env);
+	if (judges) return judges.split(",").some((judge) => judge.trim() === "mude");
+	const path = pathFor(platform);
+	for (const name of ["mu.json", "kyrn.json"]) {
+		let config;
+		try {
+			config = JSON.parse(readFile(path.join(agentDir, name)));
+		} catch (error) {
+			if (error instanceof SyntaxError) return false;
+			continue;
+		}
+		const named = (tiers) => Array.isArray(tiers) && tiers.includes("mude");
+		return named(config?.tiers) || Object.values(config?.routes ?? {}).some(named);
+	}
+	return false;
+}
+
 export function localJudgeSupport({ platform, env, wsl = false }) {
 	if (platform === "darwin") return { runs: true };
 	const url = muEnv("LOCAL_JUDGE_URL", env);
@@ -580,6 +605,14 @@ export function planLaunch({
 		}
 	}
 
+	// mude's server, when the configuration asks for it: started without waiting, so a session never waits for the
+	// model to load (what mude cannot answer yet goes to the judges behind it). Only a Mac runs it.
+	let startMude;
+	if (execPath && platform === "darwin" && wantsMude({ env: childEnv, agentDir, platform, readFile: fs.readFile })) {
+		const mude = planMude({ platform, env: childEnv, argv: ["start", "--no-wait"], root, home, execPath, fs, stripsTypes });
+		if (!mude.error) startMude = { command: mude.command, args: mude.args, env: mude.env };
+	}
+
 	return {
 		command: execPath,
 		args: [...entry, ...judgeArgs({ argv, layout, root, platform, agentDir, readFile: fs.readFile }), ...argv],
@@ -590,6 +623,7 @@ export function planLaunch({
 		appDir,
 		agentDir,
 		startJudge,
+		startMude,
 		notes,
 		preface: argv[0] === "-h" || argv[0] === "--help" ? `${usage(platform)}\n\npi's help (mu passes all of this through):\n` : undefined,
 	};
@@ -606,10 +640,17 @@ export function planLaunch({
  *
  * A checkout runs there as it runs on the command line (sourceRuntime). Returns { error } when pi cannot run.
  */
-export function planHost({ platform, env, argv, root, home, fs, wsl = false, stripsTypes = true }) {
+export function planHost({ platform, env, argv, root, home, fs, wsl = false, stripsTypes = true, nodePath, nodeEnv = {} }) {
 	const path = pathFor(platform);
 	const launch = planLaunch({ platform, env, argv, root, home, execPath: "", fs, wsl, stripsTypes });
 	if (launch.error !== undefined) return { error: launch.error };
+	// mude's server is started by a Node of the host's: `nodePath` with `nodeEnv` (Electron's own binary with
+	// ELECTRON_RUN_AS_NODE=1 in the desktop app). Without one, the host leaves it to the app.
+	let startMude;
+	if (nodePath && platform === "darwin" && wantsMude({ env: launch.env, agentDir: launch.agentDir, platform, readFile: fs.readFile })) {
+		const mude = planMude({ platform, env: { ...launch.env, ...nodeEnv }, argv: ["start", "--no-wait"], root, home, execPath: nodePath, fs, stripsTypes });
+		if (!mude.error) startMude = { command: mude.command, args: mude.args, env: mude.env };
+	}
 	const common = {
 		env: launch.env,
 		layout: launch.layout,
@@ -617,6 +658,7 @@ export function planHost({ platform, env, argv, root, home, fs, wsl = false, str
 		appDir: launch.appDir,
 		agentDir: launch.agentDir,
 		startJudge: launch.startJudge,
+		startMude,
 		notes: launch.notes,
 	};
 	if (launch.layout === "package") {
@@ -661,6 +703,7 @@ function prepareFiles({ plan, platform, root, err }) {
  */
 export function prepareLaunch({ plan, platform, root, bin, err }) {
 	prepareFiles({ plan, platform, root, err });
+	startMudeServer(plan);
 	if (plan.startJudge) {
 		const started = spawnSync(pathFor(platform).join(bin, "kyrn-judge-local"), ["start"], {
 			stdio: "ignore",
@@ -670,12 +713,32 @@ export function prepareLaunch({ plan, platform, root, bin, err }) {
 	}
 }
 
+/**
+ * mude's server, started in the background (`mu judge mude start --no-wait`): nothing waits for it, and it outlives this
+ * process, shared by every mu session like Laya. When mude is not installed it does nothing (the doctor says so).
+ */
+function startMudeServer(plan) {
+	if (!plan.startMude) return;
+	try {
+		const child = spawn(plan.startMude.command, plan.startMude.args, {
+			env: plan.startMude.env,
+			stdio: "ignore",
+			detached: true,
+		});
+		child.once("error", () => {});
+		child.unref();
+	} catch {
+		// mu works without it: the judges behind mude answer.
+	}
+}
+
 /**
  * prepareLaunch for a program that must not stop while the local judge starts, such as the desktop app's main process:
  * the same steps and notes, with the local judge started through a child process it waits for without blocking.
  */
 export async function prepareLaunchAsync({ plan, platform, root, bin, err }) {
 	prepareFiles({ plan, platform, root, err });
+	startMudeServer(plan);
 	if (!plan.startJudge) return;
 	const status = await new Promise((resolve) => {
 		const child = spawn(pathFor(platform).join(bin, "kyrn-judge-local"), ["start"], {
@@ -793,6 +856,42 @@ export function planImport({ platform, env, argv, root, home, execPath, fs, stri
 	return { command: execPath, args: [...entry, ...argv], env: childEnv, agentDir };
 }
 
+// ---------------------------------------------------------------------------------------------------------
+// mu judge mude
+// ---------------------------------------------------------------------------------------------------------
+
+/**
+ * `mu judge mude <command>` (packages/kyrn-judge/src/mude): mude on this Mac, from the checkout's TypeScript or the
+ * package's built judge/dist/mude.js. It is told where mu keeps things: the agent folder (mu.json), mu's home (the
+ * model and its environment go under local-judge/mude), the .env (its key) and the lock of its Python packages.
+ */
+export function planMude({ platform, env, argv, root, home, execPath, fs, stripsTypes = true }) {
+	const path = pathFor(platform);
+	const layout = layoutOf({ root, platform, exists: fs.exists });
+	let entry;
+	if (layout === "package") {
+		const built = packageEntries({ root, platform }).mude;
+		if (!fs.exists(built)) {
+			return { error: `This mu-agent package has no mu judge mude (${built} is missing). Update it: npm i -g mu-agent` };
+		}
+		entry = [built];
+	} else {
+		const source = path.join(root, "packages", "kyrn-judge", "src", "mude", "cli.ts");
+		if (!fs.exists(source)) return { error: `mu judge mude is missing from this checkout (${source})` };
+		if (!stripsTypes) return { error: NO_TYPE_STRIPPING };
+		entry = ["--disable-warning=ExperimentalWarning", source];
+	}
+	const muDir = muHome({ home, platform, isDir: fs.isDir });
+	const agentDir = agentDirFor({ env, muDir, platform });
+	const childEnv = {};
+	for (const [key, value] of Object.entries(env)) if (typeof value === "string") childEnv[key] = value;
+	childEnv.MU_AGENT_DIR = agentDir;
+	childEnv.MU_MUDE_HOME = muDir;
+	childEnv.MU_MUDE_ENV_FILE = envFilePath({ layout, root, muDir, platform });
+	childEnv.MU_MUDE_LOCK = path.join(root, "kyrn", "local-judge", "mude-requirements.lock.txt");
+	return { command: execPath, args: [...entry, ...argv], env: childEnv, agentDir };
+}
+
 // ---------------------------------------------------------------------------------------------------------
 // mu setup
 // ---------------------------------------------------------------------------------------------------------
@@ -913,6 +1012,12 @@ export function planSetup({ platform, env, argv, root, home, execPath, fs, strip
 	childEnv.MU_SETUP_HOME = muDir;
 	// The .env a session gets: the wizard writes the Jev key there, and reads a proxy from it.
 	childEnv.MU_SETUP_ENV_FILE = envFilePath({ layout, root, muDir, platform });
+	// mude 1.0, which the judge step installs on a Mac that can run it: where `mu judge mude` keeps it (planMude).
+	if (platform === "darwin") {
+		childEnv.MU_MUDE_HOME = muDir;
+		childEnv.MU_MUDE_ENV_FILE = childEnv.MU_SETUP_ENV_FILE;
+		childEnv.MU_MUDE_LOCK = path.join(root, "kyrn", "local-judge", "mude-requirements.lock.txt");
+	}
 	return { command: execPath, args: [...entry, ...args], env: childEnv, strategy: "spawn", agentDir, keyGiven: key !== undefined };
 }
 
@@ -1504,6 +1609,23 @@ export async function main(argv = process.argv.slice(2)) {
 			},
 		});
 	}
+	if (command === "judge" && rest[0] === "mude") {
+		const plan = planMude({
+			platform,
+			env,
+			argv: rest.slice(1),
+			root,
+			home,
+			execPath: process.execPath,
+			stripsTypes: Boolean(process.features.typescript),
+			fs: { exists: existsSync, isDir, readFile: readText },
+		});
+		if (plan.error) {
+			err(plan.error);
+			return 1;
+		}
+		return handOver({ command: plan.command, args: plan.args, env: plan.env, strategy: "spawn" });
+	}
 	if (command === "judge") {
 		const plan = planJudge({ platform, env, argv: rest, bin, wsl });
 		if (plan.kind === "script") return handOver({ command: plan.command, args: plan.args, env, strategy });