@relay-harness/coding-agent 1.0.2 → 1.0.4

package/dist/extensions/laya/index.js

@@ -1,23 +1,29 @@
 import { randomUUID } from "node:crypto";
-import { mkdirSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { createProvider, } from "@relay-harness/ai";
 import { typesafeSystemOneApi } from "@relay-harness/ai/api/typesafe-system-one.lazy";
 import { getAgentDir } from "../../config.js";
-import { assessmentFromAnswers, heuristicAssessment } from "./assessment.js";
+import { SessionManager } from "../../core/session-manager.js";
+import { assessmentFromAnswers, assessmentFromLabels, heuristicAssessment } from "./assessment.js";
+import { spawnDocker } from "./docker.js";
+import { buildLearnPrompt, exercisesToRows, LEARN_TOOL_NAME, learnToolSchema, renderQuestions, renderTask, sessionTasks, } from "./learn.js";
+import { LAYA_LESSONS_MESSAGE, LESSON_SIMILARITY, ROUTE_SIMILARITY, renderLessons, TaskMemory } from "./memory.js";
 import { LAYA_MODEL_MANIFEST } from "./model-manifest.js";
 import { applyPolicy, DEFAULT_MODEL_REGISTRY, nextTier, PerformanceHistory, POLICY_PROFILES, parseModelRef, QuotaManager, rankCandidates, taskKey, } from "./policy.js";
 import { CAPABILITY_TIERS, LAYA_QUESTIONS, layaDecisionsFile } from "./questions.js";
-import { renderPlanMessage, selectSkills, unneededTools } from "./routers.js";
-import { layaPaths, setupLayaRuntime } from "./runtime.js";
+import { LAYA_PLAN_MESSAGE, renderPlanMessage, selectSkills, unneededTools } from "./routers.js";
+import { layaImage } from "./runtime.js";
 import { generateSeed } from "./seed.js";
 import { isLocalUrl, LayaServer } from "./server.js";
 import { datasetFromTelemetry, HARNESS_MESSAGE, historyFromTelemetry, summarizeRun, TelemetryStore, truncateRequest, } from "./telemetry.js";
+import { accuracy, describeProgress, dockerHasGpu, readRegistry, readRows, SESSION_SOURCE, sharedTrainer, } from "./training.js";
+export { LAYA_PLAN_MESSAGE } from "./routers.js";
 export const LAYA_PROVIDER_ID = "laya";
 export const LAYA_CLASSIFIER_ID = "execution-intelligence";
 export const LAYA_VIRTUAL_MODEL_ID = "auto";
-export const DEFAULT_LAYA_BASE_URL = "http://127.0.0.1:8000/v1";
-export const LAYA_PLAN_MESSAGE = "laya.plan";
+/** Not 8000, the port laya-trainer's own server and many development servers use. */
+export const DEFAULT_LAYA_BASE_URL = "http://127.0.0.1:8737/v1";
 const DEFAULT_TIMEOUT_MS = 5000;
 const DEFAULT_MIN_CONFIDENCE = 0.5;
 const DEFAULT_ESCALATE_AFTER_FAILURES = 3;
@@ -85,17 +91,49 @@ function failuresThisTurn(messages) {
     }
     return { count, evidence };
 }
