@interf/compiler 0.22.0 → 0.33.0

package/dist/cli/commands/wizard.js

@@ -2,12 +2,12 @@
  * `interf` (no subcommand) and `interf init` — the wizard.
  *
  * Casual-user entry point. End-to-end onboarding:
- *   - If no connection → connect to an already-running local engine, or ask
- *     whether to start the foreground local engine, connect remote, or quit.
- *   - Once connected → action menu (list / create / build / test / open UI / stop engine / quit).
+ *   - If no connection → connect to an already-running local service, or ask
+ *     whether to start the foreground local service, connect remote, or quit.
+ *   - Once connected → action menu (list / create / build / test / stop service / quit).
  *   - Each action loops back to the menu instead of exiting.
  *
- * Agents bypass the wizard entirely. They use `interf prep`, `interf build`,
+ * Agents bypass the wizard entirely. They use `interf project`, `interf build`,
  * etc. directly. The wizard is purely a UX wrapper around those CLI commands.
  */
 import chalk from "chalk";
@@ -16,8 +16,8 @@ import { existsSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, resolve } from "node:path";
 import { spawn } from "node:child_process";
-import { ConnectionRecordSchema, readActiveConnection, writeConnection, } from "../../packages/engine/connection-config.js";
-import { LOCAL_SERVICE_DEFAULT_HOST, LOCAL_SERVICE_DEFAULT_PORT } from "../../packages/engine/routes.js";
+import { ConnectionRecordSchema, readActiveConnection, writeConnection, } from "../../packages/runtime/connection-config.js";
+import { LOCAL_SERVICE_DEFAULT_HOST, LOCAL_SERVICE_DEFAULT_PORT } from "../../packages/runtime/service/routes.js";
 async function callJson(url, token) {
     const headers = new Headers();
     if (token)
@@ -60,9 +60,9 @@ function isHttpUrl(value) {
     }
 }
 /**
- * Probe a URL's `/health` endpoint and return whether the engine is up.
+ * Probe a URL's `/health` endpoint and return whether the local service is up.
  * Used as a fallback when `connection.json` may be missing (e.g. older
- * `interf web` binaries that don't write the 0.13 record).
+ * `interf runtime` binaries that don't write the connection record).
  */
 async function probeHealth(url) {
     try {
@@ -73,29 +73,64 @@ async function probeHealth(url) {
         return false;
     }
 }
+async function serviceRequiresAuth(url) {
+    try {
+        const response = await fetch(`${url.replace(/\/+$/, "")}/v1/instance`);
+        if (response.status !== 200)
+            return true;
+        const body = await response.json();
+        return body.auth_required === true;
+    }
+    catch {
+        return true;
+    }
+}
+function activeConnectionForUrl(url) {
+    const normalized = url.replace(/\/+$/, "");
+    const conn = readActiveConnection();
+    if (!conn)
+        return null;
+    return conn.url.replace(/\/+$/, "") === normalized
+        ? { url: normalized, token: conn.auth_token }
+        : null;
+}
+async function connectToReachableEngine(url) {
+    const normalized = url.replace(/\/+$/, "");
+    const existing = activeConnectionForUrl(normalized);
+    if (existing)
+        return existing;
+    if (await serviceRequiresAuth(normalized))
+        return null;
+    try {
+        writeConnection({ url: normalized, auth_token: null });
+    }
+    catch {
+        // best effort
+    }
+    return { url: normalized, token: null };
+}
 /**
- * Connect to an engine. Either an existing one already running on the
+ * Connect to a local service. Either an existing one already running on the
  * default port (with a `wasAlreadyRunning` flag so the caller can tell
  * the user honestly) or a fresh one we spawn here.
  *
  * Returns null on timeout / error.
  */
 async function startLocalEngineInBackground() {
-    // First: check whether an engine is ALREADY running on the default
+    // First: check whether a local service is ALREADY running on the default
     // port. If so, don't pretend to start a new one — just connect.
     if (await probeHealth(DEFAULT_ENGINE_URL)) {
-        try {
-            writeConnection({ url: DEFAULT_ENGINE_URL, auth_token: null });
-        }
-        catch {
-            // best effort
+        const existing = await connectToReachableEngine(DEFAULT_ENGINE_URL);
+        if (!existing) {
+            console.log(chalk.yellow(`  Local service already running at ${DEFAULT_ENGINE_URL}, but no bearer token is available.`));
+            return null;
         }
-        console.log(chalk.dim(`  Engine already running at ${DEFAULT_ENGINE_URL} — connecting.`));
-        return { url: DEFAULT_ENGINE_URL, token: null, wasAlreadyRunning: true };
+        console.log(chalk.dim(`  Local service already running at ${DEFAULT_ENGINE_URL} — connecting.`));
+        return { ...existing, wasAlreadyRunning: true };
     }
     const spinner = p.spinner();
-    spinner.start("Starting local Interf engine…");
-    const child = spawn(process.argv[1] ?? "interf", ["web"], {
+    spinner.start("Starting local Interf service...");
+    const child = spawn(process.argv[1] ?? "interf", ["runtime"], {
         detached: true,
         stdio: "ignore",
     });
@@ -104,34 +139,31 @@ async function startLocalEngineInBackground() {
     const timeoutMs = 30_000;
     while (Date.now() - startedAt < timeoutMs) {
         await new Promise((r) => setTimeout(r, 250));
-        // Path A: connection.json written by the spawned 0.13+ server.
+        // Path A: connection.json written by the spawned server.
         const conn = readActiveConnection();
         if (conn) {
             const url = conn.url.replace(/\/+$/, "");
             if (await probeHealth(url)) {
-                spinner.stop(chalk.green(`Engine ready at ${url}`));
+                spinner.stop(chalk.green(`Local service ready at ${url}`));
                 return { url, token: conn.auth_token, wasAlreadyRunning: false };
             }
         }
-        // Path B: spawned engine is ready on the default URL.
+        // Path B: spawned service is ready on the default URL.
         if (await probeHealth(DEFAULT_ENGINE_URL)) {
-            try {
-                writeConnection({ url: DEFAULT_ENGINE_URL, auth_token: null });
-            }
-            catch {
-                // best effort
+            const existing = await connectToReachableEngine(DEFAULT_ENGINE_URL);
+            if (existing) {
+                spinner.stop(chalk.green(`Local service ready at ${DEFAULT_ENGINE_URL}`));
+                return { ...existing, wasAlreadyRunning: false };
             }
-            spinner.stop(chalk.green(`Engine ready at ${DEFAULT_ENGINE_URL}`));
-            return { url: DEFAULT_ENGINE_URL, token: null, wasAlreadyRunning: false };
         }
     }
-    spinner.stop(chalk.red("Timed out waiting for engine to start."));
+    spinner.stop(chalk.red("Timed out waiting for local service to start."));
     return null;
 }
 /**
  * Print the canonical connect-or-error hint and exit non-zero. Used
- * whenever the wizard needs an engine but no reachable connection
- * exists. The wizard does NOT auto-start an engine — `interf web` is
+ * whenever the wizard needs a local service but no reachable connection
+ * exists. The wizard does NOT auto-start a service — `interf runtime` is
  * the explicit, foreground way to run one.
  */
 function exitNoEngineConnected(reason) {
@@ -139,9 +171,9 @@ function exitNoEngineConnected(reason) {
     console.log(chalk.yellow(`  ${reason}`));
     console.log();
     console.log("  Start one in another terminal:");
-    console.log(chalk.bold("    interf web"));
+    console.log(chalk.bold("    interf runtime"));
     console.log();
-    console.log("  Or connect to a remote engine:");
+    console.log("  Or connect to a remote service:");
     console.log(chalk.bold("    interf login --url <https://…>"));
     console.log();
     process.exit(1);
@@ -156,8 +188,8 @@ async function promptForConnection(reason) {
     const choice = await p.select({
         message: "How do you want to continue?",
         options: [
-            { value: "start-local", label: "Start local engine (serves Interf UI)" },
-            { value: "connect-remote", label: "Connect to remote engine" },
+            { value: "start-local", label: "Start local service" },
+            { value: "connect-remote", label: "Connect to remote service" },
             { value: "quit", label: chalk.dim("Exit") },
         ],
         initialValue: "start-local",
@@ -168,13 +200,13 @@ async function promptForConnection(reason) {
     }
     if (choice === "start-local") {
         console.log();
-        console.log(chalk.dim("  Starting `interf web` in this terminal. Press Ctrl-C to stop the engine."));
+        console.log(chalk.dim("  Starting `interf runtime` in this terminal. Press Ctrl-C to stop the service."));
         console.log();
-        const code = await spawnInterf(["web"]);
+        const code = await spawnInterf(["runtime"]);
         process.exit(code);
     }
     const urlValue = await p.text({
-        message: "Remote engine URL",
+        message: "Remote service URL",
         placeholder: "https://api.interf.cloud",
         validate: (value) => {
             const trimmed = String(value ?? "").trim();
@@ -265,27 +297,20 @@ async function promptSourcePath() {
     }
     return String(choice);
 }
-async function flowCreatePreparation(conn) {
-    const prepId = await p.text({
-        message: "Preparation id (a short name for this unit of agent work)",
-        placeholder: "my-prep",
+async function flowCreateProject(conn) {
+    const projectId = await p.text({
+        message: "Project id (a short name for this agent task)",
+        placeholder: "my-project",
         validate: (value) => (/^[a-z0-9][a-z0-9-]*$/.test(value) ? undefined : "Lowercase letters, numbers, and dashes only."),
     });
-    if (p.isCancel(prepId))
+    if (p.isCancel(projectId))
         return null;
-    const about = await p.text({
-        message: "What is this preparation for? (one line — the agent task intent)",
-        placeholder: "Prepare these notes so an agent can answer questions about them.",
-    });
-    if (p.isCancel(about))
-        return null;
-    const aboutText = String(about ?? "").trim();
     const sourcePath = await promptSourcePath();
     if (!sourcePath)
         return null;
     // Offer saved Build Plans, but keep selection optional. The agent-first
-    // path usually creates the Preparation from requested Artifacts first,
-    // then drafts a custom Build Plan for review.
+    // path usually creates the Project from Source first, then drafts a
+    // custom Build Plan for review.
     const buildPlansResp = await callJson(`${conn.url}/v1/build-plans`, conn.token);
     const buildPlans = buildPlansResp.body?.build_plans ?? [];
     const buildPlanOptions = buildPlans
@@ -339,30 +364,29 @@ async function flowCreatePreparation(conn) {
         }
     }
     const exitCode = await spawnInterf([
-        "prep",
+        "project",
         "create",
-        String(prepId),
+        String(projectId),
         "--source",
         resolve(String(sourcePath)),
         ...(buildPlanId ? ["--build-plan", buildPlanId] : []),
-        ...(aboutText ? ["--about", aboutText] : []),
     ]);
     if (exitCode !== 0)
         return null;
-    return String(prepId);
+    return { id: String(projectId), buildPlanId };
 }
-async function pickPreparation(conn, message) {
-    const preps = await callJson(`${conn.url}/v1/preparations`, conn.token);
-    const list = preps.body?.preparations ?? [];
+async function pickProject(conn, message) {
+    const projects = await callJson(`${conn.url}/v1/projects`, conn.token);
+    const list = projects.body?.projects ?? [];
     if (list.length === 0) {
-        console.log(chalk.dim("  No preparations yet. Create one first."));
+        console.log(chalk.dim("  No Projects yet. Create one first."));
         return null;
     }
     const choice = await p.select({
         message,
-        options: list.map((prep) => ({
-            value: prep.id,
-            label: `${prep.id} ${chalk.dim(`(${prep.build_plan_id ?? "no Build Plan"} · ${prep.readiness?.status ?? "-"})`)}`,
+        options: list.map((project) => ({
+            value: project.id,
+            label: `${project.id} ${chalk.dim(`(${project.build_plan_id ?? "no Build Plan"} · ${project.readiness?.status ?? "-"})`)}`,
         })),
     });
     if (p.isCancel(choice))
@@ -371,28 +395,27 @@ async function pickPreparation(conn, message) {
 }
 async function showActionMenu(conn, options = { allowAgentRuns: true }) {
     const buildLabel = options.allowAgentRuns
-        ? "Build a preparation"
-        : chalk.dim("Build a preparation (no agents available)");
-    const testLabel = options.allowAgentRuns
-        ? "Run readiness checks"
-        : chalk.dim("Readiness checks (no agents available)");
+        ? "Build a Project"
+        : chalk.dim("Build a Project (no agents available)");
+    const benchmarkLabel = options.allowAgentRuns
+        ? "Run benchmark/evaluation"
+        : chalk.dim("Benchmark/evaluation (no agents available)");
     const action = await p.select({
         message: "What do you want to do?",
         options: [
-            { value: "ui", label: "Open Interf UI" },
-            { value: "ls", label: "List preparations" },
-            { value: "create", label: "Create a new preparation" },
+            { value: "ls", label: "List Projects" },
+            { value: "create", label: "Create a new Project" },
             { value: "agents", label: "Manage agents (list / register / role-map)" },
             { value: "build", label: buildLabel },
-            { value: "test", label: testLabel },
-            { value: "stop", label: "Stop the local engine" },
+            { value: "benchmark", label: benchmarkLabel },
+            { value: "stop", label: "Stop the local service" },
             { value: "quit", label: "Quit" },
         ],
     });
     if (p.isCancel(action) || action === "quit")
         return "exit";
     if (action === "ls") {
-        await spawnInterf(["prep", "ls"]);
+        await spawnInterf(["project", "ls"]);
         return "continue";
     }
     if (action === "agents") {
@@ -400,17 +423,21 @@ async function showActionMenu(conn, options = { allowAgentRuns: true }) {
         return "continue";
     }
     if (action === "create") {
-        const newId = await flowCreatePreparation(conn);
-        if (newId) {
+        const created = await flowCreateProject(conn);
+        if (created) {
             if (!options.allowAgentRuns) {
                 console.log(chalk.dim("  Skipping build prompt — no agents available. Install one then run `interf build " +
-                    newId +
+                    created.id +
                     "`."));
             }
+            else if (!created.buildPlanId) {
+                console.log(chalk.dim(`  Project ${created.id} created. Draft or select a Build Plan before building: ` +
+                    `interf plan draft ${created.id} --intent "...".`));
+            }
             else {
-                const buildNow = await p.confirm({ message: `Build ${newId} now?`, initialValue: true });
+                const buildNow = await p.confirm({ message: `Build ${created.id} now?`, initialValue: true });
                 if (!p.isCancel(buildNow) && buildNow) {
-                    await spawnInterf(["build", newId]);
+                    await spawnInterf(["build", created.id]);
                 }
             }
         }
@@ -423,43 +450,25 @@ async function showActionMenu(conn, options = { allowAgentRuns: true }) {
             console.log("  register a custom CLI: `interf agents register <name> --command <cmd>`.");
             return "continue";
         }
-        const id = await pickPreparation(conn, "Which preparation to build?");
+        const id = await pickProject(conn, "Which Project to build?");
         if (id)
             await spawnInterf(["build", id]);
         return "continue";
     }
-    if (action === "test") {
+    if (action === "benchmark") {
         if (!options.allowAgentRuns) {
-            console.log(chalk.yellow("  Cannot run readiness checks — no agents available."));
+            console.log(chalk.yellow("  Cannot run benchmark/evaluation — no agents available."));
             return "continue";
         }
-        const id = await pickPreparation(conn, "Which preparation should Interf test?");
+        const id = await pickProject(conn, "Which Project should Interf benchmark?");
         if (id)
-            await spawnInterf(["test", id]);
-        return "continue";
-    }
-    if (action === "ui") {
-        const target = `${conn.url}/`;
-        console.log();
-        console.log(`  Opening ${chalk.bold(target)} in your browser…`);
-        const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
-        try {
-            const child = spawn(command, [target], { detached: true, stdio: "ignore" });
-            child.on("error", () => {
-                console.log(chalk.dim(`  (Could not open browser; visit ${target} manually.)`));
-            });
-            child.unref();
-        }
-        catch {
-            console.log(chalk.dim(`  (Could not open browser; visit ${target} manually.)`));
-        }
-        console.log();
+            await spawnInterf(["benchmark", id]);
         return "continue";
     }
     if (action === "stop") {
-        const ok = await p.confirm({ message: "Stop the connected engine?", initialValue: false });
+        const ok = await p.confirm({ message: "Stop the connected local service?", initialValue: false });
         if (!p.isCancel(ok) && ok) {
-            await spawnInterf(["web", "stop"]);
+            await spawnInterf(["runtime", "stop"]);
             return "exit";
         }
         return "continue";
@@ -467,17 +476,17 @@ async function showActionMenu(conn, options = { allowAgentRuns: true }) {
     return "continue";
 }
 /**
- * Agent install-cards menu shown when the connected engine has zero
+ * Agent install-cards menu shown when the connected service has zero
  * detected + registered agents. Returns:
  *   - "rerun" → user installed an agent and wants to retry detection
- *   - "skip"  → continue in UI-only mode (no build/test)
+ *   - "skip"  → continue in read-only mode (no build/benchmark)
  *   - "quit"  → exit
  */
 async function showAgentInstallCards() {
     console.log();
     console.log(chalk.yellow("  No agents detected."));
     console.log();
-    console.log("  Interf needs at least one agent to build verifiable context and run readiness checks.");
+    console.log("  Interf needs at least one agent to build a Context Graph and run benchmark/evaluation passes.");
     console.log();
     const choice = await p.select({
         message: "How do you want to proceed?",
@@ -500,7 +509,7 @@ async function showAgentInstallCards() {
             },
             {
                 value: "skip",
-                label: chalk.dim("Skip — UI-only mode (browse existing verifiable context only)"),
+                label: chalk.dim("Skip - read-only mode (browse existing Context Graph only)"),
             },
             { value: "quit", label: chalk.dim("Quit") },
         ],
@@ -568,7 +577,7 @@ async function showAgentInstallCards() {
             message: "What now?",
             options: [
                 { value: "rerun", label: "I installed it — re-detect" },
-                { value: "skip", label: chalk.dim("Skip — continue in UI-only mode") },
+                { value: "skip", label: chalk.dim("Skip - continue in read-only mode") },
                 { value: "quit", label: chalk.dim("Quit") },
             ],
         });
@@ -580,13 +589,13 @@ async function showAgentInstallCards() {
     }
     return "rerun";
 }
-async function fetchAgentSnapshot(conn) {
+async function fetchAgentState(conn) {
     const instance = await callJson(`${conn.url}/v1/instance`, conn.token);
     const agentsResponse = await callJson(`${conn.url}/v1/agents`, conn.token);
     if (instance.status !== 200)
         return null;
-    // Engines pre-0.15 don't expose /v1/agents. Surface the gap explicitly
-    // so the wizard can tell the user to restart instead of silently going
+    // Older engines don't expose /v1/agents. Surface the gap explicitly so
+    // the wizard can tell the user to restart instead of silently going
     // through the install-cards flow.
     const engineSupportsAgents = agentsResponse.status === 200 && instance.body?.agent_count !== undefined;
     return {
@@ -598,7 +607,7 @@ async function fetchAgentSnapshot(conn) {
 }
 async function runWizard(args) {
     // The wizard is the human entry point, so it can ask how to connect.
-    // It still never auto-starts an engine: starting `interf web` is an
+    // It still never auto-starts a service: starting `interf runtime` is an
     // explicit foreground choice, and script/agent commands keep the
     // connect-or-error behavior.
     const initial = readActiveConnection({
@@ -608,18 +617,17 @@ async function runWizard(args) {
     let conn = null;
     if (!initial) {
         if (await probeHealth(DEFAULT_ENGINE_URL)) {
-            try {
-                writeConnection({ url: DEFAULT_ENGINE_URL, auth_token: null });
+            conn = await connectToReachableEngine(DEFAULT_ENGINE_URL);
+            if (conn) {
+                console.log();
+                console.log(chalk.dim(`  Local service already running at ${DEFAULT_ENGINE_URL} — connecting.`));
             }
-            catch {
-                // best effort
+            else {
+                conn = await promptForConnection(`Local service is running at ${DEFAULT_ENGINE_URL}, but no bearer token is available.`);
             }
-            console.log();
-            console.log(chalk.dim(`  Engine already running at ${DEFAULT_ENGINE_URL} — connecting.`));
-            conn = { url: DEFAULT_ENGINE_URL, token: null };
         }
         else {
-            conn = await promptForConnection("No Interf engine is connected.");
+            conn = await promptForConnection("No Interf local service is connected.");
         }
     }
     else {
@@ -627,15 +635,14 @@ async function runWizard(args) {
         const probe = await callJson(`${url}/health`, initial.auth_token);
         if (probe.status === 0) {
             if (!args.url && await probeHealth(DEFAULT_ENGINE_URL)) {
-                try {
-                    writeConnection({ url: DEFAULT_ENGINE_URL, auth_token: null });
+                conn = await connectToReachableEngine(DEFAULT_ENGINE_URL);
+                if (conn) {
+                    console.log();
+                    console.log(chalk.dim(`  Saved connection ${url} is unreachable; using local service at ${DEFAULT_ENGINE_URL}.`));
                 }
-                catch {
-                    // best effort
+                else {
+                    conn = await promptForConnection(`Saved connection ${url} is unreachable. The default local service is running, but no bearer token is available.`);
                 }
-                console.log();
-                console.log(chalk.dim(`  Saved connection ${url} is unreachable; using local engine at ${DEFAULT_ENGINE_URL}.`));
-                conn = { url: DEFAULT_ENGINE_URL, token: null };
             }
             else {
                 conn = await promptForConnection(`Connection ${url} is unreachable.`);
@@ -651,23 +658,21 @@ async function runWizard(args) {
     const instance = await callJson(`${conn.url}/v1/instance`, conn.token);
     console.log();
     console.log(chalk.bold(`  Connected to ${conn.url}`));
-    if (instance.body?.package_version) {
-        console.log(chalk.dim(`  v${instance.body.package_version} · ${instance.body.preparation_count ?? 0} preparation(s)`));
-    }
-    // 0.15 — surface the connected agents up front. When zero are
+    console.log(chalk.dim(`  ${instance.body?.project_count ?? 0} project(s)`));
+    // surface the execution agents up front. When zero are
     // detected, run the install-cards menu before letting the user
-    // try to build or run readiness checks.
-    let agents = await fetchAgentSnapshot(conn);
+    // try to build or run benchmark/evaluation passes.
+    let agents = await fetchAgentState(conn);
     if (agents && !agents.engineSupportsAgents) {
         console.log();
-        console.log(chalk.yellow("  ⚠  The connected engine is older than this CLI."));
+        console.log(chalk.yellow("  The connected local service is older than this CLI."));
         console.log(chalk.dim("     /v1/agents is not available — agent management is disabled."));
         console.log();
         const choice = await p.select({
-            message: "Restart the engine now to pick up new features?",
+            message: "Restart the local service now to pick up new features?",
             options: [
-                { value: "restart", label: "Yes — stop old engine, start new one" },
-                { value: "continue", label: chalk.dim("No — continue with limited features (no agents UI / build / test)") },
+                { value: "restart", label: "Yes - stop old service, start new one" },
+                { value: "continue", label: chalk.dim("No - continue with limited features (no agent management, Build runs, or benchmark runs)") },
                 { value: "quit", label: "Quit" },
             ],
             initialValue: "restart",
@@ -678,26 +683,26 @@ async function runWizard(args) {
         }
         if (choice === "restart") {
             console.log();
-            console.log(chalk.dim("  Stopping old engine…"));
-            await spawnInterf(["web", "stop"]);
+            console.log(chalk.dim("  Stopping old service..."));
+            await spawnInterf(["runtime", "stop"]);
             // Small grace period for the OS to release the port.
             await new Promise((r) => setTimeout(r, 800));
             const restarted = await startLocalEngineInBackground();
             if (!restarted) {
-                console.log(chalk.red("  Could not start the new engine. Try manually: interf web"));
+                console.log(chalk.red("  Could not start the new local service. Try manually: interf runtime"));
                 process.exit(1);
             }
             conn = restarted;
-            agents = await fetchAgentSnapshot(conn);
+            agents = await fetchAgentState(conn);
         }
     }
     // Treat "all registered agents are unavailable" the same as "no agents
     // detected" — the install-cards menu lets the user install or register
     // a real one before the active-agent picker runs.
-    function installedAgentCount(snapshot) {
-        if (!snapshot)
+    function installedAgentCount(registry) {
+        if (!registry)
             return 0;
-        return snapshot.agents.filter((agent) => agent.available !== false).length;
+        return registry.agents.filter((agent) => agent.available !== false).length;
     }
     let allowAgentRuns = installedAgentCount(agents) > 0;
     while (agents &&
@@ -713,7 +718,7 @@ async function runWizard(args) {
             break;
         }
         // decision === "rerun"
-        agents = await fetchAgentSnapshot(conn);
+        agents = await fetchAgentState(conn);
         allowAgentRuns = installedAgentCount(agents) > 0;
     }
     if (agents && agents.engineSupportsAgents && installedAgentCount(agents) > 0) {
@@ -724,7 +729,7 @@ async function runWizard(args) {
         //
         // Custom agents whose CLI is no longer on PATH carry `available: false`
         // — show them in a hint instead of as selectable choices so the picker
-        // does not let the user pick something the engine cannot run.
+        // does not let the user pick something the local service cannot run.
         const stale = agents.agents.filter((agent) => agent.available === false);
         if (stale.length > 0) {
             const names = stale.map((agent) => agent.display_name || agent.name).join(", ");
@@ -756,14 +761,14 @@ async function runWizard(args) {
                 p.outro("Bye.");
                 return;
             }
-            agents = await fetchAgentSnapshot(conn);
+            agents = await fetchAgentState(conn);
         }
         else if (choice !== agents.defaultAgent) {
             // Switch active agent before proceeding. Reuse the existing CLI to
             // sweep the role-map's `general` row + any role pinned to the
             // previous active.
             await spawnInterf(["agents", "use", String(choice)]);
-            agents = await fetchAgentSnapshot(conn);
+            agents = await fetchAgentState(conn);
         }
         if (agents && agents.defaultAgent) {
             console.log(chalk.dim(`  Active: ${agents.defaultAgent} · roles default to ${agents.defaultAgent}`));

package/dist/cli/index.d.ts

@@ -1,16 +1,19 @@
 import { agentsCommand } from "./commands/agents.js";
 import { buildCommand } from "./commands/build.js";
-import { testCommand } from "./commands/test.js";
+import { benchmarkCommand } from "./commands/benchmark.js";
 import { doctorCommand } from "./commands/doctor.js";
 import { buildPlanCommand } from "./commands/build-plan.js";
 import { mcpCommand } from "./commands/mcp.js";
 import { runsCommand } from "./commands/runs.js";
+import { graphsCommand } from "./commands/graphs.js";
+import { tracesCommand } from "./commands/traces.js";
 import { statusCommand } from "./commands/status.js";
 import { resetCommand } from "./commands/reset.js";
-import { webCommand } from "./commands/web.js";
-import { prepCommand } from "./commands/prep.js";
+import { runtimeCommand } from "./commands/runtime.js";
+import { projectCommand } from "./commands/project.js";
 import { loginCommand } from "./commands/login.js";
 import { logoutCommand } from "./commands/logout.js";
+import { authCommand } from "./commands/auth.js";
 import { wizardCommand, initCommand } from "./commands/wizard.js";
 export declare function buildCli(argv?: string[]): import("yargs").Argv<{}>;
 export declare function runCli(argv?: string[]): {
@@ -22,4 +25,4 @@ export declare function runCli(argv?: string[]): {
     _: (string | number)[];
     $0: string;
 }>;
-export { initCommand, buildCommand, testCommand, agentsCommand, doctorCommand, buildPlanCommand, mcpCommand, runsCommand, statusCommand, resetCommand, webCommand, prepCommand, loginCommand, logoutCommand, wizardCommand, };
+export { initCommand, buildCommand, benchmarkCommand, agentsCommand, doctorCommand, buildPlanCommand, mcpCommand, runsCommand, graphsCommand, tracesCommand, statusCommand, resetCommand, runtimeCommand, projectCommand, loginCommand, logoutCommand, authCommand, wizardCommand, };