clauderipple 0.6.0 → 0.8.0

package/dist/router/src/agents.js

@@ -14,6 +14,8 @@ import os from "node:os";
 import path from "node:path";
 import { homeDir } from "./config.js";
 import { declaredBy } from "./routing.js";
+import { adminPort } from "./admin.js";
+import { shortName } from "../../cli/src/hooks/agent-title.js";
 /** Where Claude Code's Agent tool reads its worker definitions. */
 export function defaultAgentDir() {
     return path.join(os.homedir(), ".claude", "agents");
@@ -34,6 +36,27 @@ const BODY = [
     "**작업 디렉터리(cwd)에 어떤 파일도 만들지 않는다.** 조사·감사처럼 \"읽기만\" 하는 일이어도 마찬가지다.",
     "임시 파일이 필요하면 `/tmp` 아래에만 만들고, 끝나면 지운다. 사본을 작업 폴더에 떨구지 마라.",
 ].join("\n");
+/**
+ * Added to the body when a ChatGPT provider is configured: how a worker makes an image. A worker has
+ * no image tool, and `clauderipple` is not on PATH for everyone (a checkout runs from source), so
+ * the instruction is the admin endpoint itself, which curl reaches on every platform.
+ */
+function imageLine(port) {
+    return [
+        "이미지가 필요하면 ChatGPT 구독으로 만든다(한 장 30초~수 분):",
+        `\`curl -sS --fail-with-body -o <절대경로>.png -H 'content-type: application/json' -d '{"prompt":"…"}' http://127.0.0.1:${port}/api/image\``,
+        "선택 키: aspect(square·landscape·portrait), background(transparent), format(png·jpeg·webp), images(참고 이미지 data: URL 목록). 해상도·품질은 지정할 수 없다. 실패하면 그 파일에 오류 JSON이 담긴다. 만든 뒤 Read로 확인한다.",
+    ].join("\n");
+}
+/**
+ * The tools a generated worker is given when `cli.limitWorkerTools` is on. Without a `tools:` line a
+ * subagent inherits every tool of the session — each MCP server, plugin agent and deferred-tool name —
+ * and a general worker's first request measured 43,598 tokens (2026-09-20), resent on every turn;
+ * limited, a deepseek worker's first request fell from 32,942 to 8,823 (2026-09-29). A worker reads,
+ * edits, searches, runs commands and uses skills; it does not drive browsers, simulators or mail.
+ * Off by default: a user whose workers do need those tools would otherwise lose them silently.
+ */
+const TOOLS = ["Read", "Write", "Edit", "Glob", "Grep", "Bash", "WebFetch", "WebSearch", "Skill"];
 /**
  * Parsed `*.md` frontmatter per directory, keyed by file mtime so a request never re-reads the whole
  * directory. Only the `---` block's own `key: value` lines are read: no YAML library, because the
@@ -125,19 +148,36 @@ function capsEffortLevels(provider) {
     return provider.caps?.effortLevels;
 }
 /**
- * The `@effort` suffix a generated file's `model:` carries: `@medium` when the provider or the model
- * offers medium reasoning, otherwise none. An empty `model.effortLevels` disables the provider
- * fallback (config.ts), so it is honoured rather than ignored.
+ * The `@effort` suffix a generated file's `model:` carries: `@high` when the provider or the model
+ * offers any reasoning effort, otherwise none. A ladder without `high` is fine — the request is
+ * clamped to the nearest level the model takes (compat.ts). It used to be `@medium`, which a ladder
+ * from the catalogue such as `low`/`high`/`max` does not hold, and the operator wants workers at
+ * high unless a marker says otherwise (2026-10-02). An empty `model.effortLevels` disables the
+ * provider fallback (config.ts), so it is honoured rather than ignored.
  */
 function effortSuffix(provider, modelId) {
     const modelLevels = provider.models?.find((m) => m.id === modelId)?.effortLevels;
     const levels = modelLevels !== undefined ? modelLevels : capsEffortLevels(provider);
-    return levels?.includes("medium") ? "@medium" : "";
+    return levels && levels.length > 0 ? "@high" : "";
+}
+/**
+ * What the parent is asked to start the Agent `description` with. The Desktop task panel names only
+ * Claude models, and rebuilt from the transcript it shows the description as the parent wrote it,
+ * so the agent-title hook's live correction is lost (app web bundle, 2026-09-30); a prefix the
+ * parent writes itself survives. Same form as the hook's: the display name's last word, `·level`.
+ */
+function titlePrefix(title, suffix) {
+    return suffix
+        ? `Start the Agent description with "${title}·<level> · " (the marker's level, else ${suffix.slice(1)}) so the app's task list shows the model.`
+        : `Start the Agent description with "${title} · " so the app's task list shows the model.`;
 }
-function fileContent(name, modelId, provider, suffix) {
+function fileContent(name, modelId, title, provider, suffix, limitTools, imagePort) {
     const description = `${modelId} via ${provider}. Generated by ClaudeRipple from config.json — edits are overwritten; ` +
-        `to customise, copy to another name. Set effort with [[ripple: ${name}@<level>]] on the first line.`;
-    return `---\nname: ${name}\ndescription: ${description}\nmodel: ${modelId}${suffix}\n---\n${BODY}\n`;
+        `to customise, copy to another name. Set effort with [[ripple: ${name}@<level>]] on the first line. ` +
+        titlePrefix(title, suffix);
+    const tools = limitTools ? `tools: ${TOOLS.join(", ")}\n` : "";
+    const body = imagePort === null ? BODY : `${BODY}\n${imageLine(imagePort)}`;
+    return `---\nname: ${name}\ndescription: ${description}\nmodel: ${modelId}${suffix}\n${tools}---\n${body}\n`;
 }
 function readManifest(file) {
     try {
@@ -196,9 +236,10 @@ export function syncAgentFiles(cfg, dir, log, opts = {}) {
                 log?.warn(`agent files: "${model.id}" and "${clash.modelId}" both map to "${name}"; skipping "${model.id}"`);
                 continue;
             }
-            targets.set(name, { modelId: model.id, provider: providerName, suffix: effortSuffix(provider, model.id) });
+            targets.set(name, { modelId: model.id, title: shortName(model.name ?? model.id), provider: providerName, suffix: effortSuffix(provider, model.id) });
         }
     }
+    const imagePort = Object.values(cfg.providers).some((p) => p.type === "chatgpt") ? adminPort(cfg) : null;
     const nextOwned = [];
     for (const [name, t] of targets) {
         if (handNames.has(name)) {
@@ -206,7 +247,7 @@ export function syncAgentFiles(cfg, dir, log, opts = {}) {
             continue;
         }
         const file = path.join(dir, `${name}.md`);
-        const content = fileContent(name, t.modelId, t.provider, t.suffix);
+        const content = fileContent(name, t.modelId, t.title, t.provider, t.suffix, cfg.cli.limitWorkerTools === true, imagePort);
         const existing = scanned.get(`${name}.md`);
         if (existing) {
             let current = null;

package/dist/router/src/catalog.js

@@ -0,0 +1,80 @@
+// What OpenCode itself knows about each model, read from the catalogue its own client is built on.
+//
+// OpenCode's docs publish an endpoint per model and no effort ladder at all, and its `/models`
+// reports ids alone, so `capabilities.ts` established both by sending requests: about ten per
+// model, one after another. With upstream latency swinging from 0.5s to 25s on identical one-token
+// requests (glm-5.3-flash, measured 2026-10-02), three models took 2m33s.
+//
+// models.dev (https://models.dev/api.json, maintained by the team behind OpenCode) states both for
+// every model OpenCode serves: `reasoning_options` lists the effort values, and `provider.npm` names
+// the SDK the OpenCode client speaks to it with. It is also more accurate than asking: a 200 only
+// says a level was not refused, and glm-5.3-flash answered 200 to seven levels where the catalogue
+// lists `low`/`high`/`max` — the rest were accepted and, as far as anything can tell, ignored. And
+// muse-spark-1.3-contributor names `max` in its own error message, refuses it when sent, and the
+// catalogue never lists it.
+//
+// The catalogue is community-maintained and a new model can arrive a day late; a model it does not
+// list is measured exactly as before.
+/** Which models.dev provider describes the endpoint a preset points at. Only presets whose base URL
+ * is the one the catalogue entry names (`api`) are listed, so the catalogue never describes a
+ * different endpoint from the one the request goes to. */
+const CATALOG_PROVIDER = {
+    "opencode-go": "opencode-go", // api https://opencode.ai/zen/go/v1
+    "opencode-zen": "opencode", // api https://opencode.ai/zen/v1
+};
+export const CATALOG_URL = "https://models.dev/api.json";
+const CATALOG_TIMEOUT_MS = 10_000;
+/** The catalogue changes when a model is added, not minute to minute. */
+const CATALOG_TTL_MS = 60 * 60 * 1000;
+/** The SDK packages that map onto a wire this router sends. Any other (`@ai-sdk/google`, …) says
+ * nothing we can use, and leaves the wire to measurement. */
+function wireOf(npm) {
+    if (npm === "@ai-sdk/openai-compatible")
+        return "chat";
+    if (npm === "@ai-sdk/openai")
+        return "responses";
+    if (npm === "@ai-sdk/anthropic")
+        return "anthropic";
+    return undefined;
+}
+/** One model as the catalogue describes it, or nothing when the preset has no catalogue or the model is not in it. */
+export function catalogEntry(catalog, preset, modelId) {
+    const providerId = preset ? CATALOG_PROVIDER[preset] : undefined;
+    if (!providerId || !catalog || typeof catalog !== "object")
+        return undefined;
+    const provider = catalog[providerId];
+    const model = provider?.models?.[modelId];
+    if (!model || typeof model !== "object")
+        return undefined;
+    // A model with no SDK of its own is spoken to with the provider's.
+    const wire = wireOf(model.provider?.npm ?? provider?.npm);
+    let effortLevels;
+    if (Array.isArray(model.reasoning_options)) {
+        const effort = model.reasoning_options.find((option) => option?.type === "effort" && Array.isArray(option.values));
+        effortLevels = effort ? effort.values.filter((value) => typeof value === "string") : [];
+    }
+    else if (model.reasoning === false) {
+        effortLevels = [];
+    }
+    return { ...(wire ? { wire } : {}), ...(effortLevels ? { effortLevels } : {}) };
+}
+let cached;
+/**
+ * The catalogue, fetched at most once an hour. Undefined when it cannot be had: the caller measures
+ * instead, so a catalogue outage costs time and never a wrong answer.
+ */
+export async function loadModelCatalog(fetchImpl = fetch) {
+    if (cached && Date.now() - cached.at < CATALOG_TTL_MS)
+        return cached.catalog;
+    try {
+        const response = await fetchImpl(CATALOG_URL, { signal: AbortSignal.timeout(CATALOG_TIMEOUT_MS) });
+        if (!response.ok)
+            return cached?.catalog;
+        const catalog = await response.json();
+        cached = { at: Date.now(), catalog };
+        return catalog;
+    }
+    catch {
+        return cached?.catalog;
+    }
+}

package/dist/router/src/compat.js

@@ -1,6 +1,7 @@
 // Sanitise Claude Code's Anthropic-only request extensions for providers that expose
 // an Anthropic-shaped Messages endpoint without implementing Anthropic's full feature set.
 // Pure: callers receive a new object and an audit list; the input is never mutated.
+import { droppedServerToolNote } from "./providers/chatgpt/translate.js";
 export const EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max", "ultra"];
 export const STRICT_COMPAT_CAPS = {
     effortLevels: [],
@@ -28,6 +29,10 @@ export function forwardCompatibleHeader(name, caps) {
 /**
  * Return the nearest supported canonical effort level. Unknown requested levels fall back
  * to the provider's lowest listed level, which is safer than forwarding a rejected value.
+ *
+ * Equally near on both sides goes up: `medium` on a `low`/`high`/`max` ladder — the shape most
+ * OpenCode Go models list (models.dev, 2026-10-02) — is `high`. Asking for medium means "more
+ * than low", and rounding it down cost a worker its reasoning for the sake of a tie.
  */
 export function clampEffort(effort, supported) {
     if (supported.includes(effort))
@@ -38,7 +43,11 @@ export function clampEffort(effort, supported) {
         .filter((entry) => entry.index >= 0);
     if (requested < 0 || canonical.length === 0)
         return supported[0] ?? effort;
-    return canonical.reduce((best, candidate) => Math.abs(candidate.index - requested) < Math.abs(best.index - requested) ? candidate : best).value;
+    return canonical.reduce((best, candidate) => {
+        const distance = Math.abs(candidate.index - requested);
+        const bestDistance = Math.abs(best.index - requested);
+        return distance < bestDistance || (distance === bestDistance && candidate.index > best.index) ? candidate : best;
+    }).value;
 }
 function stripCacheControl(value) {
     if (Array.isArray(value)) {
@@ -77,6 +86,15 @@ function stripCacheControl(value) {
 // translated providers drop it for the same reason (`systemText` in providers/chatgpt/translate.ts,
 // measured 2026-09-13), and it means nothing to a provider that is not Anthropic.
 const BILLING_BLOCK = /^x-anthropic-billing-header:/;
+function appendSystemText(system, text) {
+    if (system === undefined || system === null || system === "")
+        return text;
+    if (typeof system === "string")
+        return `${system}\n\n${text}`;
+    if (Array.isArray(system))
+        return [...system, { type: "text", text }];
+    return system;
+}
 function stripBillingHeader(system) {
     if (typeof system === "string") {
         const value = system.replace(/^x-anthropic-billing-header:[^\n]*\n*/, "");
@@ -183,6 +201,14 @@ export function sanitizeForCompatible(json, caps) {
             delete out.tool_choice;
             changes.push("tool_choice");
         }
+        // The instruction text for a dropped tool stays in the prompt unless withdrawn (see the note's
+        // own comment). Appended after the caller's blocks, without cache_control, so the prefix up to
+        // Claude Code's breakpoints is untouched.
+        const note = droppedServerToolNote(droppedNames);
+        if (note) {
+            out.system = appendSystemText(out.system, note);
+            changes.push("server_tool_note");
+        }
     }
     if ("system" in out) {
         const next = stripBillingHeader(out.system);

package/dist/router/src/config.js

@@ -239,6 +239,22 @@ function foldSplitProviders(c) {
 }
 export function validate(c) {
     const errors = [];
+    if (c.autoModeClassifier !== undefined) {
+        const target = c.autoModeClassifier;
+        if (!target || typeof target !== "object")
+            errors.push("autoModeClassifier must be an object");
+        else {
+            const provider = c.providers[target.provider];
+            if (!provider)
+                errors.push("autoModeClassifier: unknown provider");
+            else if (provider.type === "anthropic" && !provider.accountPool)
+                errors.push("autoModeClassifier: provider is ingress-only");
+            if (typeof target.model !== "string" || !target.model.trim())
+                errors.push("autoModeClassifier: missing model");
+            if (target.effort !== undefined && typeof target.effort !== "string")
+                errors.push("autoModeClassifier: effort must be a string");
+        }
+    }
     for (const [alias, r] of Object.entries(c.routes)) {
         if (!c.providers[r.provider])
             errors.push(`route ${alias}: unknown provider "${r.provider}"`);
@@ -360,6 +376,21 @@ export function validate(c) {
                 errors.push(`provider ${name}: caps must contain effortLevels?: string[], reasoning?: "effort"|"none"`);
             }
         }
+        else if (p.type === "google") {
+            if (p.auth !== "api-key" && p.auth !== "antigravity")
+                errors.push(`provider ${name}: auth must be "api-key" or "antigravity"`);
+            // The api-key is required, but a key may also come from the environment. The router, not the
+            // GUI save, is where that is settled — so this only refuses a key of the wrong type.
+            if (p.apiKey !== undefined && typeof p.apiKey !== "string")
+                errors.push(`provider ${name}: apiKey must be a string`);
+            if (p.url !== undefined && !/^https?:\/\//.test(p.url))
+                errors.push(`provider ${name}: url must start with http:// or https://`);
+            if (p.defaultEffort !== undefined && typeof p.defaultEffort !== "string")
+                errors.push(`provider ${name}: defaultEffort must be a string`);
+            if (p.models !== undefined && !validModels(p.models)) {
+                errors.push(`provider ${name}: ${MODELS_SHAPE}`);
+            }
+        }
         else if (p.type === "anthropic") {
             if (p.auth !== "api-key" && p.auth !== "claude-code")
                 errors.push(`provider ${name}: auth must be "api-key" or "claude-code"`);
@@ -381,6 +412,8 @@ export function validate(c) {
         errors.push("listen.port out of range");
     if (c.cli.agentFiles !== undefined && typeof c.cli.agentFiles !== "boolean")
         errors.push("cli.agentFiles must be true or false");
+    if (c.cli.limitWorkerTools !== undefined && typeof c.cli.limitWorkerTools !== "boolean")
+        errors.push("cli.limitWorkerTools must be true or false");
     if (c.listen.openaiPort !== undefined && !(c.listen.openaiPort >= 0 && c.listen.openaiPort < 65536))
         errors.push("listen.openaiPort out of range");
     return errors;

package/dist/router/src/index.js

@@ -6,7 +6,7 @@
 // Exit codes: 0 clean, 2 bad config/certs, 75 upstream unreachable (supervisor should restart).
 import fs from "node:fs";
 import path from "node:path";
-import { codexEnabled, writeCodexCatalog } from "../../cli/src/codex.js";
+import { codexEnabled, followCodexCache, writeCodexCatalog } from "../../cli/src/codex.js";
 import { ingressModels } from "./ingress/models.js";
 import { ConfigStore, configPath, homeDir, terminateHosts } from "./config.js";
 import { defaultAgentDir, syncAgentFiles } from "./agents.js";
@@ -15,6 +15,7 @@ import { Logger } from "./log.js";
 import { UpstreamHealth, EXIT_UPSTREAM_UNREACHABLE } from "./health.js";
 import { Proxy } from "./proxy.js";
 import { startAdmin } from "./admin.js";
+import { loadModelCatalog } from "./catalog.js";
 import { RequestLog } from "./requestlog.js";
 import { OpenAiIngress } from "./ingress/server.js";
 import { ObservedClaudeCodeAuth } from "./providers/anthropic-observed.js";
@@ -123,6 +124,9 @@ setInterval(() => {
     const oi = ingress.stats;
     log.info(`stats proxy=${s.started}/${s.completed}/${s.failed} inFlight=${s.inFlight} ingress=${oi.started}/${oi.completed}/${oi.failed} inFlight=${oi.inFlight} consecutiveUpstreamFailures=${health.consecutiveFailures}`);
 }, statsEvery).unref();
+// The config callback above rewrites the Codex catalog when *our* models change; this covers
+// Codex's side (a new OpenAI model arriving in its cache).
+followCodexCache(() => ingressModels(store.get()), undefined, undefined, (e) => log.warn(`codex catalog: ${e.message}`));
 proxy
     .listen()
     .then(async () => {
@@ -150,10 +154,18 @@ proxy
             accounts: () => proxy.chatgptAccounts(),
             clearCooldown: (id) => proxy.chatgptClearCooldown(id),
         }),
+        google: () => ({
+            accounts: () => proxy.googleAccounts(),
+            models: (name) => proxy.googleFetchModels(name),
+            clearCooldown: (id) => proxy.googleClearCooldown(id),
+            recheckVerification: (id) => proxy.googleRecheckVerification(id),
+        }),
         credentials: () => proxy.credentialHealth(),
         picker: () => ({ enabled: !!store.get().picker?.enabled, hosts: terminateHosts(store.get()).slice(1), last: proxy.lastPickerInjection }),
         observedClaudeCodeAuth,
         claudeUsage: () => proxy.claudeUsage.snapshot(),
+        image: (req, signal) => proxy.generateImage(req, signal),
+        modelCatalog: () => loadModelCatalog(),
         shutdown: () => beginDrain("shutdown requested"),
     });
     log.info(`clauderipple admin GUI on http://127.0.0.1:${admin.port}/`);

package/dist/router/src/ingress/server.js

@@ -332,8 +332,9 @@ export class OpenAiIngress {
             // is an OpenAI wire, which the refusal below would otherwise turn away on the provider's type
             // alone. One subscription is one provider, so the model decides.
             const provider = providerFor(configured, route.model);
-            if (provider.type === "chatgpt" || provider.type === "openai-compatible") {
-                const bytes = sendJson(res, 400, openAiError(`${provider.type === "chatgpt" ? "ChatGPT" : "OpenAI-compatible"} provider is not available through OpenAI ingress`, "invalid_request_error", "unsupported_provider"));
+            if (provider.type === "chatgpt" || provider.type === "openai-compatible" || provider.type === "google") {
+                const label = provider.type === "chatgpt" ? "ChatGPT" : provider.type === "google" ? "Google" : "OpenAI-compatible";
+                const bytes = sendJson(res, 400, openAiError(`${label} provider is not available through OpenAI ingress`, "invalid_request_error", "unsupported_provider"));
                 finish(400, bytes, { note: `model ${requested} -> ${provider.type} provider unsupported` });
                 return;
             }

package/dist/router/src/picker.js

@@ -9,6 +9,7 @@
 // entry as a template and override the identifying fields. Surfaces are matched by id
 // heuristically (anything that is not the claude.ai chat surface); the ids we saw are
 // logged once so the heuristic can be tightened.
+import { clampEffort } from "./compat.js";
 export const BOOTSTRAP_PATHS = ["/edge-api/bootstrap", "/api/bootstrap"];
 export function isBootstrapPath(path) {
     return BOOTSTRAP_PATHS.some((p) => path === p || path.startsWith(p + "/") || path.startsWith(p + "?"));
@@ -23,8 +24,35 @@ function isClaudeEntry(m) {
 function pickTemplate(models) {
     return models.find((m) => isClaudeEntry(m) && !m.disabled && m.section !== "deprecated" && m.section !== "legacy") ?? models.find(isClaudeEntry) ?? null;
 }
-/** Mutates `json` in place; returns what was done for logging. */
-export function injectPickerModels(json, extra, contextWindow) {
+/**
+ * The effort menu for one routed model: the template's own options, narrowed to the levels the
+ * model takes.
+ *
+ * The app builds the menu per entry from `thinking.effort_options` (`effortOptionsFor: e =>
+ * …effort_options ?? []` in the Code tab bundle, read 2026-10-02), so a cloned Claude entry offered
+ * Claude's whole ladder for a model that takes three of it. The template's option objects are kept
+ * as they are — they carry the app's localised labels, and an id the app does not know (its list is
+ * low/medium/high/xhigh/max) is not invented here. `recommended` moves to high, or the level nearest
+ * it: when the selected level is not on the list, the app switches to the recommended one (`uw`).
+ * A model that takes none of them gets no `thinking` at all, which the app reads as "no effort".
+ */
+function narrowThinking(entry, levels) {
+    const thinking = entry.thinking;
+    if (!thinking || !Array.isArray(thinking.effort_options))
+        return;
+    const kept = thinking.effort_options.filter((option) => typeof option.id === "string" && levels.includes(option.id));
+    if (kept.length === 0) {
+        delete entry.thinking;
+        return;
+    }
+    const preferred = clampEffort("high", kept.map((option) => option.id));
+    entry.thinking = { ...thinking, effort_options: kept.map(({ recommended: _recommended, ...option }) => (option.id === preferred ? { ...option, recommended: true } : option)) };
+}
+/**
+ * Mutates `json` in place; returns what was done for logging. `effortFor` names the levels a model
+ * takes (by its id without an `@effort` suffix); undefined leaves the template's menu as it is.
+ */
+export function injectPickerModels(json, extra, contextWindow, effortFor) {
     const result = { injected: 0, surfaces: [] };
     const msc = json.model_selector_config;
     if (!Array.isArray(msc) || extra.length === 0)
@@ -60,6 +88,9 @@ export function injectPickerModels(json, extra, contextWindow) {
             for (const k of ["disabled", "disabled_reason", "notice", "selection_notice", "badge", "badge_tooltip", "tooltip", "minimum_tier", "is_default"])
                 delete entry[k];
             entry.section = "main";
+            const levels = effortFor?.(e.model.split("@")[0]);
+            if (levels)
+                narrowThinking(entry, levels);
             surface.models.push(entry);
             result.injected++;
         }

package/dist/router/src/presets.js

@@ -207,7 +207,8 @@ export const PRESETS = [
         // assumption rather than a measurement, and it was wrong: deepseek-v4.1-flash accepts all eight
         // levels including max, and mimo-v2.6-pro accepts none/low/medium/high (measured 2026-09-22).
         // It could not correct itself either — an empty ladder is never measured. Left unstated, each
-        // model's ladder is established on the first save.
+        // model's ladder is established on the first save: from models.dev when it lists the model
+        // (catalog.ts — OpenCode's own catalogue, which does state ladders), by request otherwise.
         fallbackModels: [
             // Responses — the preset's own wire, so these carry no override.
             { id: "muse-spark-1.3-contributor", name: "Muse Spark 1.3 (Contributor)" },