-export default function layaExtension(relay) {
+const percent = (score) => `${(accuracy(score) * 100).toFixed(1)}%`;
+/** What a finished training changed, for the user. */
+export function describeTrainingOutcome({ model, activated, previous }) {
+    const session = `${model.session.candidate.correct} of ${model.session.candidate.n} answers on the session tasks right (${previous}: ${model.session.current.correct})`;
+    const minutes = Math.max(1, Math.round(model.seconds / 60));
+    return activated
+        ? `Laya learned ${model.sessionTasks} session tasks in about ${minutes} min: ${model.name} now routes requests. It gets ${session}; test ${percent(model.test.candidate)} (${previous}: ${percent(model.test.current)}).`
+        : `Laya trained ${model.name}, but ${previous} keeps routing: the test score fell from ${percent(model.test.current)} to ${percent(model.test.candidate)}. It gets ${session}. /laya use ${model.name} activates it anyway.`;
+}
+/** Files of the Python runtime Relay used to install on the host, before Laya moved to Docker. */
+const HOST_RUNTIME_LEFTOVERS = ["venv", "models", "serve.py", "train.py", "server.log"];
+export default function layaExtension(relay, options = {}) {
     const quota = new QuotaManager();
+    const docker = options.docker ?? spawnDocker;
     const layaHome = join(getAgentDir(), "laya");
     const store = new TelemetryStore(join(layaHome, "telemetry.jsonl"));
-    const server = new LayaServer({
-        paths: layaPaths(layaHome, LAYA_MODEL_MANIFEST),
-        manifest: LAYA_MODEL_MANIFEST,
-        baseUrl: () => settings.baseUrl ?? process.env.LAYA_BASE_URL ?? DEFAULT_LAYA_BASE_URL,
-    });
-    let setupOffered = false;
-    let setupRunning;
+    const baseUrl = () => settings.baseUrl ?? process.env.LAYA_BASE_URL ?? DEFAULT_LAYA_BASE_URL;
+    let variant;
+    let gpu;
+    /** The CUDA image where an NVIDIA GPU exists, the smaller CPU image otherwise. */
+    const hostVariant = async () => {
+        if (process.platform === "darwin")
+            return "cpu";
+        try {
+            return (await relay.exec("nvidia-smi", ["-L"], { timeout: 10_000 })).code === 0 ? "cuda" : "cpu";
+        }
+        catch {
+            return "cpu";
+        }
+    };
+    const imageVariant = () => {
+        variant ??= hostVariant();
+        return variant;
+    };
+    const image = async () => settings.image ?? layaImage(LAYA_MODEL_MANIFEST, await imageVariant());
+    const trainingGpu = () => {
+        gpu ??= (async () => (await imageVariant()) === "cuda" && dockerHasGpu(docker, await image()))();
+        return gpu;
+    };
+    const trainer = sharedTrainer({ home: layaHome, manifest: LAYA_MODEL_MANIFEST, docker, image, gpu: trainingGpu });
+    const server = new LayaServer({ docker, baseUrl, image, model: () => trainer.activeModel().dir });
+    /** Server problem last reported, so a failing Docker is not reported on every start. */
+    let reportedProblem;
     let history = new PerformanceHistory();
     let settings = {};
     let profileOverride;
@@ -108,6 +146,11 @@ export default function layaExtension(relay) {
     let run;
     /** Tools active before enforced tool routing changed them. */
     let toolBaseline;
+    /** Tasks `/laya learn` listed for the agent to label, numbered as the agent saw them. */
+    let learnTasks;
+    /** This runtime's training listener, while it is the latest one. */
+    let listener;
+    let memoryCache;
     const refreshSettings = () => {
         settings = relay.getSettings().laya ?? {};
         quota.configure(settings.quota);
@@ -124,14 +167,47 @@ export default function layaExtension(relay) {
     });
     relay.registerProvider(createLayaProvider(() => settings.baseUrl));
     /** System 1: Laya's answers, or keyword rules when the server cannot answer. */
+    /** Learned tasks, reloaded when the training dataset changes. Undefined when off or empty. */
+    function memory() {
+        if (settings.memory === false)
+            return undefined;
+        let version;
+        try {
+            const stat = statSync(trainer.workspace.dataset);
+            version = `${stat.mtimeMs}:${stat.size}`;
+        }
+        catch {
+            return undefined;
+        }
+        if (memoryCache?.version !== version) {
+            memoryCache = { version, memory: TaskMemory.fromRows(readRows(trainer.workspace.dataset)) };
+        }
+        return memoryCache.memory.size > 0 ? memoryCache.memory : undefined;
+    }
+    /** Lessons of learned tasks similar to a request; none for harness messages such as /laya learn's. */
+    const lessonsFor = (request) => HARNESS_MESSAGE.test(request.trimStart())
+        ? undefined
+        : renderLessons(memory()?.search(request, LESSON_SIMILARITY) ?? []);
+    /** The labels of a learned task close to the request, then Laya's answers, then keyword rules. */
     async function assess(request, ctx, signal) {
+        const learned = memory()?.search(request, ROUTE_SIMILARITY, 1)[0];
+        if (learned) {
+            try {
+                return {
+                    ...assessmentFromLabels(learned.task.expected),
+                    source: "memory",
+                    confidence: learned.similarity,
+                };
+            }
+            catch {
+                // Labeled against questions that have changed since; Laya answers instead.
+            }
+        }
         const classifier = ctx.modelRegistry.findOfType("classifier", LAYA_PROVIDER_ID, LAYA_CLASSIFIER_ID);
-        if (!classifier || Date.now() < layaUnavailableUntil)
+        // While the container installs, or without Docker, the classifier call would only fail.
+        if (!classifier || Date.now() < layaUnavailableUntil || server.state === "installing") {
             return heuristicAssessment(request);
-        // Starts the local server when the runtime is installed; a failed start falls through to the
-        // classifier call, which fails fast and lands on the keyword rules.
-        if (settings.autostart !== false)
-            await server.ensureRunning(signal);
+        }
         const result = await ctx.modelRegistry.classify(classifier, { state: { request: truncateRequest(request) }, questions: LAYA_QUESTIONS }, { signal, timeoutMs: settings.timeoutMs ?? DEFAULT_TIMEOUT_MS, maxRetries: 0 });
         try {
             if (result.stopReason !== "stop")
@@ -203,7 +279,7 @@ export default function layaExtension(relay) {
             alternatives: ranked.slice(1, 4).map((candidate) => candidate.ref),
         };
         current = state;
-        ctx.ui.setStatus("laya", `laya ${profile()}: ${base.assessment.task.type} → ${chosen.tier} ${chosen.model.id} • ${state.thinkingLevel}${base.assessment.source === "heuristic" ? " (rules)" : ""}`);
+        ctx.ui.setStatus("laya", `laya ${profile()}: ${base.assessment.task.type} → ${chosen.tier} ${chosen.model.id} • ${state.thinkingLevel}${{ laya: "", memory: " (memory)", heuristic: " (rules)" }[base.assessment.source]}`);
         return { route: { model: chosen.model, thinkingLevel: state.thinkingLevel, state }, state };
     }
     async function planTask(request, ctx) {
@@ -287,33 +363,133 @@ export default function layaExtension(relay) {
         name: "Auto (Laya)",
         route,
     });
-    /** Installs the Python environment and downloads the trained model. Concurrent calls share one run. */
-    function setupRuntime(ctx) {
-        setupRunning ??= (async () => {
+    /**
+     * Pulls the image and starts or updates the server container, with progress in the status line.
+     * `explicit` is a user command: it always reports the result. Otherwise only a finished
+     * installation and a new problem are reported.
+     */
+    async function install(ctx, explicit = false) {
+        let worked = false;
+        const ok = await server.install((message) => {
+            worked = true;
+            ctx.ui.setStatus("laya-setup", `laya: ${message}`);
+        });
+        ctx.ui.setStatus("laya-setup", undefined);
+        if (ok) {
+            layaUnavailableUntil = 0;
+            lastClassifierError = undefined;
+            reportedProblem = undefined;
+            if (explicit || worked)
+                ctx.ui.notify(`Laya is ${server.describe()}; it routes laya/auto requests.`);
+            return true;
+        }
+        const problem = server.describe();
+        if (explicit || problem !== reportedProblem) {
+            reportedProblem = problem;
+            ctx.ui.notify(`Laya ${problem}. Keyword rules route laya/auto requests until it runs.`, "warning");
+        }
+        return false;
+    }
+    /** Deletes the Python environment and model that Relay installed on the host before Laya moved to Docker. */
+    function removeHostRuntime() {
+        for (const name of HOST_RUNTIME_LEFTOVERS) {
             try {
-                await setupLayaRuntime({
-                    exec: (command, args, options) => relay.exec(command, args, options),
-                    home: layaHome,
-                    manifest: LAYA_MODEL_MANIFEST,
-                    python: settings.python,
-                    signal: ctx.signal,
-                    report: (message) => ctx.ui.setStatus("laya-setup", `laya setup: ${message}`),
-                });
-                ctx.ui.notify("Laya is installed. Starting the server on the next request.");
+                rmSync(join(layaHome, name), { recursive: true, force: true });
             }
-            catch (error) {
-                ctx.ui.notify(`Laya setup failed: ${error instanceof Error ? error.message : String(error)}`, "error");
+            catch {
+                // In use or not ours to delete; it does no harm.
             }
-            finally {
-                ctx.ui.setStatus("laya-setup", undefined);
-                setupRunning = undefined;
+        }
+    }
+    /** Capability tier of a `provider/model` in the Laya model registry. */
+    const tierOf = (ref) => {
+        const registry = { ...DEFAULT_MODEL_REGISTRY, ...settings.models };
+        return CAPABILITY_TIERS.find((tier) => registry[tier]?.includes(ref));
+    };
+    /**
+     * Starts training on the collected exercises. It runs in the background in interactive modes and
+     * reports through the listener; print and JSON mode wait for it, since the process ends with the turn.
+     */
+    async function startTraining(ctx) {
+        if (trainer.running)
+            return "Laya is already training; run /laya train after it ends to include these tasks.";
+        if (server.state !== "ready" && !(await server.install())) {
+            return `Laya ${server.describe()}, so it cannot train yet. Run /laya setup, then /laya train.`;
+        }
+        if (!(await trainingGpu())) {
+            const accepted = !ctx.hasUI ||
+                (await ctx.ui.confirm("Train Laya on the CPU?", "Docker gives Laya no GPU on this computer. Training still works, but can take an hour or more. Laya keeps routing requests meanwhile."));
+            if (!accepted)
+                return "Training was not started. Run /laya train when you want it.";
+        }
+        // The server runs on the CPU, so it keeps routing while the training container has the GPU.
+        const job = trainer.train();
+        if (ctx.mode === "print" || ctx.mode === "json") {
+            try {
+                return describeTrainingOutcome(await job);
             }
-        })();
-        return setupRunning;
+            catch (error) {
+                return `Laya training failed: ${error instanceof Error ? error.message : String(error)}`;
+            }
+        }
+        // The listener reports the result.
+        job.catch(() => { });
+        return "Laya is training in a Docker container (a few minutes with a GPU). The current model keeps routing until it ends; then the new model routes requests if it passes the test.";
     }
-    relay.on("session_start", () => {
+    relay.on("session_start", (_event, ctx) => {
         refreshSettings();
         history = settings.telemetry === false ? new PerformanceHistory() : historyFromTelemetry(store.read());
+        removeHostRuntime();
+        // Install right away in the background: pull the image on first use, then keep the container
+        // running. Sessions without a UI (print mode, SDK, tests) leave Docker alone.
+        if (settings.autostart !== false && ctx.hasUI && isLocalUrl(baseUrl()))
+            void install(ctx);
+        listener = {
+            progress: (progress) => ctx.ui.setStatus("laya-train", `laya training: ${describeProgress(progress)}`),
+            finished: (result) => {
+                ctx.ui.setStatus("laya-train", undefined);
+                if ("error" in result) {
+                    ctx.ui.notify(`Laya training failed: ${result.error.message}`, "error");
+                    return;
+                }
+                ctx.ui.notify(describeTrainingOutcome(result.outcome), result.outcome.activated ? "info" : "warning");
+                // The server container is replaced by one serving the new model.
+                if (result.outcome.activated)
+                    void install(ctx);
+            },
+        };
+        trainer.listener = listener;
+    });
+    relay.registerTool({
+        name: LEARN_TOOL_NAME,
+        label: "Laya learn",
+        description: "Save labeled tasks of this session as training exercises for Laya, Relay's routing model, and train it so similar requests get the right model, effort and tools. Use after /laya learn lists the tasks, or when the user asks Relay to learn from this session or conversation.",
+        parameters: learnToolSchema,
+        // Loaded by /laya learn, or found by tool search when the user asks in their own words.
+        exposure: "deferred",
+        executionMode: "sequential",
+        async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+            if (!learnTasks) {
+                // Called without /laya learn: number this session's tasks and ask for labels against them.
+                const tasks = sessionTasks(ctx.sessionManager.getBranch(), tierOf);
+                learnTasks = { tasks, session: ctx.sessionManager.getSessionId() };
+                throw new Error([
+                    `Nothing was saved: label these tasks of the session by their numbers, then call ${LEARN_TOOL_NAME} again. Leave out entries that are not coding tasks, such as this request to learn.`,
+                    `Questions:\n${renderQuestions()}`,
+                    ...tasks.map(renderTask),
+                ].join("\n\n"));
+            }
+            const rows = exercisesToRows(learnTasks.tasks, params.exercises, {
+                session: learnTasks.session,
+                created: new Date().toISOString(),
+            });
+            const { added, updated } = trainer.addExercises(rows);
+            learnTasks = undefined;
+            const sessionRows = trainer.counts()[SESSION_SOURCE] ?? 0;
+            const saved = `Saved ${rows.length} exercises (${added} new, ${updated} updated); ${sessionRows} session tasks in total, in ${trainer.workspace.dataset}. Requests similar to these tasks use their labels and lessons from the next one.`;
+            const training = params.train === false ? "Training was not started (run /laya train)." : await startTraining(ctx);
+            return { content: [{ type: "text", text: `${saved} ${training}` }], details: { added, updated, training } };
+        },
     });
     /** The user's own tool set: the active tools, or the set enforcement replaced while it is unchanged. */
     const userTools = () => {
@@ -330,19 +506,18 @@ export default function layaExtension(relay) {
             relay.setActiveTools(userTools());
             toolBaseline = undefined;
         }
-        if (!isSelected(ctx))
-            return;
-        // First use: offer to install the trained Laya once per session. Without it, keyword rules route.
-        if (settings.autostart !== false &&
-            !setupOffered &&
-            ctx.hasUI &&
-            server.status() !== "ready" &&
-            isLocalUrl(settings.baseUrl ?? process.env.LAYA_BASE_URL ?? DEFAULT_LAYA_BASE_URL) &&
-            !(await server.isUp())) {
-            setupOffered = true;
-            const accepted = await ctx.ui.confirm("Install Laya?", "laya/auto routes with a trained Laya model. This downloads about 680 MB of model and a Python environment (a few GB, including torch) into ~/.relay/agent/laya. Until then, keyword rules route requests.");
-            if (accepted)
-                await setupRuntime(ctx);
+        if (!isSelected(ctx)) {
+            // Lessons help whichever model runs the request.
+            const lessons = lessonsFor(event.prompt);
+            if (!lessons)
+                return;
+            return {
+                message: {
+                    customType: LAYA_LESSONS_MESSAGE,
+                    content: `[laya:lessons] ${lessons}`,
+                    display: false,
+                },
+            };
         }
         const assessment = await assess(event.prompt, ctx, ctx.signal);
         pending = { request: event.prompt, assessment };
@@ -358,17 +533,24 @@ export default function layaExtension(relay) {
             toolBaseline = { tools: baseline, applied };
             relay.setActiveTools(applied);
         }
+        const lessons = lessonsFor(event.prompt);
+        const plan = renderPlanMessage(assessment, policy, skills, deactivated);
         return {
             message: {
                 customType: LAYA_PLAN_MESSAGE,
-                content: renderPlanMessage(assessment, policy, skills, deactivated),
+                content: lessons ? `${plan}\n- ${lessons}` : plan,
                 display: false,
                 details: { assessment, policy, skills, deactivated },
             },
         };
     });
-    relay.on("session_shutdown", () => {
-        server.stop();
+    relay.on("session_shutdown", (event) => {
+        // The server container keeps running for the next session.
+        if (trainer.listener === listener)
+            trainer.listener = undefined;
+        // Training belongs to the process: it goes on into the next session, and stops when Relay quits.
+        if (event.reason === "quit")
+            trainer.stop();
     });
     relay.on("agent_start", () => {
         run = undefined;
@@ -425,8 +607,21 @@ export default function layaExtension(relay) {
         writeFileSync(path, content, "utf8");
     };
     relay.registerCommand("laya", {
-        description: "Laya execution router: status, policy, decisions, seed, export",
-        getArgumentCompletions: (prefix) => ["status", "setup", "start", "stop", "policy ", "decisions", "seed", "export"]
+        description: "Laya execution router: status, setup, learn from sessions, train, models, policy",
+        getArgumentCompletions: (prefix) => [
+            "status",
+            "setup",
+            "start",
+            "stop",
+            "learn",
+            "train",
+            "models",
+            "use ",
+            "policy ",
+            "decisions",
+            "seed",
+            "export",
+        ]
             .filter((item) => item.startsWith(prefix))
             .map((item) => ({ value: item, label: item.trim() })),
         handler: async (args, ctx) => {
@@ -469,26 +664,91 @@ export default function layaExtension(relay) {
                     ctx.ui.notify(`Exported ${rows.length} evidence-labeled exercises to ${path}`);
                     return;
                 }
-                case "setup": {
-                    await setupRuntime(ctx);
+                case "learn": {
+                    const file = rest.join(" ");
+                    let entries = ctx.sessionManager.getBranch();
+                    let session = ctx.sessionManager.getSessionId();
+                    if (file) {
+                        const path = resolve(ctx.cwd, file);
+                        if (!existsSync(path)) {
+                            ctx.ui.notify(`No session file at ${path}`, "warning");
+                            return;
+                        }
+                        const manager = SessionManager.open(path);
+                        entries = manager.getBranch();
+                        session = manager.getSessionId();
+                    }
+                    const tasks = sessionTasks(entries, tierOf);
+                    if (tasks.length === 0) {
+                        ctx.ui.notify("The session has no requests to learn from yet.", "warning");
+                        return;
+                    }
+                    learnTasks = { tasks, session };
+                    const active = relay.getActiveTools();
+                    if (!active.includes(LEARN_TOOL_NAME))
+                        relay.setActiveTools([...active, LEARN_TOOL_NAME]);
+                    const prompt = buildLearnPrompt(tasks, { source: file ? resolve(ctx.cwd, file) : undefined });
+                    if (ctx.isIdle())
+                        relay.sendUserMessage(prompt);
+                    else
+                        relay.sendUserMessage(prompt, { deliverAs: "followUp" });
+                    return;
+                }
+                case "train": {
+                    ctx.ui.notify(await startTraining(ctx));
+                    return;
+                }
+                case "models": {
+                    const active = trainer.activeModel().name;
+                    const registry = readRegistry(trainer.workspace);
+                    const mark = (name) => (name === active ? " (routing)" : "");
+                    const lines = [`${LAYA_MODEL_MANIFEST.version}: shipped with Relay${mark(LAYA_MODEL_MANIFEST.version)}`];
+                    for (const model of registry.models) {
+                        lines.push(`${model.name}: ${model.createdAt.slice(0, 16).replace("T", " ")}, from ${model.basedOn}, ${model.sessionTasks} session tasks, test ${percent(model.test.candidate)} (${model.basedOn}: ${percent(model.test.current)}), session answers ${model.session.candidate.correct}/${model.session.candidate.n}${mark(model.name)}`);
+                    }
+                    const counts = trainer.counts();
+                    lines.push(`Exercises: ${Object.entries(counts)
+                        .map(([source, count]) => `${count} ${source}`)
+                        .join(", ") || "none yet"} (${trainer.workspace.dataset})`);
+                    if (trainer.running) {
+                        lines.push(`Training: ${trainer.progress ? describeProgress(trainer.progress) : "starting"}`);
+                    }
+                    ctx.ui.notify(lines.join("\n"));
+                    return;
+                }
+                case "use": {
+                    const name = rest[0];
+                    if (!name) {
+                        ctx.ui.notify(`Usage: /laya use <model> (current: ${trainer.activeModel().name}; see /laya models)`, "warning");
+                        return;
+                    }
+                    try {
+                        trainer.use(name);
+                    }
+                    catch (error) {
+                        ctx.ui.notify(error instanceof Error ? error.message : String(error), "warning");
+                        return;
+                    }
+                    ctx.ui.notify(`${trainer.activeModel().name} routes requests once the Laya container restarts with it`);
+                    // Replaces the server container with one serving the selected model.
+                    await install(ctx, true);
                     return;
                 }
+                case "setup":
                 case "start": {
-                    ctx.ui.notify((await server.ensureRunning(ctx.signal))
-                        ? "Laya server is running"
-                        : "Laya server did not start (see /laya status)", "info");
+                    await install(ctx, true);
                     return;
                 }
                 case "stop": {
-                    server.stop();
-                    ctx.ui.notify("Stopped the Laya server this session started");
+                    await server.stop();
+                    ctx.ui.notify("Stopped the Laya container; /laya start or the next Relay start runs it again");
                     return;
                 }
                 case "status": {
                     const providers = new Set(candidates(ctx).map((candidate) => candidate.provider));
                     const lines = [
                         `Profile: ${profile()}${isSelected(ctx) ? "" : " (select laya/auto to route with Laya)"}`,
-                        `Laya runtime: ${server.status()}${server.status() === "ready" ? "" : " (run /laya setup)"}; server ${(await server.isUp()) ? "answering" : "not answering"}`,
+                        `Laya container: ${server.describe()}; server ${(await server.isUp()) ? "answering" : "not answering"} at ${baseUrl()}`,
                         `Laya server: ${lastClassifierError ? `unavailable, using keyword rules (${lastClassifierError})` : "ok or not yet asked"}`,
                         `Models with credentials: ${candidates(ctx)
                             .map((candidate) => `${candidate.tier}:${candidate.ref}`)
@@ -496,6 +756,10 @@ export default function layaExtension(relay) {
                         `Quota: ${Object.entries(quota.snapshot(providers))
                             .map(([name, value]) => `${name} ${value}`)
                             .join(", ") || "none"}`,
+                        `Routing model: ${trainer.activeModel().name}${trainer.running
+                            ? `; training ${trainer.progress ? describeProgress(trainer.progress) : "starting"}`
+                            : ""}`,
+                        `Memory: ${settings.memory === false ? "off" : `${memory()?.size ?? 0} learned tasks route similar requests and share their lessons`}`,
                         `Telemetry: ${settings.telemetry === false ? "off" : store.path}`,
                     ];
                     if (current) {
@@ -508,7 +772,7 @@ export default function layaExtension(relay) {
                     return;
                 }
                 default:
-                    ctx.ui.notify("Usage: /laya [status|setup|start|stop|policy <profile>|decisions [path]|seed [count] [path]|export [path]]", "warning");
+                    ctx.ui.notify("Usage: /laya [status|setup|start|stop|learn [session file]|train|models|use <model>|policy <profile>|decisions [path]|seed [count] [path]|export [path]]", "warning");
             }
         },
     });