@timetick/mcp 0.2.1 → 0.3.1

package/dist/index.js

@@ -4,28 +4,696 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
-// src/tools/context.ts
+// src/auth/credentials.ts
+import { chmod, mkdir, readFile, rm, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { dirname, join } from "path";
+var DEFAULT_API_ENDPOINT = "https://app.timetick.io/graphql";
+function apiEndpoint() {
+  return process.env.TIMETICK_API_URL ?? DEFAULT_API_ENDPOINT;
+}
+function credentialFilePath() {
+  return process.env.TIMETICK_CREDENTIALS_PATH ?? join(homedir(), ".timetick", "credentials.json");
+}
+var cached;
+async function loadCredentials(reload = false) {
+  if (cached !== void 0 && !reload) return cached;
+  const text = await readFile(credentialFilePath(), "utf8").catch(() => null);
+  const parsed = text ? safeParse(text) : null;
+  cached = parsed?.apiKey && parsed.endpoint === apiEndpoint() ? parsed : null;
+  return cached;
+}
+function safeParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+function peekCredentials() {
+  return cached ?? null;
+}
+async function saveCredentials(credentials) {
+  const path = credentialFilePath();
+  await mkdir(dirname(path), { recursive: true, mode: 448 });
+  await writeFile(path, `${JSON.stringify(credentials, null, 2)}
+`, { mode: 384 });
+  await chmod(path, 384).catch(() => {
+  });
+  cached = credentials;
+}
+async function clearCredentials() {
+  cached = null;
+  await rm(credentialFilePath(), { force: true });
+}
+
+// src/instructions.ts
+var SERVER_INSTRUCTIONS = `Timetick simulates EV chargers (OCPP 1.6 / 2.0.1) and runs tests against a CSMS: the user's own or Timetick's. Day-to-day work runs through these tools. The web portal is still needed for billing, API keys on Google or LinkedIn accounts, resetting a password, and security profiles (Basic Auth or certificates towards a CSMS).
+
+Sign-in: call whoami. If not logged in, call login, which opens a local browser page for sign-in or sign-up. Never ask for passwords or API keys in chat.
+
+Pick the setup from what is under test:
+- The user's CSMS: simulators connect to it. create_endpoint type EXTERNAL with its public ws(s):// URL; Timetick connects from the cloud, so localhost or private addresses cannot work, and the CSMS must accept the simulator name as the charge point identity. Simulators perform charger-side steps automatically. A Remote: step waits up to 10 minutes for the user's CSMS to send that command, so tell the user what to send and when. It passes or fails on its own from expected results; without them use complete_test_step or fail_test_step.
+- The user's real charger: hardware connects to Timetick's CSMS. create_hardware with a TIMETICK endpoint and a model, get_hardware shows the URL to configure on the charger. Timetick sends Remote: steps automatically; a person performs charger-side steps at the charger.
+
+Flow: (1) establish protocol, target, scale and scenario, asking only what you cannot discover. (2) Check get_context: it says if the project is read-only and what to do. List before creating: project, endpoint, simulator config, OCPP config, manufacturer, model, simulators. New projects already have TIMETICK endpoints. Then power_on_simulator and check networkStatus with get_simulator. (3) Prefer list_test_templates + create_test_from_template for protocol scenarios, otherwise list_actions + create_test. Run with run_test, run_stress_test for load, or create_test_plan + launch_test_plan. (4) Follow with get_test_run; on failure read get_test_run_details and get_simulator_logs, form a hypothesis, fix, rerun. (5) Report what ran, pass or fail, failed steps with reasons and OCPP evidence, and the recommended fix.
+
+A simulator or hardware runs one test at a time. Confirm before delete_* and before stopping a run you did not start. Never ask for ids you can look up with list_* tools.`;
+
+// src/network.ts
+import net from "net";
+var CONNECT_ATTEMPT_TIMEOUT_MS = 2500;
+function allowSlowConnections() {
+  net.setDefaultAutoSelectFamilyAttemptTimeout?.(CONNECT_ATTEMPT_TIMEOUT_MS);
+}
+
+// src/tools/auth.ts
 import { z } from "zod";
+import { TimetickError as TimetickError3 } from "@timetick/sdk";
+
+// src/auth/browser-login.ts
+import { createServer } from "http";
+import { spawn } from "child_process";
+import { randomBytes } from "crypto";
+
+// src/result.ts
+import { TimetickError } from "@timetick/sdk";
+
+// src/version.ts
+import { readFileSync } from "fs";
+var pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+var VERSION = pkg.version;
+var CLIENT_HEADER = { "x-timetick-client": `mcp/${VERSION}` };
+var REGISTRY_URL = "https://registry.npmjs.org/@timetick/mcp/latest";
+var REGISTRY_TIMEOUT_MS = 2e3;
+function isNewerVersion(candidate, current) {
+  const parts = (version) => version.split(".").map((part) => Number.parseInt(part, 10) || 0);
+  const a = parts(candidate);
+  const b = parts(current);
+  for (let i = 0; i < 3; i++) {
+    if ((a[i] ?? 0) !== (b[i] ?? 0)) return (a[i] ?? 0) > (b[i] ?? 0);
+  }
+  return false;
+}
+var latest;
+function latestVersion() {
+  latest ??= fetch(REGISTRY_URL, { signal: AbortSignal.timeout(REGISTRY_TIMEOUT_MS) }).then((res) => res.ok ? res.json() : null).then((body) => body?.version ?? null).catch(() => null);
+  return latest;
+}
+var UPDATE_HOW_TO = "To update, make sure the client config runs `npx -y @timetick/mcp@latest` and restart the client.";
+async function updateNotice() {
+  const newest = await latestVersion();
+  if (!newest || !isNewerVersion(newest, VERSION)) return null;
+  return `A newer Timetick MCP server is available: ${newest} (running ${VERSION}). ${UPDATE_HOW_TO}`;
+}
+
+// src/result.ts
+var KEY_RENAMES = {
+  chargerActions: "steps",
+  scenarioAction: "step",
+  scenarioOperationSubmissions: "stepSettings",
+  actionOperationId: "stepOperationId",
+  groupId: "stressTestId",
+  deviceMode: "mode"
+};
+var DROPPED_KEYS = /* @__PURE__ */ new Set(["__typename", "deviceType"]);
+var ENTITY_TYPES = {
+  SCENARIO: "TEST",
+  SCENARIO_RUN: "TEST_RUN",
+  SCENARIO_ACTION: "TEST_STEP",
+  CHARGER: "SIMULATOR",
+  CHARGER_MODEL: "MODEL",
+  CHARGER_CONFIG: "SIMULATOR_CONFIG",
+  DEVICE: "HARDWARE"
+};
+var LIMIT_NAMES = {
+  Assets: "simulators",
+  "Asset Models": "models",
+  Endpoints: "endpoints",
+  "Project Users": "team members"
+};
+var VERBATIM_KEYS = /* @__PURE__ */ new Set([
+  "args",
+  "values",
+  "data",
+  "preset",
+  "schema",
+  "uiSchema",
+  "request",
+  "response",
+  "requestPayload",
+  "responsePayload",
+  "expectedRequest",
+  "expectedResponse",
+  "actualRequest",
+  "actualResponse",
+  "remoteStart",
+  "remoteStop",
+  "remoteStartV2x",
+  "commandsStrategies"
+]);
+function publicKey(key) {
+  return KEY_RENAMES[key] ?? key.replace(/scenarioRunCharger/g, "testRunSimulator").replace(/ScenarioRunCharger/g, "TestRunSimulator").replace(/scenario/g, "test").replace(/Scenario/g, "Test").replace(/charger/g, "simulator").replace(/Charger/g, "Simulator").replace(/device/g, "hardware").replace(/Device/g, "Hardware");
+}
+var NOT_A_NAME = "(?![-_\\w])";
+var MESSAGE_WORDS = [
+  [new RegExp(`\\bscenario runs?${NOT_A_NAME}`, "g"), "test run"],
+  [new RegExp(`\\bScenario runs?${NOT_A_NAME}`, "g"), "Test run"],
+  [new RegExp(`\\bscenario(s?)${NOT_A_NAME}`, "g"), "test$1"],
+  [new RegExp(`\\bScenario(s?)${NOT_A_NAME}`, "g"), "Test$1"],
+  [new RegExp(`\\brequirement(s?)${NOT_A_NAME}`, "g"), "slot$1"],
+  [new RegExp(`\\bRequirement(s?)${NOT_A_NAME}`, "g"), "Slot$1"],
+  [new RegExp(`(?<!(?:On|Off|Reset) )\\bCharger(s?)${NOT_A_NAME}`, "g"), "Simulator$1"],
+  [new RegExp(`\\bcharger(s?)${NOT_A_NAME}`, "g"), "simulator$1"],
+  [new RegExp(`\\bDevices?${NOT_A_NAME}`, "g"), "Hardware"],
+  [new RegExp(`\\bdevices?${NOT_A_NAME}`, "g"), "hardware"]
+];
+function publicMessage(message) {
+  return MESSAGE_WORDS.reduce((text, [pattern, word]) => text.replace(pattern, word), message);
+}
+function cleanMarkup(text) {
+  if (typeof text !== "string") return "";
+  return text.replace(/<a\b[^>]*href=["']([^"']*)["'][^>]*>([\s\S]*?)<\/a>/gi, "$2 ($1)").replace(/<br\s*\/?>/gi, "\n").replace(/<\/?[a-zA-Z][^>]*>/g, "").replace(/&nbsp;/g, " ").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&amp;/g, "&");
+}
+function listLines(items, style, start = 1, depth = 0) {
+  if (!Array.isArray(items)) return [];
+  const indent = "  ".repeat(depth);
+  return items.flatMap((item, index) => {
+    const marker = style === "ordered" ? `${start + index}.` : "-";
+    if (typeof item === "string") return [`${indent}${marker} ${cleanMarkup(item)}`];
+    const check = style === "checklist" ? item?.meta?.checked ? "[x]" : "[ ]" : marker;
+    return [`${indent}${check} ${cleanMarkup(item?.content)}`, ...listLines(item?.items, style, 1, depth + 1)];
+  });
+}
+function blockLines({ type, data = {} }) {
+  switch (type) {
+    case "list":
+      return listLines(data.items, data.style, Number(data.meta?.start) || 1);
+    case "table":
+      return Array.isArray(data.content) ? data.content.map((row) => Array.isArray(row) ? row.map(cleanMarkup).join(" | ") : "") : [];
+    case "code":
+      return typeof data.code === "string" ? [data.code] : [];
+    case "raw":
+      return [cleanMarkup(data.html)];
+    case "warning":
+      return [data.title, data.message].map(cleanMarkup);
+    case "alert":
+      return [cleanMarkup(data.message)];
+    case "quote":
+      return [data.text, data.caption].map(cleanMarkup);
+    case "image":
+      return [cleanMarkup(data.caption) || "[image]"];
+    case "paragraph":
+    case "header":
+      return [cleanMarkup(data.text)];
+    default:
+      return [cleanMarkup(data.text) || `[${String(type)}]`];
+  }
+}
+function plainDescription(text) {
+  if (!text.startsWith("{")) return text;
+  try {
+    const { blocks } = JSON.parse(text);
+    if (!Array.isArray(blocks) || !blocks.every((block) => typeof block?.type === "string")) return text;
+    return blocks.flatMap(blockLines).filter((line) => line.length > 0).join("\n").trim();
+  } catch {
+    return text;
+  }
+}
+function toPublicVocabulary(value) {
+  if (Array.isArray(value)) return value.map(toPublicVocabulary);
+  if (value === null || typeof value !== "object" || value instanceof Date) return value;
+  return Object.fromEntries(
+    Object.entries(value).filter(([key]) => !DROPPED_KEYS.has(key)).map(([key, entry]) => {
+      if (key === "description" && typeof entry === "string") return [key, plainDescription(entry)];
+      if (key === "entityType" && typeof entry === "string") return [key, ENTITY_TYPES[entry] ?? entry];
+      return [publicKey(key), VERBATIM_KEYS.has(key) ? entry : toPublicVocabulary(entry)];
+    })
+  );
+}
+function ok(text, data) {
+  const body = data === void 0 ? text : `${text}
+
+${JSON.stringify(toPublicVocabulary(data), null, 2)}`;
+  return { content: [{ type: "text", text: body }] };
+}
+function fail(message) {
+  return { content: [{ type: "text", text: message }], isError: true };
+}
+function isContractError(err) {
+  if (err.code === "GRAPHQL_VALIDATION_FAILED") return true;
+  return err.code === "BAD_USER_INPUT" && /is not defined by type|was not provided/.test(err.message);
+}
+function describeScheduleConflict(err) {
+  const conflict = err.errors[0]?.extensions?.scheduleConflict ?? {};
+  const busy = (conflict.devices ?? []).filter((device) => device.isBusy).map((device) => device.name);
+  const runs = (conflict.conflictingRuns ?? []).map((run) => `${run.scenarioRunId} ("${run.name}")`);
+  const options = ["wait", "stop_test_run"];
+  if (conflict.availableResolutions?.includes("RESCHEDULE")) {
+    options.push(
+      `if this tool has onConflict: RESCHEDULE${conflict.firstFreeSlot ? ` (first free ${conflict.firstFreeSlot})` : ""}`
+    );
+  }
+  if (conflict.availableResolutions?.includes("FORCE_RUN")) {
+    options.push("if this tool has onConflict: FORCE_RUN, which stops those runs, so ask the user first");
+  }
+  return `Busy${busy.length ? `: ${busy.join(", ")}` : ""}, so nothing was started.` + (runs.length ? ` Held by test run ${runs.join(", ")}.` : "") + ` Options: ${options.join("; ")}.`;
+}
+function describeApiError(err) {
+  if (err.code === "SCHEDULE_CONFLICT") return describeScheduleConflict(err);
+  if (isContractError(err)) {
+    return `This version of the Timetick MCP server (${VERSION}) no longer matches the Timetick API, so the request was rejected before anything ran. ${UPDATE_HOW_TO} If it is already the newest version, report this to support@timetick.io. Details: ${err.message}`;
+  }
+  if (/not authenticated/i.test(err.message)) {
+    return process.env.TIMETICK_API_TOKEN ? "Timetick rejected the API key in TIMETICK_API_TOKEN (revoked, expired or disabled). Replace it in the client config." : "Timetick rejected the API key (revoked, expired or disabled). Call `whoami`, which picks up a key stored by another session; if it is still rejected, call `login`.";
+  }
+  if (/trial is not available/i.test(err.message)) {
+    return "This account has used its free trial, so this needs a paid plan, which is set up in the web portal.";
+  }
+  const limit = /^Project limit of (.+) is reached$/.exec(err.message);
+  if (limit) {
+    return `This project's plan has reached its limit of ${LIMIT_NAMES[limit[1]] ?? limit[1].toLowerCase()}. Remove some, or change the plan in the web portal.`;
+  }
+  if (/you do not have permission/i.test(err.message)) {
+    return "Timetick refused this: you do not have permission. Your role may not allow it, or the project may have no active plan, which get_context would report along with what to do.";
+  }
+  return `Timetick API error: ${publicMessage(err.message)}`;
+}
+var NETWORK_FAILURE = /fetch failed|ETIMEDOUT|ECONNRESET|ECONNREFUSED|ENOTFOUND|EHOSTUNREACH|socket hang up/i;
+function isNetworkFailure(err) {
+  return !(err instanceof TimetickError) && NETWORK_FAILURE.test(err instanceof Error ? err.message : String(err));
+}
+function describeError(err) {
+  if (err instanceof TimetickError) return describeApiError(err);
+  const message = err instanceof Error ? err.message : String(err);
+  if (isNetworkFailure(err)) {
+    return `Could not reach Timetick (${message}). The request may or may not have been applied: if it created or started something, check with a list_* tool before retrying.`;
+  }
+  return message;
+}
+async function guard(fn) {
+  try {
+    return await fn();
+  } catch (err) {
+    return fail(describeError(err));
+  }
+}
+
+// src/auth/platform.ts
+import { hostname } from "os";
+import { TimetickError as TimetickError2 } from "@timetick/sdk";
+async function request(operationName, query, variables, headers = {}) {
+  const res = await fetch(apiEndpoint(), {
+    method: "POST",
+    headers: { "content-type": "application/json", ...CLIENT_HEADER, ...headers },
+    body: JSON.stringify({ operationName, query, variables })
+  });
+  const body = await res.json().catch(() => null);
+  if (body?.errors?.length) {
+    throw new TimetickError2(body.errors);
+  }
+  if (!body?.data) {
+    throw new Error(
+      res.status >= 500 ? `Timetick is not responding properly (HTTP ${res.status}). Try again shortly.` : `${apiEndpoint()} did not answer like the Timetick API (HTTP ${res.status}). Check TIMETICK_API_URL.`
+    );
+  }
+  return { data: body.data, setCookie: res.headers.getSetCookie?.() ?? [] };
+}
+var SIGN_IN_MUTATION = `
+  mutation SignIn($email: String!, $password: String!) {
+    signIn(email: $email, password: $password) {
+      id
+      email
+      firstName
+      lastName
+    }
+  }
+`;
+var SIGN_UP_MUTATION = `
+  mutation SignUp($email: String!, $password: String!, $firstName: String, $lastName: String, $companyName: String) {
+    signUp(email: $email, password: $password, firstName: $firstName, lastName: $lastName, companyName: $companyName) {
+      id
+    }
+  }
+`;
+var CREATE_API_KEY_MUTATION = `
+  mutation CreateApiKey($name: String!) {
+    createApiKey(name: $name, enabled: true) {
+      apiKey { id name createdAt }
+      secretKey
+    }
+  }
+`;
+var DELETE_API_KEY_MUTATION = `
+  mutation DeleteApiKey($id: ID!) {
+    deleteApiKey(id: $id)
+  }
+`;
+var SESSION_USER_QUERY = `
+  query SessionUser {
+    currentUser {
+      id
+      email
+      firstName
+      lastName
+      companyName
+    }
+  }
+`;
+function extractSessionCookie(setCookie) {
+  for (const cookie of setCookie) {
+    const [pair] = cookie.split(";");
+    const [name, ...rest] = pair.split("=");
+    if (name?.trim() === "sessionID") {
+      const value = rest.join("=");
+      return value ? `sessionID=${value}` : null;
+    }
+  }
+  return null;
+}
+async function signIn(email, password) {
+  const { data, setCookie } = await request("SignIn", SIGN_IN_MUTATION, { email, password });
+  if (!data.signIn) throw new Error("Sign-in failed: wrong email or password.");
+  const sessionCookie = extractSessionCookie(setCookie);
+  if (!sessionCookie) {
+    throw new Error("Signed in but the platform did not return a session cookie.");
+  }
+  return { sessionCookie, user: data.signIn };
+}
+async function signUp(input) {
+  await request("SignUp", SIGN_UP_MUTATION, input);
+}
+async function createApiKey(sessionCookie, name) {
+  const { data } = await request("CreateApiKey", CREATE_API_KEY_MUTATION, { name }, { cookie: sessionCookie });
+  const response = data.createApiKey;
+  if (!response?.secretKey || !response.apiKey?.id) {
+    throw new Error("The platform accepted the login but did not return an API key.");
+  }
+  return { id: response.apiKey.id, secretKey: response.secretKey };
+}
+async function deleteApiKey(apiKey, id) {
+  const { data } = await request("DeleteApiKey", DELETE_API_KEY_MUTATION, { id }, { "x-api-key": apiKey });
+  if (data.deleteApiKey === "ERROR") throw new Error("The platform could not delete the key.");
+}
+async function fetchSessionUser(apiKey) {
+  const { data } = await request("SessionUser", SESSION_USER_QUERY, {}, { "x-api-key": apiKey });
+  return data.currentUser ?? null;
+}
+function displayName(user) {
+  return [user.firstName, user.lastName].filter(Boolean).join(" ") || void 0;
+}
+async function revokeReplaced(previous, newKey) {
+  if (!previous?.keyId || previous.apiKey === newKey) return;
+  await deleteApiKey(previous.apiKey, previous.keyId).catch((err) => {
+    console.error(`Timetick MCP: could not revoke the replaced API key ${previous.keyId}: ${String(err)}`);
+  });
+}
+async function loginWithCredentials(email, password) {
+  const { sessionCookie, user } = await signIn(email, password);
+  const key = await createApiKey(sessionCookie, `MCP (${hostname()})`);
+  const previous = await loadCredentials(true);
+  const credentials = {
+    apiKey: key.secretKey,
+    endpoint: apiEndpoint(),
+    keyId: key.id,
+    email: user.email ?? email,
+    userName: displayName(user),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await saveCredentials(credentials);
+  await revokeReplaced(previous, credentials.apiKey);
+  return { credentials, keyId: key.id };
+}
+async function loginWithApiKey(apiKey) {
+  const user = await fetchSessionUser(apiKey).catch((err) => {
+    if (err instanceof TimetickError2 && /not authenticated/i.test(err.message)) return null;
+    throw err;
+  });
+  if (!user?.id) throw new Error("Timetick did not accept that API key.");
+  const previous = await loadCredentials(true);
+  const credentials = {
+    apiKey,
+    endpoint: apiEndpoint(),
+    email: user.email ?? void 0,
+    userName: displayName(user),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await saveCredentials(credentials);
+  await revokeReplaced(previous, apiKey);
+  return { credentials };
+}
+function portalUrl(path = "/") {
+  return new URL(path, apiEndpoint()).toString();
+}
+
+// src/auth/browser-login.ts
+var LOGIN_TIMEOUT_MS = 10 * 60 * 1e3;
+var MAX_BODY_BYTES = 64 * 1024;
+var TERMS_URL = "https://timetick.io/terms/";
+var PRIVACY_URL = "https://timetick.io/privacy-policy/";
+var EMAIL_RULE = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(\.[a-zA-Z]{2,63})+$/;
+var PASSWORD_RULE = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)\S{8,}$/;
+var STYLE = `
+  body { font-family: -apple-system, "Segoe UI", sans-serif; background: #f6f7f9; display: flex;
+         justify-content: center; padding-top: 8vh; margin: 0; }
+  .card { background: #fff; border-radius: 12px; box-shadow: 0 8px 30px rgba(0,0,0,.08);
+          padding: 2.2rem; width: 24rem; }
+  h1 { font-size: 1.2rem; margin: 0 0 .3rem; }
+  summary { cursor: pointer; font-weight: 600; font-size: .95rem; padding: .7rem 0 .3rem; }
+  p.sub, p.hint { color: #667; font-size: .8rem; margin: .2rem 0 .8rem; }
+  label { display: block; font-size: .78rem; color: #445; margin: .7rem 0 .25rem; }
+  input { width: 100%; box-sizing: border-box; padding: .55rem .7rem; font-size: .95rem;
+          border: 1px solid #ccd; border-radius: 8px; }
+  input[type=checkbox] { width: auto; margin-right: .4rem; }
+  button { margin-top: 1.1rem; width: 100%; padding: .6rem; font-size: .95rem; color: #fff;
+           background: #2563eb; border: 0; border-radius: 8px; cursor: pointer; }
+  .error { background: #fee2e2; color: #991b1b; border-radius: 8px; padding: .6rem .8rem; font-size: .85rem; }
+  .notice { background: #dcfce7; color: #166534; border-radius: 8px; padding: .6rem .8rem; font-size: .85rem; }
+`;
+function shell(title, body) {
+  return `<!doctype html><html><head><meta charset="utf-8"><title>${title}</title><style>${STYLE}</style></head>
+<body><div class="card">${body}</div></body></html>`;
+}
+function escapeHtml(text) {
+  return text.replace(
+    /[&<>"']/g,
+    (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]
+  );
+}
+function page(state, tab, message) {
+  return shell(
+    "Timetick \u2014 sign in",
+    `<h1>Connect your AI client to Timetick</h1>
+    <p class="sub">This page runs on your computer. What you type goes to the Timetick MCP server on this
+    machine and from there to Timetick. It is not shared with the AI client or its conversation.</p>
+    ${message ? `<div class="${message.kind}">${escapeHtml(message.text)}</div>` : ""}
+    <details ${tab === "signin" ? "open" : ""}><summary>Sign in</summary>
+      <form method="post" action="/${state}/signin">
+        <label for="email">Email</label><input id="email" name="email" type="email" required>
+        <label for="password">Password</label><input id="password" name="password" type="password" required>
+        <button type="submit">Sign in</button>
+      </form>
+      <p class="hint"><a href="${escapeHtml(portalUrl("/reset-password"))}" target="_blank" rel="noreferrer">Forgot your password?</a></p>
+    </details>
+    <details ${tab === "signup" ? "open" : ""}><summary>Create an account</summary>
+      <form method="post" action="/${state}/signup">
+        <label for="new-email">Work email</label><input id="new-email" name="email" type="email" required>
+        <label for="new-password">Password (8+ characters with upper and lower case and a digit)</label>
+        <input id="new-password" name="password" type="password" required>
+        <label for="passwordConfirm">Confirm password</label>
+        <input id="passwordConfirm" name="passwordConfirm" type="password" required>
+        <label for="firstName">First name</label><input id="firstName" name="firstName" required minlength="2" maxlength="50">
+        <label for="lastName">Last name</label><input id="lastName" name="lastName" required minlength="2" maxlength="50">
+        <label for="companyName">Company</label><input id="companyName" name="companyName" required minlength="2" maxlength="50">
+        <label><input name="agree" type="checkbox" required>I agree with the
+          <a href="${TERMS_URL}" target="_blank" rel="noreferrer">Terms and Conditions</a> and the
+          <a href="${PRIVACY_URL}" target="_blank" rel="noreferrer">Privacy Policy</a></label>
+        <button type="submit">Create account</button>
+      </form>
+    </details>
+    <details ${tab === "apikey" ? "open" : ""}><summary>Signed up with Google or LinkedIn</summary>
+      <p class="hint">Sign in to the <a href="${escapeHtml(portalUrl())}" target="_blank" rel="noreferrer">
+      Timetick portal</a>, open your project, go to API keys, create one and paste it here.</p>
+      <form method="post" action="/${state}/apikey">
+        <label for="apiKey">API key</label><input id="apiKey" name="apiKey" type="password" required>
+        <button type="submit">Use this key</button>
+      </form>
+    </details>`
+  );
+}
+var donePage = (title, message) => shell("Timetick", `<h1>${title}</h1><p class="sub">${message}</p>`);
+function openBrowser(url) {
+  const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+  const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+  const child = spawn(command, args, { detached: true, stdio: "ignore" });
+  child.on("error", () => {
+  });
+  child.unref();
+}
+async function readForm(req) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of req) {
+    size += chunk.length;
+    if (size > MAX_BODY_BYTES) throw new Error("The form is too large.");
+    chunks.push(chunk);
+  }
+  const out = {};
+  for (const [key, value] of new URLSearchParams(Buffer.concat(chunks).toString("utf8"))) {
+    out[key] = key === "password" || key === "passwordConfirm" ? value : value.trim();
+  }
+  return out;
+}
+function sendHtml(res, status, html) {
+  res.writeHead(status, {
+    "content-type": "text/html; charset=utf-8",
+    "cache-control": "no-store",
+    "referrer-policy": "no-referrer",
+    "content-security-policy": "default-src 'none'; style-src 'unsafe-inline'; form-action 'self'"
+  });
+  res.end(html);
+}
+function validateSignUp(form) {
+  if (!EMAIL_RULE.test(form.email ?? "")) throw new Error("Check the email address.");
+  if (!PASSWORD_RULE.test(form.password ?? "")) {
+    throw new Error("The password needs 8 or more characters with upper and lower case and a digit, and no spaces.");
+  }
+  if (form.password !== form.passwordConfirm) throw new Error("The passwords do not match.");
+  const named = (value, label) => {
+    if (!value || value.length < 2 || value.length > 50) throw new Error(`${label} must be 2 to 50 characters.`);
+    return value;
+  };
+  const account = {
+    email: form.email,
+    password: form.password,
+    firstName: named(form.firstName, "First name"),
+    lastName: named(form.lastName, "Last name"),
+    companyName: named(form.companyName, "Company")
+  };
+  if (form.agree !== "on") throw new Error("Please agree with the Terms and Conditions and the Privacy Policy.");
+  return account;
+}
+var pending = null;
+async function startBrowserLogin(onLogin) {
+  if (pending) {
+    const login = await pending;
+    openBrowser(login.url);
+    return login;
+  }
+  pending = openLoginPage(onLogin).catch((err) => {
+    pending = null;
+    throw err;
+  });
+  return pending;
+}
+async function openLoginPage(onLogin) {
+  const state = randomBytes(16).toString("hex");
+  let resolveDone;
+  let rejectDone;
+  const done = new Promise((resolve, reject) => {
+    resolveDone = resolve;
+    rejectDone = reject;
+  });
+  done.catch(() => {
+  });
+  let host = "";
+  const server = createServer(async (req, res) => {
+    const [, token, action] = (req.url ?? "/").split("?")[0].split("/");
+    if (req.headers.host !== host || token !== state) {
+      return sendHtml(res, 404, donePage("Page expired", "Call the login tool again."));
+    }
+    if (req.method === "GET" && !action) return sendHtml(res, 200, page(state, "signin"));
+    if (req.method !== "POST") return sendHtml(res, 405, donePage("Not allowed", "Unsupported request."));
+    const tab = action === "signup" ? "signup" : action === "apikey" ? "apikey" : "signin";
+    try {
+      const form = await readForm(req);
+      if (action === "signup") {
+        await signUp(validateSignUp(form));
+        return sendHtml(res, 200, page(state, "signin", {
+          kind: "notice",
+          text: "Account created. Open the confirmation link we emailed you, then sign in here."
+        }));
+      }
+      let result;
+      if (action === "apikey") {
+        if (!form.apiKey) throw new Error("Paste an API key.");
+        result = await loginWithApiKey(form.apiKey);
+      } else {
+        if (!form.email || !form.password) throw new Error("Email and password are required.");
+        result = await loginWithCredentials(form.email, form.password);
+      }
+      sendHtml(res, 200, donePage("Connected", "You can close this window and return to your AI client."));
+      finish();
+      onLogin(result);
+      resolveDone(result);
+    } catch (err) {
+      sendHtml(res, 400, page(state, tab, {
+        kind: "error",
+        text: isNetworkFailure(err) ? "Could not reach Timetick. Check your connection and try again." : describeError(err)
+      }));
+    }
+  });
+  const timer = setTimeout(() => {
+    finish();
+    rejectDone(new Error("Sign-in timed out after 10 minutes. Call the login tool to try again."));
+  }, LOGIN_TIMEOUT_MS);
+  timer.unref();
+  function finish() {
+    clearTimeout(timer);
+    server.close();
+    server.closeIdleConnections?.();
+    pending = null;
+  }
+  await new Promise((resolve, reject) => {
+    server.once("error", (err) => {
+      clearTimeout(timer);
+      reject(new Error(`Could not start the local sign-in page: ${err.message}`));
+    });
+    server.listen(0, "127.0.0.1", resolve);
+  });
+  server.unref();
+  const address = server.address();
+  if (!address || typeof address === "string") {
+    finish();
+    throw new Error("Could not determine the local sign-in page address.");
+  }
+  host = `127.0.0.1:${address.port}`;
+  const url = `http://${host}/${state}`;
+  openBrowser(url);
+  console.error(`Timetick MCP: waiting for sign-in at ${url}`);
+  return { url, done };
+}
 
 // src/sdk.ts
 import { createClient } from "@timetick/sdk";
+var NOT_LOGGED_IN_MESSAGE = "Not logged in. Call the `login` tool: it opens a sign-in page in the local browser. On a machine without a browser, set the TIMETICK_API_TOKEN environment variable instead.";
+function authStatus() {
+  const envKey = process.env.TIMETICK_API_TOKEN;
+  if (envKey) return { source: "env", apiKey: envKey };
+  const stored = peekCredentials();
+  if (stored) return { source: "stored", apiKey: stored.apiKey, email: stored.email };
+  return { source: "none", apiKey: null };
+}
 var client = null;
 function sdk() {
   if (client) return client;
-  const apiKey = process.env.TIMETICK_API_TOKEN;
-  if (!apiKey) {
-    throw new Error(
-      "TIMETICK_API_TOKEN is not set. Generate an API key in the Timetick portal (Account \u2192 API keys) and expose it to the MCP server as TIMETICK_API_TOKEN."
-    );
-  }
-  client = createClient({ apiKey, endpoint: process.env.TIMETICK_API_URL });
+  const status = authStatus();
+  if (!status.apiKey) throw new Error(NOT_LOGGED_IN_MESSAGE);
+  client = createClient({
+    apiKey: status.apiKey,
+    endpoint: process.env.TIMETICK_API_URL,
+    headers: CLIENT_HEADER
+  });
   return client;
 }
+function resetSdk() {
+  client = null;
+}
 
 // src/context.ts
 var ContextError = class extends Error {
 };
-var cached = null;
+var cached2 = null;
 async function buildContext(projectId, projectName, source) {
   const worlds = await sdk().simWorlds.list(projectId);
   const world = worlds?.[0];
@@ -51,10 +719,16 @@ function formatProjects(projects) {
 }
 async function findProject(project) {
   const projects = await sdk().projects.list();
-  const needle = project.toLowerCase();
-  const match = projects?.find(
-    (p) => p?.id === project || p?.name?.toLowerCase() === needle
-  );
+  const needle = project.trim().toLowerCase();
+  const exact = projects?.filter((p) => p?.name?.trim() === project.trim()) ?? [];
+  const named = exact.length === 1 ? exact : projects?.filter((p) => p?.name?.trim().toLowerCase() === needle) ?? [];
+  if (named.length > 1 && !projects?.some((p) => p?.id === project.trim())) {
+    throw new ContextError(
+      `${named.length} projects are named "${project}". Use the id instead:
+${formatProjects(named)}`
+    );
+  }
+  const match = projects?.find((p) => p?.id === project.trim()) ?? named[0];
   if (!match?.id) {
     throw new ContextError(
       `No project matching "${project}". Available:
@@ -64,10 +738,10 @@ ${formatProjects(projects)}`
   return { id: match.id, name: match.name ?? "(unnamed)" };
 }
 async function getContext() {
-  if (cached) return cached;
+  if (cached2) return cached2;
   const projects = await sdk().projects.list();
   if (!projects || projects.length === 0) {
-    throw new ContextError("No projects are available for this API key.");
+    throw new ContextError("This account has no projects yet. Create one with create_project.");
   }
   if (projects.length > 1) {
     throw new ContextError(
@@ -76,56 +750,180 @@ ${formatProjects(projects)}`
     );
   }
   const only = projects[0];
-  cached = await buildContext(only.id, only.name ?? "(unnamed)", "single-project");
-  return cached;
+  cached2 = await buildContext(only.id, only.name ?? "(unnamed)", "single-project");
+  return cached2;
 }
 async function useProject(input) {
   const match = await findProject(input.project);
-  cached = await buildContext(match.id, match.name, "explicit");
-  return cached;
+  cached2 = await buildContext(match.id, match.name, "explicit");
+  return cached2;
 }
 async function lookupProject(project) {
   const match = await findProject(project);
   return buildContext(match.id, match.name, "explicit");
 }
+function resetContext() {
+  cached2 = null;
+}
 function peekContext() {
-  return cached;
+  return cached2;
 }
 
-// src/result.ts
-import { TimetickError } from "@timetick/sdk";
-function ok(text, data) {
-  const body = data === void 0 ? text : `${text}
-
-${JSON.stringify(data, null, 2)}`;
-  return { content: [{ type: "text", text: body }] };
+// src/tools/auth.ts
+var LOGIN_WAIT_MS = 45 * 1e3;
+function afterAuthChange() {
+  resetSdk();
+  resetContext();
 }
-function fail(message) {
-  return { content: [{ type: "text", text: message }], isError: true };
+function loggedInMessage({ credentials }) {
+  const who = credentials.userName ?? credentials.email ?? "unknown user";
+  return `Logged in as ${who}. The API key is stored at ${credentialFilePath()}; every tool now works.`;
 }
-async function guard(fn) {
-  try {
-    return await fn();
-  } catch (err) {
-    if (err instanceof TimetickError) return fail(`Timetick API error: ${err.message}`);
-    return fail(err instanceof Error ? err.message : String(err));
-  }
+function registerAuthTools(server, target = server) {
+  server.registerTool(
+    "login",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+      title: "Log in to Timetick",
+      description: "Sign in or create a Timetick account and store an API key locally, so every other tool works without the web portal. Opens a one-time page in the local browser, where the user signs in, signs up or pastes an API key. Credentials never pass through this conversation, so never ask for them in chat. If sign-in is not finished within 45 seconds this returns the page address: show it to the user, wait until they say they are done, then call whoami. Needed once per machine, or again to switch to another account, which replaces the stored key.",
+      inputSchema: {}
+    },
+    async () => guard(async () => {
+      if (process.env.TIMETICK_API_TOKEN) {
+        return fail(
+          "TIMETICK_API_TOKEN is set in the client config and always wins, so a login here would have no effect. Remove the variable and restart the client to use login."
+        );
+      }
+      const login = await startBrowserLogin(afterAuthChange);
+      const finished = await Promise.race([
+        login.done,
+        new Promise((resolve) => setTimeout(() => resolve(null), LOGIN_WAIT_MS).unref())
+      ]);
+      if (finished) return ok(loggedInMessage(finished));
+      return ok(
+        `The sign-in page is open at ${login.url} (only reachable from this machine; open it manually if no browser window appeared). It stays open for 10 minutes. Ask the user to finish there, then call whoami to confirm.`
+      );
+    })
+  );
+  server.registerTool(
+    "logout",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true },
+      title: "Log out of Timetick",
+      description: "Revoke the locally stored API key on the Timetick platform and delete it from this machine. Does nothing to a key provided via the TIMETICK_API_TOKEN environment variable.",
+      inputSchema: {}
+    },
+    async () => guard(async () => {
+      await loadCredentials(true);
+      const status = authStatus();
+      if (status.source === "none") return fail("Already logged out: no stored credentials.");
+      if (status.source === "env") {
+        return fail(
+          "Authentication comes from the TIMETICK_API_TOKEN environment variable, so logout can't revoke it. Remove the variable from the client config instead."
+        );
+      }
+      const stored = await loadCredentials();
+      let revocation = "The key was pasted in by hand, so it stays active until you delete it in the portal.";
+      if (stored?.keyId) {
+        revocation = await deleteApiKey(stored.apiKey, stored.keyId).then(
+          () => "The API key was revoked on the platform.",
+          (err) => `The API key could NOT be revoked (${err instanceof Error ? err.message : String(err)}); delete key ${stored.keyId} in the portal.`
+        );
+      }
+      await clearCredentials();
+      afterAuthChange();
+      return ok(`Logged out and removed the key from ${credentialFilePath()}. ${revocation}`);
+    })
+  );
+  server.registerTool(
+    "whoami",
+    {
+      annotations: { readOnlyHint: true },
+      title: "Show authentication status",
+      description: "Show who the MCP server is authenticated as, where the API key came from, the server version, and whether a newer version is available. Also picks up a login finished in the browser.",
+      inputSchema: {}
+    },
+    async () => guard(async () => {
+      const before = authStatus().apiKey;
+      await loadCredentials(true);
+      const status = authStatus();
+      if (status.apiKey !== before) afterAuthChange();
+      const notice = await updateNotice();
+      const footer = `Timetick MCP ${VERSION}.${notice ? ` ${notice}` : ""}`;
+      if (!status.apiKey) {
+        return ok(
+          `Not logged in: no API key found (looked at TIMETICK_API_TOKEN and ${credentialFilePath()}). Call the login tool to authenticate.
+${footer}`
+        );
+      }
+      const user = await fetchSessionUser(status.apiKey).catch((err) => {
+        if (err instanceof TimetickError3 && /not authenticated/i.test(err.message)) return null;
+        throw err;
+      });
+      if (!user?.id) {
+        const next = status.source === "env" ? "Replace TIMETICK_API_TOKEN in the client config." : "Call the login tool to sign in again.";
+        return fail(`The API key was not accepted (revoked, expired or disabled). ${next}
+${footer}`);
+      }
+      const name = [user.firstName, user.lastName].filter(Boolean).join(" ") || user.email || "unknown user";
+      const company = `${user.email && user.email !== name ? ` <${user.email}>` : ""}${user.companyName ? `, ${user.companyName}` : ""}`;
+      const source = status.source === "env" ? "TIMETICK_API_TOKEN environment variable" : "stored credentials";
+      return ok(`Authenticated as ${name}${company} (key from ${source}).
+${footer}`, { user, source: status.source });
+    })
+  );
+  target.registerTool(
+    "update_profile",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+      title: "Update profile",
+      description: "Update your Timetick account profile (name, company, phone). Changing the sign-in email is done in the web portal.",
+      inputSchema: {
+        firstName: z.string().optional(),
+        lastName: z.string().optional(),
+        companyName: z.string().optional(),
+        companyWebsite: z.string().optional(),
+        phoneNumber: z.string().optional(),
+        countryCode: z.string().optional().describe("Two-letter country code, e.g. 'NL'")
+      }
+    },
+    async (input) => guard(async () => {
+      const me = await sdk().users.getCurrent();
+      if (!me?.id) return fail("Could not resolve the current user id.");
+      const { id } = me;
+      const values = Object.fromEntries(
+        Object.entries(input).filter(([, v]) => v !== void 0)
+      );
+      const updated = await sdk().users.updateProfile({ id, ...values });
+      return ok(`Updated profile.`, updated);
+    })
+  );
 }
 
 // src/tools/context.ts
+import { z as z2 } from "zod";
+async function planNote(projectId) {
+  const project = await sdk().projects.get(projectId).catch(() => null);
+  if (!project) return "";
+  if (project.projectPlan) return ` Plan: ${project.projectPlan.plan?.name ?? "unknown"}.`;
+  if (project.onboardingStatus === "NOT_STARTED" || project.onboardingStatus === "IN_PROGRESS") {
+    return " This project's trial has not started, so it is read-only: its owner can call start_trial.";
+  }
+  return " This project has no active plan, so it is read-only: a paid plan is set up in the web portal.";
+}
 function registerContextTools(server) {
   server.registerTool(
     "get_context",
     {
       annotations: { readOnlyHint: true },
       title: "Get active context",
-      description: "Show the project and sim world the MCP server is currently operating on. If no project is selected yet and you have only one project, it is auto-selected.",
+      description: "Show the project and sim world the MCP server is currently operating on. If no project is selected yet and you have only one project, it is auto-selected. Also shows the project's plan, or that it has none and is read-only.",
       inputSchema: {}
     },
     async () => guard(async () => {
       const ctx = peekContext() ?? await getContext();
       return ok(
-        `Active project: ${ctx.projectName} (id: ${ctx.projectId}); sim world: ${ctx.simWorldId} [${ctx.source}]`,
+        `Active project: ${ctx.projectName} (id: ${ctx.projectId}); sim world: ${ctx.simWorldId} [${ctx.source}].` + await planNote(ctx.projectId),
         ctx
       );
     })
@@ -137,18 +935,19 @@ function registerContextTools(server) {
       title: "Select project",
       description: "Switch the active project by name or id. Only needed if you have more than one project. Caches the project's sim world for subsequent tools.",
       inputSchema: {
-        project: z.string().describe("Project name or id to make active")
+        project: z2.string().describe("Project name or id to make active")
       }
     },
     async ({ project }) => guard(async () => {
       const ctx = await useProject({ project });
-      return ok(`Active project is now ${ctx.projectName} (id: ${ctx.projectId}).`, ctx);
+      return ok(`Active project is now ${ctx.projectName} (id: ${ctx.projectId}).${await planNote(ctx.projectId)}`, ctx);
     })
   );
 }
 
 // src/tools/data.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
+import { describeStepArgs } from "@timetick/sdk";
 
 // src/links.ts
 var SIMULATOR_PATH = /\/projects\/([^/?#&|>\s]+)\/simulators\/([^/?#&|>\s]+)/;
@@ -174,11 +973,27 @@ async function resolveSimWorld(project) {
   if (project) return lookupProject(project);
   return getContext();
 }
+var RESOLVE_PAGE_SIZE = 200;
+var CANDIDATE_LIMIT = 10;
 async function resolveSimulator(simWorldId, simulator) {
   const needle = simulator.toLowerCase();
-  const page = await sdk().simulators.list({ simWorldId, searchValue: simulator });
-  const records = page?.records ?? [];
-  const exact = records.find((r) => r?.id === simulator) ?? records.find((r) => r?.baseName?.toLowerCase() === needle) ?? (records.length === 1 ? records[0] : void 0);
+  const records = [];
+  for (let page2 = 1; ; page2++) {
+    const result = await sdk().simulators.list({
+      simWorldId,
+      searchValue: simulator,
+      pagination: { page: page2, pageSize: RESOLVE_PAGE_SIZE }
+    });
+    records.push(...result?.records ?? []);
+    if (!result?.records?.length || !result.pageInfo?.hasNextPage) break;
+  }
+  const named = records.filter((r) => r?.baseName?.toLowerCase() === needle);
+  if (named.length > 1) {
+    const candidates2 = named.map((r) => `  - ${r?.baseName} (id: ${r?.id}, connects to ${r?.endpoint?.name ?? r?.endpoint?.uri ?? "?"})`).join("\n");
+    throw new Error(`Several simulators are named "${simulator}". Pass the id of one:
+${candidates2}`);
+  }
+  const exact = records.find((r) => r?.id === simulator) ?? named[0];
   if (exact?.id) {
     return { id: exact.id, baseName: exact.baseName ?? "", protocol: String(exact.protocol) };
   }
@@ -186,11 +1001,11 @@ async function resolveSimulator(simWorldId, simulator) {
   if (byId?.id) {
     return { id: byId.id, baseName: byId.baseName ?? "", protocol: String(byId.protocol) };
   }
-  const candidates = records.map((r) => `  - ${r?.baseName} (id: ${r?.id})`).join("\n");
+  const candidates = records.slice(0, CANDIDATE_LIMIT).map((r) => `  - ${r?.baseName} (id: ${r?.id})`).join("\n");
   throw new Error(
-    `No simulator matching "${simulator}".` + (candidates ? `
-Candidates:
-${candidates}` : " No simulators found in this sim world.")
+    `No simulator named "${simulator}".` + (candidates ? `
+Similar names:
+${candidates}` : " No simulators found in this project.")
   );
 }
 async function resolveSimulatorTarget(simulator, project) {
@@ -207,36 +1022,65 @@ async function resolveSimulatorById(id) {
   if (!byId?.id) throw new Error(`No simulator with id ${id} from the portal link.`);
   return { id: byId.id, baseName: byId.baseName ?? "", protocol: String(byId.protocol) };
 }
-async function resolveActionId(simWorldId, protocol, actionName) {
-  const page = await sdk().actions.list({
+async function resolveHardware(ctx, hardware) {
+  const page2 = await sdk().hardware.list({ deviceScopeId: ctx.deviceScopeId, searchValue: hardware });
+  const records = page2?.records ?? [];
+  const match = records.find((r) => r?.id === hardware) ?? records.find((r) => r?.serialNumber?.toLowerCase() === hardware.toLowerCase());
+  if (match?.id) return { id: match.id, name: match.serialNumber ?? match.id, protocol: String(match.protocol) };
+  const byId = await sdk().hardware.get(hardware).catch(() => null);
+  if (byId?.id) return { id: byId.id, name: byId.serialNumber ?? byId.id, protocol: String(byId.protocol) };
+  const candidates = records.map((r) => `  - ${r?.serialNumber} (id: ${r?.id})`).join("\n");
+  throw new Error(
+    `No hardware matching "${hardware}".` + (candidates ? `
+Candidates:
+${candidates}` : "")
+  );
+}
+async function resolveRunTarget(input) {
+  if (Boolean(input.simulator) === Boolean(input.hardware)) {
+    throw new Error("Pass exactly one of `simulator` or `hardware`.");
+  }
+  if (input.simulator) {
+    const { ctx: ctx2, sim } = await resolveSimulatorTarget(input.simulator, input.project);
+    return { ctx: ctx2, kind: "SIMULATOR", id: sim.id, name: sim.baseName, protocol: sim.protocol };
+  }
+  const ctx = await resolveSimWorld(input.project);
+  const device = await resolveHardware(ctx, input.hardware);
+  return { ctx, kind: "HARDWARE", ...device };
+}
+var CATALOG_PAGE_SIZE = 200;
+async function loadActionCatalog(simWorldId, protocol) {
+  const page2 = await sdk().actions.list({
     simWorldId,
-    searchValue: actionName,
-    filters: { isSystem: true, protocol, deviceType: "CHARGER" },
-    pagination: { page: 1, pageSize: 50 }
+    filters: { protocol },
+    pagination: { page: 1, pageSize: CATALOG_PAGE_SIZE }
   });
-  const records = page?.records ?? [];
-  const needle = actionName.toLowerCase();
-  const match = records.find((a) => a?.name?.toLowerCase() === needle) ?? records.find((a) => a?.name?.toLowerCase().includes(needle));
-  if (!match?.id) {
-    const available = records.map((a) => `  - ${a?.name}`).join("\n");
-    throw new Error(
-      `Action "${actionName}" not found for ${protocol}.` + (available ? `
-Available system actions matching your search:
-${available}` : "")
-    );
-  }
-  return match.id;
+  return (page2?.records ?? []).filter((action) => action != null);
+}
+function findAction(catalog, protocol, actionName) {
+  const needle = actionName.trim().toLowerCase();
+  const exact = catalog.find((a) => a.name.toLowerCase() === needle);
+  if (exact) return exact;
+  const partial = catalog.filter((a) => a.name.toLowerCase().includes(needle));
+  if (partial.length === 1) return partial[0];
+  const names = (partial.length > 1 ? partial : catalog).map((a) => a.name).join(", ");
+  throw new Error(
+    partial.length > 1 ? `Step "${actionName}" is ambiguous for ${protocol}. Use one of: ${names}.` : `No step "${actionName}" for ${protocol}. Available: ${names}.`
+  );
+}
+async function resolveAction(simWorldId, protocol, actionName) {
+  return findAction(await loadActionCatalog(simWorldId, protocol), protocol, actionName);
 }
 
 // src/pagination.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 var DEFAULT_PAGE_SIZE = 20;
 var paginationArgs = {
-  page: z2.number().int().min(1).optional().describe("Page number, starting at 1 (default 1)"),
-  pageSize: z2.number().int().min(1).max(200).optional().describe(`Results per page (default ${DEFAULT_PAGE_SIZE})`)
+  page: z3.number().int().min(1).optional().describe("Page number, starting at 1 (default 1)"),
+  pageSize: z3.number().int().min(1).max(200).optional().describe(`Results per page (default ${DEFAULT_PAGE_SIZE})`)
 };
-function pagination(page, pageSize, defaultPageSize = DEFAULT_PAGE_SIZE) {
-  return { page: page ?? 1, pageSize: pageSize ?? defaultPageSize };
+function pagination(page2, pageSize, defaultPageSize = DEFAULT_PAGE_SIZE) {
+  return { page: page2 ?? 1, pageSize: pageSize ?? defaultPageSize };
 }
 function pageSummary(noun, count, pageInfo) {
   const total = pageInfo?.totalCount;
@@ -245,19 +1089,18 @@ function pageSummary(noun, count, pageInfo) {
 }
 
 // src/tools/data.ts
-var protocolEnum = z3.enum(["OCPP_1_6", "OCPP_2_0_1"]);
-function summarizeArgs(params) {
-  if (!params || typeof params !== "object") return void 0;
-  const summary = {};
-  for (const [name, spec] of Object.entries(params)) {
-    if (!spec || typeof spec !== "object") continue;
-    const { type, allowNull, defaultValue, visible } = spec;
-    if (visible === false) continue;
-    const parts = [String(type ?? "unknown"), allowNull === false ? "required" : "optional"];
-    if (defaultValue !== void 0) parts.push(`default ${JSON.stringify(defaultValue)}`);
-    summary[name] = parts.join(", ");
-  }
-  return Object.keys(summary).length > 0 ? summary : void 0;
+var protocolEnum = z4.enum(["OCPP_1_6", "OCPP_2_0_1"]);
+function summarizeAction(action) {
+  return {
+    name: action.name,
+    description: action.description ?? void 0,
+    kind: action.deviceType === "CSMS" ? "remote" : "charger-side",
+    custom: action.isSystem ? void 0 : true,
+    args: Object.fromEntries(Object.entries(describeStepArgs(action)).filter(([name]) => name !== "onFail")),
+    defaultExpectedResults: (action.actionOperations ?? []).flatMap(
+      (operation) => (operation.expectedResults ?? []).map((result) => result.commandName)
+    )
+  };
 }
 function registerDataTools(server) {
   server.registerTool(
@@ -280,19 +1123,19 @@ function registerDataTools(server) {
       title: "List simulators",
       description: "List simulators (virtual chargers) in the active project's sim world. Optionally filter by name search or protocol.",
       inputSchema: {
-        search: z3.string().optional().describe("Filter by simulator base name"),
+        search: z4.string().optional().describe("Filter by simulator base name"),
         protocol: protocolEnum.optional(),
         ...paginationArgs,
-        project: z3.string().optional().describe("Project name or id (defaults to active project)")
+        project: z4.string().optional().describe("Project name or id (defaults to active project)")
       }
     },
-    async ({ search, protocol, page, pageSize, project }) => guard(async () => {
+    async ({ search, protocol, page: page2, pageSize, project }) => guard(async () => {
       const ctx = await resolveSimWorld(project);
       const result = await sdk().simulators.list({
         simWorldId: ctx.simWorldId,
         searchValue: search,
         filters: protocol ? { protocol } : void 0,
-        pagination: pagination(page, pageSize)
+        pagination: pagination(page2, pageSize)
       });
       return ok(
         pageSummary("simulator(s)", result?.records?.length ?? 0, result?.pageInfo),
@@ -307,8 +1150,8 @@ function registerDataTools(server) {
       title: "Get simulator",
       description: "Get a simulator's details and live status (network status, launched/power status, connectors) by id or base name.",
       inputSchema: {
-        simulator: z3.string().describe(SIMULATOR_ARG_DESCRIPTION),
-        project: z3.string().optional().describe("Project name or id (defaults to active project)")
+        simulator: z4.string().describe(SIMULATOR_ARG_DESCRIPTION),
+        project: z4.string().optional().describe("Project name or id (defaults to active project)")
       }
     },
     async ({ simulator, project }) => guard(async () => {
@@ -322,70 +1165,402 @@ function registerDataTools(server) {
     {
       annotations: { readOnlyHint: true },
       title: "List hardware",
-      description: "List physical OCPP hardware devices in the active project's sim world.",
+      description: "List real chargers registered as hardware in the active project's sim world.",
       inputSchema: {
-        search: z3.string().optional().describe("Filter by serial number / model"),
+        search: z4.string().optional().describe("Filter by serial number / model"),
         ...paginationArgs,
-        project: z3.string().optional().describe("Project name or id (defaults to active project)")
+        project: z4.string().optional().describe("Project name or id (defaults to active project)")
       }
     },
-    async ({ search, page, pageSize, project }) => guard(async () => {
+    async ({ search, page: page2, pageSize, project }) => guard(async () => {
       const ctx = await resolveSimWorld(project);
       const result = await sdk().hardware.list({
         deviceScopeId: ctx.deviceScopeId,
         searchValue: search,
-        pagination: pagination(page, pageSize)
+        pagination: pagination(page2, pageSize)
       });
       return ok(
-        pageSummary("hardware device(s)", result?.records?.length ?? 0, result?.pageInfo),
+        pageSummary("hardware record(s)", result?.records?.length ?? 0, result?.pageInfo),
         result
       );
     })
   );
+  server.registerTool(
+    "get_hardware",
+    {
+      annotations: { readOnlyHint: true },
+      title: "Get hardware",
+      description: "Get hardware details and live status. endpoint.uri is the Timetick CSMS URL to configure on the physical charger; networkStatus shows whether it has connected.",
+      inputSchema: {
+        hardwareId: z4.string().describe("Hardware id (see list_hardware)")
+      }
+    },
+    async ({ hardwareId }) => guard(async () => {
+      const device = await sdk().hardware.get(hardwareId);
+      if (!device) return ok(`No hardware found with id ${hardwareId}.`);
+      return ok(`Hardware ${device.serialNumber} (id: ${hardwareId}).`, device);
+    })
+  );
   server.registerTool(
     "list_actions",
     {
       annotations: { readOnlyHint: true },
-      title: "List actions (test steps)",
-      description: "List available actions (steps) you can use to build a test \u2014 e.g. 'Power On Charger', 'Plug In Connector', 'Charge a Vehicle'. Filter by protocol. Each action lists its arguments: the name, whether it is required (allowNull false), and any default.",
+      title: "List test steps",
+      description: "List the steps you can use to build a test, for one protocol. kind 'charger-side' is something that happens at the charger, such as 'Plug In Connector'; 'remote' is a Remote: step, a command sent by the CSMS. Each step lists its arguments with type, required flag and default. get_action shows nested argument details.",
       inputSchema: {
-        protocol: protocolEnum.optional(),
-        search: z3.string().optional().describe("Filter by action name"),
+        protocol: protocolEnum,
+        search: z4.string().optional().describe("Filter by step name"),
         ...paginationArgs,
-        project: z3.string().optional().describe("Project name or id (defaults to active project)")
+        project: z4.string().optional().describe("Project name or id (defaults to active project)")
       }
     },
-    async ({ protocol, search, page, pageSize, project }) => guard(async () => {
+    async ({ protocol, search, page: page2, pageSize, project }) => guard(async () => {
       const ctx = await resolveSimWorld(project);
       const result = await sdk().actions.list({
         simWorldId: ctx.simWorldId,
         searchValue: search,
-        filters: { isSystem: true, deviceType: "CHARGER", ...protocol ? { protocol } : {} },
-        pagination: pagination(page, pageSize, 100)
+        filters: { protocol },
+        pagination: pagination(page2, pageSize, 100)
       });
-      const actions = (result?.records ?? []).map((a) => ({
-        name: a?.name,
-        description: a?.description ?? void 0,
-        args: summarizeArgs(a?.params)
-      }));
-      return ok(pageSummary("action(s)", actions.length, result?.pageInfo), actions);
+      const actions = (result?.records ?? []).filter((a) => a != null).map(summarizeAction);
+      return ok(pageSummary("step(s)", actions.length, result?.pageInfo), actions);
     })
   );
-}
+  server.registerTool(
+    "get_action",
+    {
+      annotations: { readOnlyHint: true },
+      title: "Get test step",
+      description: "Full definition of one step: the argument schema of each of its operations, with nested fields such as chargingProfile, its preset values and its default expected results.",
+      inputSchema: {
+        actionName: z4.string().describe("Step name, e.g. 'Remote: Set Charging Profile'"),
+        protocol: protocolEnum,
+        project: z4.string().optional().describe("Project name or id (defaults to active project)")
+      }
+    },
+    async ({ actionName, protocol, project }) => guard(async () => {
+      const ctx = await resolveSimWorld(project);
+      const action = findAction(await loadActionCatalog(ctx.simWorldId, protocol), protocol, actionName);
+      return ok(`Step "${action.name}".`, {
+        ...summarizeAction(action),
+        operations: (action.actionOperations ?? []).map((operation) => ({
+          preset: operation.preset,
+          schema: operation.formTemplate?.schema ?? operation.operation?.formTemplate?.schema ?? null,
+          expectedResults: operation.expectedResults
+        }))
+      });
+    })
+  );
+  server.registerTool(
+    "list_expected_result_commands",
+    {
+      annotations: { readOnlyHint: true },
+      title: "List expected-result commands",
+      description: "List the OCPP messages a step's expectedResults can check. Pass `command` to get the request and response fields of one message.",
+      inputSchema: {
+        protocol: protocolEnum,
+        command: z4.string().optional().describe("OCPP message name, e.g. 'Authorize'")
+      }
+    },
+    async ({ protocol, command }) => guard(async () => {
+      const configs = await sdk().actions.listExpectedResultConfigs(protocol) ?? [];
+      if (!command) {
+        return ok(`${configs.length} command(s) for ${protocol}: ${configs.map((c) => c.name).join(", ")}.`);
+      }
+      const config = configs.find((c) => c.name.toLowerCase() === command.toLowerCase());
+      if (!config) return fail(`No expected-result command "${command}" for ${protocol}.`);
+      return ok(`Fields of ${config.name}.`, { request: config.request.schema, response: config.response.schema });
+    })
+  );
+  server.registerTool(
+    "create_hardware",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+      title: "Create hardware",
+      description: "Register a real charger under test. Hardware connects to Timetick's CSMS, so give it a TIMETICK endpoint; get_hardware then shows the URL to configure on the charger. Run tests on it with run_test's `hardware` argument.",
+      inputSchema: {
+        serialNumber: z4.string().describe("Serial number; the charge point identity on Timetick's CSMS"),
+        model: z4.string().describe("Model name"),
+        manufacturer: z4.string().describe("Manufacturer name"),
+        firmwareVersion: z4.string(),
+        protocol: z4.enum(["OCPP_1_6", "OCPP_2_0_1"]),
+        year: z4.number().int().optional().describe("Manufacturing year"),
+        month: z4.number().int().min(1).max(12).optional().describe("Manufacturing month"),
+        endpointId: z4.string().describe("TIMETICK endpoint it connects to (see list_endpoints)"),
+        modelId: z4.string().describe("Model with the charger's connectors (see list_models)"),
+        project: z4.string().optional().describe("Project name or id (defaults to active project)")
+      }
+    },
+    async ({ serialNumber, model, manufacturer, firmwareVersion, protocol, year, month, endpointId, modelId, project }) => guard(async () => {
+      const ctx = await resolveSimWorld(project);
+      const device = await sdk().hardware.create({
+        deviceScopeId: ctx.deviceScopeId,
+        serialNumber,
+        model,
+        manufacturer,
+        firmwareVersion,
+        type: "CHARGER",
+        protocol,
+        year,
+        month,
+        endpointId,
+        chargerModelId: modelId
+      });
+      return ok(
+        `Created hardware (id: ${device?.id}). Configure the charger to connect to ${device?.endpoint?.uri ?? "its endpoint (see get_hardware)"}.`,
+        device
+      );
+    })
+  );
+  server.registerTool(
+    "update_hardware",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+      title: "Update hardware",
+      description: "Update hardware details or its endpoint.",
+      inputSchema: {
+        hardwareId: z4.string().describe("Hardware id (see list_hardware)"),
+        serialNumber: z4.string().optional(),
+        model: z4.string().optional(),
+        manufacturer: z4.string().optional(),
+        firmwareVersion: z4.string().optional(),
+        endpointId: z4.string().optional(),
+        project: z4.string().optional().describe("Project name or id (defaults to active project)")
+      }
+    },
+    async ({ hardwareId, serialNumber, model, manufacturer, firmwareVersion, endpointId, project }) => guard(async () => {
+      const ctx = await resolveSimWorld(project);
+      const current = await sdk().hardware.get(hardwareId);
+      if (!current) return fail(`No hardware found with id ${hardwareId}.`);
+      const device = await sdk().hardware.update({
+        id: hardwareId,
+        tags: (current.tags ?? []).map(({ id, name, color }) => ({ id, name, color })),
+        deviceScopeId: ctx.deviceScopeId,
+        serialNumber,
+        model,
+        manufacturer,
+        firmwareVersion,
+        endpointId
+      });
+      return ok(`Updated hardware (id: ${hardwareId}).`, device);
+    })
+  );
+  server.registerTool(
+    "delete_hardware",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true },
+      title: "Delete hardware",
+      description: "Permanently delete a hardware record.",
+      inputSchema: {
+        hardwareId: z4.string().describe("Hardware id (see list_hardware)")
+      }
+    },
+    async ({ hardwareId }) => guard(async () => {
+      await sdk().hardware.delete(hardwareId);
+      return ok(`Deleted hardware ${hardwareId}.`);
+    })
+  );
+}
 
 // src/tools/simulators.ts
-import { z as z4 } from "zod";
-async function runOnSimulator(project, simulator, actionName, args = []) {
-  const { ctx, sim } = await resolveSimulatorTarget(simulator, project);
-  const actionId = await resolveActionId(ctx.simWorldId, sim.protocol, actionName);
+import { z as z5 } from "zod";
+import { buildOperationSubmissions } from "@timetick/sdk";
+var protocolEnum2 = z5.enum(["OCPP_1_6", "OCPP_2_0_1"]);
+async function runStep(target, actionName, args = {}) {
+  const run = await resolveRunTarget(target);
+  const action = await resolveAction(run.ctx.simWorldId, run.protocol, actionName);
   const status = await sdk().testRuns.runAction({
-    chargerId: sim.id,
-    action: { requirementKey: "1", stream: 1, order: 1, actionId, args }
+    ...run.kind === "SIMULATOR" ? { chargerId: run.id } : { deviceId: run.id },
+    action: {
+      requirementKey: "1",
+      stream: 1,
+      order: 1,
+      actionId: action.id,
+      operationSubmissions: buildOperationSubmissions(action, args)
+    }
   });
-  return { sim, actionName, status };
+  return { run, status };
 }
+async function modelOcppConfigId(modelId) {
+  const model = await sdk().models.get(modelId);
+  return model?.ocppConfig?.id ?? void 0;
+}
+var CREATE_POLL_ATTEMPTS = 8;
+var CREATE_POLL_DELAY_MS = 2e3;
 function registerSimulatorTools(server) {
-  const projectArg = z4.string().optional().describe("Project name or id (defaults to active project)");
+  const projectArg = z5.string().optional().describe("Project name or id (defaults to active project)");
+  server.registerTool(
+    "create_simulator",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+      title: "Create simulator",
+      description: "Create a simulator (virtual charger) from a model. Needs a model (list_models / create_model) and an endpoint (list_endpoints / create_endpoint). After creating, boot it with power_on_simulator and confirm it connects with get_simulator.",
+      inputSchema: {
+        baseName: z5.string().describe("Simulator name (letters, digits, _ and -). It is the charge point identity the CSMS sees."),
+        modelId: z5.string().describe("Model id (see list_models)"),
+        endpointId: z5.string().describe("Endpoint id to connect to (see list_endpoints)"),
+        protocol: protocolEnum2,
+        ocppConfigId: z5.string().optional().describe("OCPP config to attach (default: the model's; see list_ocpp_configs)"),
+        lat: z5.number().optional().describe("Map location latitude (default 52.3676)"),
+        lng: z5.number().optional().describe("Map location longitude (default 4.9041)"),
+        autoPowerOff: z5.boolean().optional().describe("Power the simulator off automatically when idle"),
+        autoPowerOffTimeout: z5.number().optional().describe("Auto power-off timeout in seconds"),
+        project: projectArg
+      }
+    },
+    async ({ baseName, modelId, endpointId, protocol, ocppConfigId, lat, lng, autoPowerOff, autoPowerOffTimeout, project }) => guard(async () => {
+      const ctx = await resolveSimWorld(project);
+      const config = ocppConfigId ?? await modelOcppConfigId(modelId);
+      let simulator = await sdk().simulators.create({
+        baseName,
+        simWorldId: ctx.simWorldId,
+        chargerModelId: modelId,
+        endpointId,
+        protocol,
+        location: { lat: lat ?? 52.3676, lng: lng ?? 4.9041 },
+        ocppConfigId: config,
+        autoPowerOff,
+        autoPowerOffTimeout
+      });
+      for (let attempt = 0; !simulator && attempt < CREATE_POLL_ATTEMPTS; attempt++) {
+        await new Promise((resolve) => setTimeout(resolve, CREATE_POLL_DELAY_MS));
+        const page2 = await sdk().simulators.list({
+          simWorldId: ctx.simWorldId,
+          searchValue: baseName,
+          filters: { endpointIds: [endpointId] }
+        });
+        simulator = page2?.records?.find((record) => record?.baseName === baseName);
+      }
+      if (!simulator) {
+        return ok(
+          `Creation of simulator "${baseName}" is queued but it has not appeared yet. Check with list_simulators (search: "${baseName}") in a moment, then boot it with power_on_simulator.`
+        );
+      }
+      return ok(
+        `Created simulator "${simulator.baseName}" (id: ${simulator.id}). Boot it with power_on_simulator when ready.`,
+        simulator
+      );
+    })
+  );
+  server.registerTool(
+    "create_simulators_bulk",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+      title: "Create simulators (bulk)",
+      description: "Create many simulators at once from a model, named <baseName>_1 \u2026 _N. Runs in the background, so they appear in list_simulators shortly after. For load-testing fleets. Same requirements as create_simulator: model and endpoint.",
+      inputSchema: {
+        baseName: z5.string().describe("Name base: simulators are created as <baseName>_1, _2, \u2026"),
+        modelId: z5.string().describe("Model id (see list_models)"),
+        endpointId: z5.string().describe("Endpoint id to connect to (see list_endpoints)"),
+        protocol: protocolEnum2,
+        amount: z5.number().int().min(1).describe("How many simulators to create"),
+        startNumber: z5.number().int().min(1).optional().describe("First number suffix (default 1)"),
+        ocppConfigId: z5.string().optional().describe("OCPP config to attach (see list_ocpp_configs)"),
+        lat: z5.number().optional().describe("Map location latitude (default 52.3676)"),
+        lng: z5.number().optional().describe("Map location longitude (default 4.9041)"),
+        project: projectArg
+      }
+    },
+    async ({ baseName, modelId, endpointId, protocol, amount, startNumber, ocppConfigId, lat, lng, project }) => guard(async () => {
+      const ctx = await resolveSimWorld(project);
+      const config = ocppConfigId ?? await modelOcppConfigId(modelId);
+      await sdk().simulators.createBulk({
+        baseName,
+        simWorldId: ctx.simWorldId,
+        chargerModelId: modelId,
+        endpointId,
+        protocol,
+        chargersAmount: amount,
+        startNumber,
+        location: { lat: lat ?? 52.3676, lng: lng ?? 4.9041 },
+        ocppConfigId: config
+      });
+      return ok(
+        `Queued creation of ${amount} simulator(s) named ${amount === 1 ? baseName : `${baseName}_\u2026`}. They appear in list_simulators (search: "${baseName}") shortly.`
+      );
+    })
+  );
+  server.registerTool(
+    "update_simulator",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+      title: "Update simulator",
+      description: "Rename a simulator or move it to another model or endpoint.",
+      inputSchema: {
+        simulator: z5.string().describe(SIMULATOR_ARG_DESCRIPTION),
+        baseName: z5.string().optional().describe("New name"),
+        modelId: z5.string().optional().describe("Move to another model (see list_models)"),
+        endpointId: z5.string().optional().describe("Move to another endpoint (see list_endpoints)"),
+        protocol: protocolEnum2.optional(),
+        project: projectArg
+      }
+    },
+    async ({ simulator, baseName, modelId, endpointId, protocol, project }) => guard(async () => {
+      const { ctx, sim } = await resolveSimulatorTarget(simulator, project);
+      const current = await sdk().simulators.get(sim.id);
+      const updated = await sdk().simulators.update({
+        id: sim.id,
+        tags: (current?.tags ?? []).map(({ id, name, color }) => ({ id, name, color })),
+        simWorldId: ctx.simWorldId,
+        baseName,
+        chargerModelId: modelId,
+        endpointId,
+        protocol
+      });
+      return ok(`Updated simulator ${sim.baseName} (id: ${sim.id}).`, updated);
+    })
+  );
+  server.registerTool(
+    "delete_simulator",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true },
+      title: "Delete simulator",
+      description: "Permanently delete a simulator and its history. There is no undo.",
+      inputSchema: {
+        simulator: z5.string().describe(SIMULATOR_ARG_DESCRIPTION),
+        project: projectArg
+      }
+    },
+    async ({ simulator, project }) => guard(async () => {
+      const { sim } = await resolveSimulatorTarget(simulator, project);
+      await sdk().simulators.delete(sim.id);
+      return ok(`Deleted simulator ${sim.baseName} (id: ${sim.id}).`);
+    })
+  );
+  server.registerTool(
+    "update_simulator_ocpp_key",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+      title: "Set a simulator's OCPP key",
+      description: "Change one OCPP configuration value on one simulator, e.g. HeartbeatInterval. get_simulator_config lists the current keys. This is the usual fix before a rerun; update_ocpp_config changes a shared config template instead.",
+      inputSchema: {
+        simulator: z5.string().describe(SIMULATOR_ARG_DESCRIPTION),
+        key: z5.string().describe("OCPP 1.6 key, or OCPP 2.0.1 variable name"),
+        component: z5.string().optional().describe("OCPP 2.0.1 component name, when the variable name is ambiguous"),
+        evseId: z5.number().int().optional().describe("OCPP 2.0.1 EVSE id, when the variable exists per EVSE"),
+        componentInstance: z5.string().optional().describe("OCPP 2.0.1 component instance, when there are several"),
+        variableInstance: z5.string().optional().describe("OCPP 2.0.1 variable instance, when there are several"),
+        value: z5.string(),
+        project: projectArg
+      }
+    },
+    async ({ simulator, key, component, evseId, componentInstance, variableInstance, value, project }) => guard(async () => {
+      const { sim } = await resolveSimulatorTarget(simulator, project);
+      const items = await sdk().simulators.getOcppConfigItems(sim.id) ?? [];
+      const matches = items.filter(
+        (item) => (item.key ?? item.variableName) === key && (!component || item.componentName === component) && (evseId === void 0 || item.evseId === evseId) && (componentInstance === void 0 || item.componentInstance === componentInstance) && (variableInstance === void 0 || item.variableInstance === variableInstance)
+      );
+      if (matches.length === 0) return fail(`${sim.baseName} has no OCPP key "${key}".`);
+      if (matches.length > 1) {
+        const places = matches.map(
+          (item) => `${item.componentName} (EVSE ${item.evseId ?? "-"}, component instance ${item.componentInstance ?? "-"}, variable instance ${item.variableInstance ?? "-"})`
+        ).join(", ");
+        return fail(`"${key}" exists in several places: ${places}. Narrow it down with the matching arguments.`);
+      }
+      await sdk().simulators.updateOcppConfigItem({ id: matches[0].id, simulatorId: sim.id, value });
+      return ok(`Set ${key} to "${value}" on ${sim.baseName} (id: ${sim.id}).`);
+    })
+  );
   server.registerTool(
     "power_on_simulator",
     {
@@ -393,13 +1568,13 @@ function registerSimulatorTools(server) {
       title: "Power on simulator",
       description: "Power on a simulator (boots it and connects it to the OCPP server).",
       inputSchema: {
-        simulator: z4.string().describe(SIMULATOR_ARG_DESCRIPTION),
+        simulator: z5.string().describe(SIMULATOR_ARG_DESCRIPTION),
         project: projectArg
       }
     },
     async ({ simulator, project }) => guard(async () => {
-      const { sim, status } = await runOnSimulator(project, simulator, "Power On Charger");
-      return ok(`Powered on ${sim.baseName} (id: ${sim.id}).`, { status });
+      const { run, status } = await runStep({ simulator, project }, "Power On Charger");
+      return ok(`Powered on ${run.name} (id: ${run.id}). Check networkStatus with get_simulator.`, { status });
     })
   );
   server.registerTool(
@@ -409,60 +1584,115 @@ function registerSimulatorTools(server) {
       title: "Power off simulator",
       description: "Power off a simulator.",
       inputSchema: {
-        simulator: z4.string().describe(SIMULATOR_ARG_DESCRIPTION),
+        simulator: z5.string().describe(SIMULATOR_ARG_DESCRIPTION),
         project: projectArg
       }
     },
     async ({ simulator, project }) => guard(async () => {
-      const { sim, status } = await runOnSimulator(project, simulator, "Power Off Charger");
-      return ok(`Powered off ${sim.baseName} (id: ${sim.id}).`, { status });
+      const { run, status } = await runStep({ simulator, project }, "Power Off Charger");
+      return ok(`Powered off ${run.name} (id: ${run.id}).`, { status });
     })
   );
   server.registerTool(
-    "run_simulator_action",
+    "run_step",
     {
       annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true },
-      title: "Run simulator action",
-      description: "Run a single named action against a simulator \u2014 e.g. 'Reset Charger', 'Plug In Connector', 'Plug Out Connector'. Use list_actions to discover names and required args. Args are passed as key/value pairs (e.g. connectorId=1).",
+      title: "Run a single step",
+      description: "Run one step right now on a simulator or hardware, e.g. 'Reset Charger', 'Plug In Connector', 'Remote: Reset'. Use list_actions to discover names and arguments.",
       inputSchema: {
-        simulator: z4.string().describe(SIMULATOR_ARG_DESCRIPTION),
-        actionName: z4.string().describe("Exact action name, e.g. 'Reset Charger'"),
-        args: z4.array(z4.object({ key: z4.string(), value: z4.string() })).optional().describe("Action arguments as key/value pairs"),
+        simulator: z5.string().optional().describe(SIMULATOR_ARG_DESCRIPTION),
+        hardware: z5.string().optional().describe("Hardware serial number or id (instead of simulator)"),
+        actionName: z5.string().describe("Step name, e.g. 'Reset Charger'"),
+        args: z5.record(z5.string(), z5.unknown()).optional().describe("Step arguments, e.g. { connectorId: 1 }"),
         project: projectArg
       }
     },
-    async ({ simulator, actionName, args, project }) => guard(async () => {
-      const { sim, status } = await runOnSimulator(project, simulator, actionName, args ?? []);
-      return ok(`Ran "${actionName}" on ${sim.baseName} (id: ${sim.id}).`, { status });
+    async ({ simulator, hardware, actionName, args, project }) => guard(async () => {
+      const { run, status } = await runStep({ simulator, hardware, project }, actionName, args);
+      return ok(`Ran "${actionName}" on ${run.name} (id: ${run.id}).`, { status });
     })
   );
 }
 
 // src/tools/tests.ts
-import { z as z5 } from "zod";
-var protocolEnum2 = z5.enum(["OCPP_1_6", "OCPP_2_0_1"]);
+import { z as z6 } from "zod";
+import { buildOperationSubmissions as buildOperationSubmissions2 } from "@timetick/sdk";
+var protocolEnum3 = z6.enum(["OCPP_1_6", "OCPP_2_0_1"]);
+var DEFAULT_SLOT = "A";
+var stepSchema = z6.object({
+  actionName: z6.string().describe("Step name from list_actions, e.g. 'Power On Charger'"),
+  args: z6.record(z6.string(), z6.unknown()).optional().describe("Step arguments, e.g. { connectorId: 1 }"),
+  stream: z6.number().int().min(1).optional().describe("Parallel column, default 1. Columns start together; steps within a column run in order."),
+  slot: z6.string().optional().describe("Which slot runs the step, when the test has several"),
+  stopTestOnFailure: z6.boolean().optional().describe("Fail the whole test if this step fails. Default false: the test continues."),
+  expectedResults: z6.array(
+    z6.object({
+      command: z6.string().describe("OCPP message, e.g. 'Authorize' (see list_expected_result_commands)"),
+      request: z6.record(z6.string(), z6.unknown()).optional().describe("Request fields to check"),
+      response: z6.record(z6.string(), z6.unknown()).optional().describe("Response fields to check, e.g. { status: 'Accepted' }")
+    })
+  ).optional().describe("What must happen for the step to pass. Omit to use the step's defaults."),
+  strict: z6.boolean().optional().describe("Fail the step on any OCPP message not listed in expectedResults. For certification-style tests.")
+});
+async function buildSteps(simWorldId, steps, slots, defaultSlot) {
+  const catalogs = /* @__PURE__ */ new Map();
+  const orderInStream = /* @__PURE__ */ new Map();
+  const built = [];
+  for (const step of steps) {
+    const slotName = step.slot ?? defaultSlot;
+    const slot = slotName ? slots.get(slotName) : void 0;
+    if (!slot) {
+      throw new Error(`Step "${step.actionName}" needs \`slot\`, one of: ${[...slots.keys()].join(", ")}.`);
+    }
+    let catalog = catalogs.get(slot.protocol);
+    if (!catalog) {
+      catalog = await loadActionCatalog(simWorldId, slot.protocol);
+      catalogs.set(slot.protocol, catalog);
+    }
+    const action = findAction(catalog, slot.protocol, step.actionName);
+    const stream = step.stream ?? 1;
+    const order = (orderInStream.get(stream) ?? 0) + 1;
+    orderInStream.set(stream, order);
+    built.push({
+      order,
+      stream,
+      actionId: action.id,
+      requirementKey: slot.requirementKey,
+      ...step.stopTestOnFailure ? { onFailStrategy: "failScenario" } : {},
+      operationSubmissions: buildOperationSubmissions2(action, step.args, {
+        strictMode: step.strict,
+        expectedResults: step.expectedResults?.map((result) => ({
+          commandName: result.command,
+          requestPayload: result.request,
+          responsePayload: result.response
+        }))
+      })
+    });
+  }
+  return built;
+}
 function registerTestTools(server) {
-  const projectArg = z5.string().optional().describe("Project name or id (defaults to active project)");
+  const projectArg = z6.string().optional().describe("Project name or id (defaults to active project)");
   server.registerTool(
     "list_tests",
     {
       annotations: { readOnlyHint: true },
       title: "List tests",
-      description: "List tests (scenarios) in the active project's sim world.",
+      description: "List tests in the active project's sim world.",
       inputSchema: {
-        protocol: protocolEnum2.optional(),
-        search: z5.string().optional().describe("Filter by test name"),
+        protocol: protocolEnum3.optional(),
+        search: z6.string().optional().describe("Filter by test name"),
         ...paginationArgs,
         project: projectArg
       }
     },
-    async ({ protocol, search, page, pageSize, project }) => guard(async () => {
+    async ({ protocol, search, page: page2, pageSize, project }) => guard(async () => {
       const ctx = await resolveSimWorld(project);
       const result = await sdk().tests.list({
         simWorldId: ctx.simWorldId,
         searchValue: search,
         filters: protocol ? { protocol } : void 0,
-        pagination: pagination(page, pageSize)
+        pagination: pagination(page2, pageSize)
       });
       return ok(pageSummary("test(s)", result?.records?.length ?? 0, result?.pageInfo), result);
     })
@@ -472,15 +1702,63 @@ function registerTestTools(server) {
     {
       annotations: { readOnlyHint: true },
       title: "Get test",
-      description: "Get a test by id, including its device requirements.",
+      description: "Get a test by id, with its slots, steps, arguments and expected results.",
       inputSchema: {
-        testId: z5.string().describe("Test (scenario) id")
+        testId: z6.string().describe("Test id")
       }
     },
     async ({ testId }) => guard(async () => {
       const test = await sdk().tests.get(testId);
       if (!test) return ok(`No test found with id ${testId}.`);
-      return ok(`Test ${test.name} (id: ${testId}).`, test);
+      const { requirements, ...rest } = test;
+      return ok(`Test ${test.name} (id: ${testId}).`, {
+        ...rest,
+        slots: requirements.map((requirement) => ({
+          id: requirement.id,
+          protocol: requirement.params.find((param) => param.key === "protocol")?.value
+        }))
+      });
+    })
+  );
+  server.registerTool(
+    "list_test_templates",
+    {
+      annotations: { readOnlyHint: true },
+      title: "List test templates",
+      description: "List ready-made tests, including protocol test cases such as 'TC_G_06_CSMS: Change Availability'. Search here before building a protocol test by hand; copy one with create_test_from_template.",
+      inputSchema: {
+        protocol: protocolEnum3.optional(),
+        search: z6.string().optional().describe("Filter by name, e.g. 'CSMS' or 'TC_G'"),
+        ...paginationArgs,
+        project: projectArg
+      }
+    },
+    async ({ protocol, search, page: page2, pageSize, project }) => guard(async () => {
+      const ctx = await resolveSimWorld(project);
+      const result = await sdk().tests.listTemplates({
+        simWorldId: ctx.simWorldId,
+        searchValue: search,
+        filters: protocol ? { protocol } : void 0,
+        pagination: pagination(page2, pageSize)
+      });
+      return ok(pageSummary("template(s)", result?.records?.length ?? 0, result?.pageInfo), result);
+    })
+  );
+  server.registerTool(
+    "create_test_from_template",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+      title: "Create test from template",
+      description: "Copy a template into the project as a new test you can run and edit.",
+      inputSchema: {
+        templateId: z6.string().describe("Template id (see list_test_templates)"),
+        project: projectArg
+      }
+    },
+    async ({ templateId, project }) => guard(async () => {
+      const ctx = await resolveSimWorld(project);
+      const test = await sdk().tests.createFromTemplate(templateId, ctx.simWorldId);
+      return ok(`Created test "${test?.name}" (id: ${test?.id}).`, test);
     })
   );
   server.registerTool(
@@ -488,91 +1766,251 @@ function registerTestTools(server) {
     {
       annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
       title: "Create test",
-      description: "Create a test from an ordered list of steps. Each step references an action by name (use list_actions to discover them) plus optional key/value args. The steps run in order against a single simulator. Example steps: 'Power On Charger', 'Plug In Connector', 'Use RFID Card', 'Charge a Vehicle', 'Plug Out Connector', 'Power Off Charger'.",
+      description: "Create a test from steps (use list_actions for names and arguments). Example: 'Power On Charger', 'Plug In Connector', 'Use RFID Card', 'Charge a Vehicle', 'Plug Out Connector', 'Power Off Charger'. Steps may run in parallel columns (stream). One slot by default; pass `slots` when several simulators must interact, such as site load sharing. To run the same test on many simulators use run_stress_test instead.",
       inputSchema: {
-        name: z5.string().describe("Test name"),
-        protocol: protocolEnum2,
-        steps: z5.array(
-          z5.object({
-            actionName: z5.string().describe("Exact action name, e.g. 'Power On Charger'"),
-            args: z5.array(z5.object({ key: z5.string(), value: z5.string() })).optional().describe("Action arguments as key/value pairs")
-          })
-        ).min(1).describe("Ordered list of steps"),
+        name: z6.string().describe("Test name"),
+        description: z6.string().optional(),
+        protocol: protocolEnum3.optional().describe("Protocol of the single slot; required unless `slots` is given"),
+        slots: z6.array(z6.object({ name: z6.string().describe("Slot name, e.g. 'A'"), protocol: protocolEnum3 })).min(1).optional().describe("Slots for a test with several simulators or hardware"),
+        steps: z6.array(stepSchema).min(1).describe("Ordered list of steps"),
         project: projectArg
       }
     },
-    async ({ name, protocol, steps, project }) => guard(async () => {
+    async ({ name, description, protocol, slots, steps, project }) => guard(async () => {
+      const declared = slots ?? (protocol ? [{ name: DEFAULT_SLOT, protocol }] : []);
+      if (declared.length === 0) return fail("Pass `protocol`, or `slots` for a test with several simulators or hardware.");
       const ctx = await resolveSimWorld(project);
-      const actions = [];
-      for (let i = 0; i < steps.length; i++) {
-        const actionId = await resolveActionId(ctx.simWorldId, protocol, steps[i].actionName);
-        actions.push({
-          order: i + 1,
-          stream: 1,
-          actionId,
-          requirementKey: "charger",
-          args: steps[i].args ?? []
-        });
-      }
+      const slotMap = new Map(declared.map((slot) => [slot.name, { protocol: slot.protocol, requirementKey: slot.name }]));
+      const scenarioActions = await buildSteps(
+        ctx.simWorldId,
+        steps,
+        slotMap,
+        declared.length === 1 ? declared[0].name : void 0
+      );
       const test = await sdk().tests.create({
         simWorldId: ctx.simWorldId,
         name,
+        description,
         deviceType: "CHARGER",
-        requirements: [
-          { key: "charger", type: "CHARGER", params: [{ key: "protocol", value: protocol }] }
-        ],
-        actions
+        requirements: declared.map((slot) => ({
+          key: slot.name,
+          type: "CHARGER",
+          params: [{ key: "protocol", value: slot.protocol }]
+        })),
+        scenarioActions
       });
       return ok(`Created test "${name}" (id: ${test?.id}).`, test);
     })
   );
+  server.registerTool(
+    "update_test",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+      title: "Update test",
+      description: "Update a test's name, description, priority or steps. `steps` replaces all steps; each step's `slot` is a slot id from get_test, and can be left out when the test has one slot.",
+      inputSchema: {
+        testId: z6.string().describe("Test id"),
+        name: z6.string().optional(),
+        description: z6.string().optional(),
+        priority: z6.enum(["URGENT", "HIGH", "MEDIUM", "LOW"]).optional(),
+        steps: z6.array(stepSchema).min(1).optional().describe("Replaces all steps"),
+        project: z6.string().optional().describe("Project name or id the test belongs to (defaults to active project)")
+      }
+    },
+    async ({ testId, name, description, priority, steps, project }) => guard(async () => {
+      const ctx = await resolveSimWorld(project);
+      const existing = await sdk().tests.get(testId);
+      if (!existing) return fail(`No test found with id ${testId}.`);
+      let stepChanges = {};
+      if (steps) {
+        const requirements = existing.requirements;
+        const slotMap = new Map(
+          requirements.map((requirement) => {
+            const slotProtocol = requirement.params.find((param) => param.key === "protocol")?.value;
+            if (!slotProtocol) throw new Error(`Slot ${requirement.id} of test ${testId} has no protocol.`);
+            return [requirement.id, { protocol: slotProtocol, requirementKey: requirement.id }];
+          })
+        );
+        stepChanges = {
+          scenarioActions: await buildSteps(
+            ctx.simWorldId,
+            steps,
+            slotMap,
+            requirements.length === 1 ? requirements[0].id : void 0
+          ),
+          requirements: requirements.map((requirement) => ({
+            key: requirement.id,
+            type: requirement.type,
+            params: requirement.params.map(({ key, value }) => ({ key, value }))
+          }))
+        };
+      }
+      const test = await sdk().tests.update({
+        id: testId,
+        simWorldId: ctx.simWorldId,
+        name,
+        description,
+        priority,
+        tags: (existing.tags ?? []).map(({ id, name: tagName, color }) => ({ id, name: tagName, color })),
+        checklistTemplateItems: (existing.checklistTemplateItems ?? []).map(({ order, description: description2 }) => ({
+          order,
+          description: description2 ?? ""
+        })),
+        ...stepChanges
+      });
+      return ok(`Updated test (id: ${testId}).`, test);
+    })
+  );
+  server.registerTool(
+    "delete_test",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true },
+      title: "Delete test",
+      description: "Permanently delete a test. There is no undo.",
+      inputSchema: {
+        testId: z6.string().describe("Test id")
+      }
+    },
+    async ({ testId }) => guard(async () => {
+      await sdk().tests.delete(testId);
+      return ok(`Deleted test ${testId}.`);
+    })
+  );
 }
 
 // src/tools/test-runs.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
+var conflictEnum = z7.enum(["FAIL", "RESCHEDULE", "FORCE_RUN"]);
+var CONFLICT_DESCRIPTION = "When something is busy. FAIL (default) starts nothing, RESCHEDULE uses the first free time, FORCE_RUN stops the runs holding it, so ask the user before using it.";
+function withoutInternalGroup(run) {
+  if (run.category === "STRESS_TEST") return run;
+  const { groupId: _groupId, ...rest } = run;
+  return rest;
+}
+var SIMULATOR_PAGE_SIZE = 200;
+var FINISHED_STATUSES = /* @__PURE__ */ new Set(["COMPLETED", "FAILED", "SKIPPED"]);
+async function listSimulatorIds(simWorldId, selection) {
+  const ids = [];
+  for (let page2 = 1; ; page2++) {
+    const result = await sdk().simulators.list({
+      simWorldId,
+      searchValue: selection.search,
+      filters: { protocol: selection.protocol, tagIds: selection.tagIds },
+      pagination: { page: page2, pageSize: SIMULATOR_PAGE_SIZE }
+    });
+    const records = result?.records ?? [];
+    for (const record of records) if (record?.id) ids.push(record.id);
+    if (records.length === 0 || !result?.pageInfo?.hasNextPage) return ids;
+  }
+}
 function registerTestRunTools(server) {
-  const projectArg = z6.string().optional().describe("Project name or id (defaults to active project)");
+  const projectArg = z7.string().optional().describe("Project name or id (defaults to active project)");
   server.registerTool(
     "run_test",
     {
       annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
       title: "Run test",
-      description: "Run a test (scenario) on a simulator, starting immediately. Returns the test run id and status \u2014 poll with get_test_run to follow it. A simulator runs one test at a time; if it is busy this says so and starts nothing.",
+      description: "Run a test on a simulator or on hardware, now or at a set time. Returns the test run id and status; follow it with get_test_run. A simulator or hardware runs one test at a time: if it is busy this says so and starts nothing, unless onConflict says otherwise. A test with several slots needs `assignments`.",
       inputSchema: {
-        testId: z6.string().describe("Test (scenario) id to run"),
-        simulator: z6.string().describe(`${SIMULATOR_ARG_DESCRIPTION} to run the test on`),
+        testId: z7.string().describe("Test id to run"),
+        simulator: z7.string().optional().describe(SIMULATOR_ARG_DESCRIPTION),
+        hardware: z7.string().optional().describe("Hardware serial number or id (instead of simulator)"),
+        assignments: z7.array(
+          z7.object({
+            slotId: z7.string().describe("Slot id from get_test"),
+            simulator: z7.string().optional(),
+            hardware: z7.string().optional()
+          })
+        ).min(1).optional().describe("Which simulator or hardware fills each slot, for a test with several slots"),
+        speedup: z7.number().int().min(1).optional().describe("Time acceleration, e.g. 10 = 10x faster (default 1)"),
+        startAt: z7.string().optional().describe("ISO 8601 start time; omit to start now"),
+        onConflict: conflictEnum.optional().describe(CONFLICT_DESCRIPTION),
         project: projectArg
       }
     },
-    async ({ testId, simulator, project }) => guard(async () => {
-      const { ctx, sim } = await resolveSimulatorTarget(simulator, project);
+    async ({ testId, simulator, hardware, assignments, speedup, startAt, onConflict, project }) => guard(async () => {
       const test = await sdk().tests.get(testId);
-      const requirementId = test?.requirements?.[0]?.id;
-      if (!requirementId) return fail(`Test ${testId} has no device requirement to assign.`);
+      const requirements = test?.requirements ?? [];
+      if (requirements.length === 0) return fail(`Test ${testId} has no slot to assign.`);
+      const slots = assignments ?? [{ slotId: requirements[0].id, simulator, hardware }];
+      if (!assignments && requirements.length > 1) {
+        return fail(
+          `Test ${testId} has ${requirements.length} slots (${requirements.map((r) => r.id).join(", ")}). Pass \`assignments\` with a simulator or hardware for each.`
+        );
+      }
+      const assigned = slots.map((slot) => slot.slotId).sort().join(",");
+      const expected = requirements.map((requirement) => requirement.id).sort().join(",");
+      if (assigned !== expected) {
+        return fail(`Assign exactly one simulator or hardware to each slot of test ${testId}: ${expected}.`);
+      }
+      const targets = await Promise.all(
+        slots.map(async (slot) => ({
+          slotId: slot.slotId,
+          target: await resolveRunTarget({ simulator: slot.simulator, hardware: slot.hardware, project })
+        }))
+      );
+      for (const { slotId, target } of targets) {
+        const requirement = requirements.find((candidate) => candidate.id === slotId);
+        const protocol = requirement?.params.find((param) => param.key === "protocol")?.value;
+        if (protocol && protocol !== target.protocol) {
+          return fail(`${target.name} speaks ${target.protocol}, but slot ${slotId} of this test needs ${protocol}.`);
+        }
+      }
       const run = await sdk().testRuns.create({
         scenarioId: testId,
-        simWorldId: ctx.simWorldId,
-        scheduleMode: "NOW",
-        speedup: 1,
-        forceDelete: false,
-        requirementDevices: [
-          { requirementId, deviceId: sim.id, deviceMode: "SIMULATOR" }
-        ]
-      }).catch(async (err) => {
-        const message = err instanceof Error ? err.message : String(err);
-        if (!/conflict/i.test(message)) throw err;
-        const details = await sdk().simulators.get(sim.id).catch(() => null);
-        const blocking = details?.lastRun;
-        throw new Error(
-          `${sim.baseName} (id: ${sim.id}) is busy` + (blocking?.id ? ` with test run ${blocking.id} (${blocking.status})` : "") + `, so nothing was started. Stop that run with stop_test_run \u2014 the simulator is free once it stops \u2014 then run this test again.`
-        );
+        simWorldId: targets[0].target.ctx.simWorldId,
+        scheduleMode: startAt ? "DATETIME" : "NOW",
+        startTimestamp: startAt,
+        speedup: speedup ?? 1,
+        conflictResolution: onConflict,
+        requirementDevices: targets.map(({ slotId, target }) => ({
+          requirementId: slotId,
+          deviceId: target.id,
+          deviceMode: target.kind
+        }))
       });
       return ok(
-        `Started test "${test?.name}" on ${sim.baseName} \u2014 run id ${run?.id}, status ${run?.status}.`,
+        `Created run ${run?.id} of test "${test?.name}" on ${targets.map(({ target }) => target.name).join(", ")}, status ${run?.status}.`,
         run
       );
     })
   );
+  server.registerTool(
+    "complete_test_step",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+      title: "Complete a waiting step",
+      description: "Mark a waiting manual step as passed: a Remote: step on a simulator, or a charger-side step on hardware. Only needed for steps without expected results; those with expected results pass on their own. Ask the user whether the action really happened before calling this. stepId comes from get_test_run_details.",
+      inputSchema: {
+        stepId: z7.string().describe("Step id from get_test_run_details"),
+        project: projectArg
+      }
+    },
+    async ({ stepId, project }) => guard(async () => {
+      const ctx = await resolveSimWorld(project);
+      const status = await sdk().testRuns.completeManualStep(stepId, ctx.simWorldId);
+      if (status === "ERROR") return fail(`Step ${stepId} could not be marked as passed. Is it still waiting?`);
+      return ok(`Asked to mark step ${stepId} as passed (${status}). Confirm its status with get_test_run_details.`);
+    })
+  );
+  server.registerTool(
+    "fail_test_step",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+      title: "Fail a waiting step",
+      description: "Mark a waiting manual step as failed. stepId comes from get_test_run_details.",
+      inputSchema: {
+        stepId: z7.string().describe("Step id from get_test_run_details"),
+        project: projectArg
+      }
+    },
+    async ({ stepId, project }) => guard(async () => {
+      const ctx = await resolveSimWorld(project);
+      const status = await sdk().testRuns.failManualStep(stepId, ctx.simWorldId);
+      if (status === "ERROR") return fail(`Step ${stepId} could not be marked as failed. Is it still waiting?`);
+      return ok(`Asked to mark step ${stepId} as failed (${status}). Confirm its status with get_test_run_details.`);
+    })
+  );
   server.registerTool(
     "get_test_run",
     {
@@ -580,14 +2018,14 @@ function registerTestRunTools(server) {
       title: "Get test run",
       description: "Get a test run's status by id.",
       inputSchema: {
-        runId: z6.string().describe("Test run id")
+        runId: z7.string().describe("Test run id")
       }
     },
     async ({ runId }) => guard(async () => {
       const run = await sdk().testRuns.get(runId);
       if (!run) return ok(`No test run found with id ${runId}.`);
       const reason = run.failReason ? ` \u2014 ${run.failReason}` : "";
-      return ok(`Test run ${runId} ("${run.scenario?.name}"): ${run.status}${reason}.`, run);
+      return ok(`Test run ${runId} ("${run.scenario?.name}"): ${run.status}${reason}.`, withoutInternalGroup(run));
     })
   );
   server.registerTool(
@@ -601,13 +2039,16 @@ function registerTestRunTools(server) {
         project: projectArg
       }
     },
-    async ({ page, pageSize, project }) => guard(async () => {
+    async ({ page: page2, pageSize, project }) => guard(async () => {
       const ctx = await resolveSimWorld(project);
       const result = await sdk().testRuns.list({
         simWorldId: ctx.simWorldId,
-        pagination: pagination(page, pageSize)
+        pagination: pagination(page2, pageSize)
+      });
+      return ok(pageSummary("test run(s)", result?.records?.length ?? 0, result?.pageInfo), {
+        ...result,
+        records: (result?.records ?? []).map((record) => record && withoutInternalGroup(record))
       });
-      return ok(pageSummary("test run(s)", result?.records?.length ?? 0, result?.pageInfo), result);
     })
   );
   server.registerTool(
@@ -615,39 +2056,402 @@ function registerTestRunTools(server) {
     {
       annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true },
       title: "Stop test run",
-      description: "Shut down (stop) a running or scheduled test run by id.",
+      description: "Stop a running or scheduled test run. For a run in a stress test use stop_stress_test, and for a run in a test plan use stop_test_plan: stopping one such run would not stop the rest.",
       inputSchema: {
-        runId: z6.string().describe("Test run id")
+        runId: z7.string().describe("Test run id")
       }
     },
     async ({ runId }) => guard(async () => {
       const existing = await sdk().testRuns.get(runId);
       if (!existing) return fail(`No test run found with id ${runId}.`);
-      await sdk().testRuns.shutDown(runId);
+      if (FINISHED_STATUSES.has(String(existing.status))) {
+        return fail(`Test run ${runId} has already finished: it is ${existing.status}.`);
+      }
+      if (existing.category === "STRESS_TEST") {
+        return fail(`Test run ${runId} is part of stress test ${existing.groupId}. Use stop_stress_test.`);
+      }
+      if (existing.testPlanId) {
+        return fail(`Test run ${runId} is part of test plan ${existing.testPlanId}. Use stop_test_plan.`);
+      }
+      const stopped = await sdk().testRuns.shutDown(runId);
+      if (!stopped) return fail(`Test run ${runId} was not stopped: it is ${existing.status}.`);
       const after = await sdk().testRuns.get(runId);
       return ok(
-        `Shut down test run ${runId} (was ${existing.status}, now ${after?.status ?? "unknown"}).`,
-        after
+        `Stopped test run ${runId} (was ${existing.status}, now ${after?.status ?? "unknown"}).`,
+        after && withoutInternalGroup(after)
       );
     })
   );
-}
-
-// src/tools/support.ts
-import { z as z7 } from "zod";
-
-// src/logs-format.ts
-var DEFAULT_LOGS_LAST = "1h";
-var DEFAULT_LOGS_LIMIT = 200;
-var MAX_LOGS_LIMIT = 1e3;
-var PAYLOAD_MAX_CHARS = 500;
-var UNIT_MS = { s: 1e3, m: 6e4, h: 36e5, d: 864e5 };
-function parseDuration(value) {
-  const match = value.trim().match(/^(\d+)\s*([smhd])$/i);
-  if (!match) throw new Error(`Invalid duration "${value}". Use a number and a unit: 30m, 6h, 2d.`);
-  return Number(match[1]) * UNIT_MS[match[2].toLowerCase()];
-}
-function parseInstant(value, name) {
+  server.registerTool(
+    "update_test_run",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+      title: "Update test run",
+      description: "Change a scheduled test run's start time or speed-up factor. Only applies to runs that haven't started yet. To run on other simulators, delete it and use run_test.",
+      inputSchema: {
+        runId: z7.string().describe("Test run id"),
+        startAt: z7.string().optional().describe("New ISO 8601 start time"),
+        speedup: z7.number().int().min(1).optional().describe("Time acceleration factor, e.g. 10 = 10x faster"),
+        onConflict: conflictEnum.optional().describe(CONFLICT_DESCRIPTION)
+      }
+    },
+    async ({ runId, startAt, speedup, onConflict }) => guard(async () => {
+      const current = await sdk().testRuns.get(runId);
+      if (!current) return fail(`No test run found with id ${runId}.`);
+      const startTimestamp = startAt ?? current.startTimestamp;
+      if (!startTimestamp) return fail(`Test run ${runId} has no start time. Pass \`startAt\`.`);
+      const run = await sdk().testRuns.update({
+        id: runId,
+        startTimestamp,
+        speedup: speedup ?? current.speedup ?? 1,
+        conflictResolution: onConflict
+      });
+      return ok(`Updated test run (id: ${runId}).`, run);
+    })
+  );
+  server.registerTool(
+    "delete_test_run",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true },
+      title: "Delete test run",
+      description: "Permanently delete a test run and its results. Stop it first if it is still running (stop_test_run).",
+      inputSchema: {
+        runId: z7.string().describe("Test run id")
+      }
+    },
+    async ({ runId }) => guard(async () => {
+      await sdk().testRuns.delete(runId);
+      return ok(`Deleted test run ${runId}.`);
+    })
+  );
+  server.registerTool(
+    "list_latest_test_runs",
+    {
+      annotations: { readOnlyHint: true },
+      title: "List latest test runs",
+      description: "List what ran most recently in the active project's sim world, the quickest way to see how it went. Scheduled runs are not included. An entry with totalCount above 1 is a stress test; use its stressTestId with get_stress_test.",
+      inputSchema: {
+        limit: z7.number().int().min(1).max(50).optional().describe("How many entries to return (default 10)"),
+        project: projectArg
+      }
+    },
+    async ({ limit, project }) => guard(async () => {
+      const ctx = await resolveSimWorld(project);
+      const runs = await sdk().testRuns.listLatest(ctx.simWorldId, limit ?? 10);
+      return ok(`Found ${runs?.length ?? 0} recent run(s).`, runs);
+    })
+  );
+  server.registerTool(
+    "list_stress_tests",
+    {
+      annotations: { readOnlyHint: true },
+      title: "List stress tests",
+      description: "List stress tests in the active project's sim world, newest first, including scheduled ones, with their counts and stressTestId. Pass testId to find the one you just queued with run_stress_test; it appears once its background job has created the runs.",
+      inputSchema: {
+        testId: z7.string().optional().describe("Only stress tests of this test"),
+        ...paginationArgs,
+        project: projectArg
+      }
+    },
+    async ({ testId, page: page2, pageSize, project }) => guard(async () => {
+      const ctx = await resolveSimWorld(project);
+      const result = await sdk().testRuns.listGrouped({
+        simWorldId: ctx.simWorldId,
+        filters: { categories: ["STRESS_TEST"], ...testId ? { scenarioIds: [testId] } : {} },
+        pagination: pagination(page2, pageSize)
+      });
+      return ok(pageSummary("stress test(s)", result?.records?.length ?? 0, result?.pageInfo), result);
+    })
+  );
+  server.registerTool(
+    "stop_stress_test",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true },
+      title: "Stop stress test",
+      description: "Stop every run of a stress test. The stressTestId comes from list_stress_tests.",
+      inputSchema: {
+        stressTestId: z7.string().describe("Stress test id"),
+        project: projectArg
+      }
+    },
+    async ({ stressTestId, project }) => guard(async () => {
+      const ctx = await resolveSimWorld(project);
+      const status = await sdk().testRuns.shutDownGroup(stressTestId, ctx.simWorldId);
+      if (status === "ERROR") return fail(`Stress test ${stressTestId} could not be stopped.`);
+      return ok(`Asked to stop stress test ${stressTestId} (${status}). Follow it with get_stress_test.`);
+    })
+  );
+  server.registerTool(
+    "get_stress_test",
+    {
+      annotations: { readOnlyHint: true },
+      title: "Get stress test summary",
+      description: "Summarize a stress test: counts of planned, in-progress, completed, failed, skipped and draft runs. The stressTestId comes from list_stress_tests.",
+      inputSchema: {
+        stressTestId: z7.string().describe("Stress test id")
+      }
+    },
+    async ({ stressTestId }) => guard(async () => {
+      const group = await sdk().testRuns.getGrouped(stressTestId);
+      return ok(`Stress test ${stressTestId}: ${group?.completedCount ?? 0} completed, ${group?.failedCount ?? 0} failed, ${group?.skippedCount ?? 0} skipped, ${group?.inProgressCount ?? 0} in progress of ${group?.totalCount ?? 0} total.`, group);
+    })
+  );
+  server.registerTool(
+    "run_stress_test",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+      title: "Run stress test",
+      description: "Run one test on two or more simulators at once, the load-testing primitive: one run per selected simulator, for a test with one slot. Select with `simulatorIds`, or with `allSimulators` plus optional search, tagIds and excludeSimulatorIds; simulators of the test's protocol are used. It starts in the background: find it with list_stress_tests, then follow it with get_stress_test.",
+      inputSchema: {
+        testId: z7.string().describe("Test id to run"),
+        simulatorIds: z7.array(z7.string()).min(1).optional().describe("Run on exactly these simulators"),
+        allSimulators: z7.boolean().optional().describe("Run on every simulator matching the filters"),
+        search: z7.string().optional().describe("With allSimulators: filter by simulator name"),
+        tagIds: z7.array(z7.string()).optional().describe("With allSimulators: filter by tags"),
+        excludeSimulatorIds: z7.array(z7.string()).optional().describe("With allSimulators: leave these out"),
+        speedup: z7.number().int().min(1).optional().describe("Time acceleration, e.g. 10 = 10x faster (default 1)"),
+        startAt: z7.string().optional().describe("ISO 8601 start time (omit to start now)"),
+        onConflict: conflictEnum.optional().describe(CONFLICT_DESCRIPTION),
+        project: projectArg
+      }
+    },
+    async ({ testId, simulatorIds, allSimulators, search, tagIds, excludeSimulatorIds, speedup, startAt, onConflict, project }) => guard(async () => {
+      if (Boolean(simulatorIds) === Boolean(allSimulators)) {
+        return fail("Pass exactly one of `simulatorIds` or `allSimulators`.");
+      }
+      const ctx = await resolveSimWorld(project);
+      const test = await sdk().tests.get(testId);
+      const requirements = test?.requirements ?? [];
+      if (requirements.length !== 1) {
+        return fail(
+          `A stress test needs a test with one slot; test ${testId} has ${requirements.length}. Use run_test with \`assignments\` for a test with several.`
+        );
+      }
+      const requirement = requirements[0];
+      const protocol = requirement.params.find((param) => param.key === "protocol")?.value;
+      const matching = await listSimulatorIds(
+        ctx.simWorldId,
+        allSimulators ? { search, protocol, tagIds } : { protocol }
+      );
+      const wrong = (simulatorIds ?? []).filter((id) => !matching.includes(id));
+      if (wrong.length > 0) {
+        return fail(`Simulators ${wrong.join(", ")} are not ${protocol} simulators in this project.`);
+      }
+      const selected = allSimulators ? matching.filter((id) => !excludeSimulatorIds?.includes(id)) : [...new Set(simulatorIds)];
+      if (selected.length === 0) return fail("No simulators match the selection.");
+      if (selected.length === 1) {
+        return fail(`Only simulator ${selected[0]} matches, so this is not a stress test. Use run_test.`);
+      }
+      const multiplier = selected.length;
+      await sdk().testRuns.createBulkRuns({
+        scenarioId: testId,
+        simWorldId: ctx.simWorldId,
+        multiplier,
+        speedup: speedup ?? 1,
+        startTimestamp: startAt,
+        scheduleMode: startAt ? "DATETIME" : "NOW",
+        conflictResolution: onConflict,
+        bulkRequirementDevices: [
+          {
+            requirementId: requirement.id,
+            includedDevices: selected.map((deviceId) => ({ deviceId, deviceMode: "SIMULATOR" }))
+          }
+        ]
+      });
+      return ok(
+        `Queued a stress test: ${multiplier} run(s) of "${test?.name}" at ${speedup ?? 1}x speed. It is created in the background. Find it with list_stress_tests (testId ${testId}), do not start it again, then follow it with get_stress_test.`
+      );
+    })
+  );
+}
+
+// src/tools/test-plans.ts
+import { z as z8 } from "zod";
+function registerTestPlanTools(server) {
+  const projectArg = z8.string().optional().describe("Project name or id (defaults to active project)");
+  server.registerTool(
+    "list_test_plans",
+    {
+      annotations: { readOnlyHint: true },
+      title: "List test plans",
+      description: "List test plans in the active project's sim world. A plan runs several tests one after another on one simulator or hardware, now or at a set time.",
+      inputSchema: {
+        search: z8.string().optional().describe("Filter by plan name"),
+        ...paginationArgs,
+        project: projectArg
+      }
+    },
+    async ({ search, page: page2, pageSize, project }) => guard(async () => {
+      const ctx = await resolveSimWorld(project);
+      const result = await sdk().testPlans.list({
+        filters: { simWorldId: ctx.simWorldId, name: search },
+        pagination: pagination(page2, pageSize)
+      });
+      return ok(
+        pageSummary("test plan(s)", result?.records?.length ?? 0, result?.pageInfo),
+        result
+      );
+    })
+  );
+  server.registerTool(
+    "get_test_plan",
+    {
+      annotations: { readOnlyHint: true },
+      title: "Get test plan",
+      description: "Get a test plan by id, with its status and scheduled start.",
+      inputSchema: {
+        planId: z8.string().describe("Test plan id (see list_test_plans)")
+      }
+    },
+    async ({ planId }) => guard(async () => {
+      const plan = await sdk().testPlans.get(planId);
+      if (!plan) return ok(`No test plan found with id ${planId}.`);
+      return ok(`Test plan ${plan.name} (id: ${planId}).`, plan);
+    })
+  );
+  server.registerTool(
+    "create_test_plan",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+      title: "Create test plan",
+      description: "Create a test plan: a set of tests run one after another on one simulator or one hardware. Next step: launch it with launch_test_plan.",
+      inputSchema: {
+        name: z8.string(),
+        description: z8.string().optional(),
+        testIds: z8.array(z8.string()).min(1).describe("Test ids to include (see list_tests)"),
+        simulatorId: z8.string().optional().describe("Simulator the plan runs on (see list_simulators)"),
+        hardwareId: z8.string().optional().describe("Hardware the plan runs on, instead of a simulator"),
+        project: projectArg
+      }
+    },
+    async ({ name, description, testIds, simulatorId, hardwareId, project }) => guard(async () => {
+      if (simulatorId && hardwareId) return fail("Pass `simulatorId` or `hardwareId`, not both.");
+      const ctx = await resolveSimWorld(project);
+      const plan = await sdk().testPlans.create({
+        simWorldId: ctx.simWorldId,
+        name,
+        description,
+        scenarios: testIds,
+        chargerIds: simulatorId ? [simulatorId] : void 0,
+        deviceIds: hardwareId ? [hardwareId] : void 0
+      });
+      return ok(`Created test plan "${name}" (id: ${plan?.id}).`, plan);
+    })
+  );
+  server.registerTool(
+    "update_test_plan",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+      title: "Update test plan",
+      description: "Update a test plan's name or description, or, before it is launched, the simulator or hardware it runs on. Its tests cannot be changed; create a new plan for different tests.",
+      inputSchema: {
+        planId: z8.string().describe("Test plan id (see list_test_plans)"),
+        name: z8.string().optional(),
+        description: z8.string().optional(),
+        simulatorId: z8.string().optional().describe("Run on this simulator instead"),
+        hardwareId: z8.string().optional().describe("Run on this hardware instead")
+      }
+    },
+    async ({ planId, name, description, simulatorId, hardwareId }) => guard(async () => {
+      if (simulatorId && hardwareId) return fail("Pass `simulatorId` or `hardwareId`, not both.");
+      const current = await sdk().testPlans.get(planId);
+      if (!current) return fail(`No test plan found with id ${planId}.`);
+      if ((simulatorId || hardwareId) && current.status !== "DRAFT") {
+        return fail(
+          `Test plan ${planId} is ${current.status}: its runs are already bound to their simulator or hardware. Create a new plan to run elsewhere.`
+        );
+      }
+      const plan = await sdk().testPlans.update({
+        id: planId,
+        name,
+        description,
+        tags: (current.tags ?? []).map(({ id, name: tagName, color }) => ({ id, name: tagName, color })),
+        ...simulatorId ? { chargerIds: [simulatorId], deviceIds: [] } : {},
+        ...hardwareId ? { deviceIds: [hardwareId], chargerIds: [] } : {}
+      });
+      return ok(`Updated test plan (id: ${planId}).`, plan);
+    })
+  );
+  server.registerTool(
+    "launch_test_plan",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+      title: "Launch test plan",
+      description: "Launch a test plan now, or at a set time with startAt. Follow progress with list_test_runs and get_test_run.",
+      inputSchema: {
+        planId: z8.string().describe("Test plan id (see list_test_plans)"),
+        startAt: z8.string().optional().describe("ISO 8601 start time; omit to start now"),
+        onConflict: z8.enum(["FAIL", "RESCHEDULE", "FORCE_RUN"]).optional().describe(
+          "When something is busy. FAIL (default) starts nothing, RESCHEDULE uses the first free time, FORCE_RUN stops the runs holding it, so ask the user before using it."
+        )
+      }
+    },
+    async ({ planId, startAt, onConflict }) => guard(async () => {
+      const plan = await sdk().testPlans.launch({
+        id: planId,
+        scheduleMode: startAt ? "DATETIME" : "NOW",
+        startTimestamp: startAt,
+        conflictResolution: onConflict
+      });
+      return ok(`Launched test plan (id: ${planId})${startAt ? ` for ${startAt}` : ""}.`, plan);
+    })
+  );
+  server.registerTool(
+    "stop_test_plan",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true },
+      title: "Stop test plan",
+      description: "Stop a launched test plan: the tests that have not started are skipped, and the one in progress is stopped too unless keepActive is true. Stopping the active run leaves its simulator or hardware in a non-default state.",
+      inputSchema: {
+        planId: z8.string().describe("Test plan id (see list_test_plans)"),
+        keepActive: z8.boolean().optional().describe("Let the test in progress finish (default false)")
+      }
+    },
+    async ({ planId, keepActive }) => guard(async () => {
+      const current = await sdk().testPlans.get(planId);
+      if (!current) return fail(`No test plan found with id ${planId}.`);
+      if (current.status === "DRAFT") {
+        return fail(`Test plan ${planId} has not been launched, so there is nothing to stop.`);
+      }
+      if (current.status === "COMPLETED" || current.status === "FAILED" || current.status === "SKIPPED") {
+        return fail(`Test plan ${planId} has already finished: it is ${current.status}.`);
+      }
+      const plan = await sdk().testPlans.skipRemaining(planId, keepActive ? "PENDING_ONLY" : "INCLUDING_ACTIVE");
+      return ok(`Stopped test plan ${planId}, now ${plan?.status ?? "unknown"}.`, plan);
+    })
+  );
+  server.registerTool(
+    "delete_test_plan",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true },
+      title: "Delete test plan",
+      description: "Permanently delete a test plan.",
+      inputSchema: {
+        planId: z8.string().describe("Test plan id (see list_test_plans)")
+      }
+    },
+    async ({ planId }) => guard(async () => {
+      await sdk().testPlans.delete(planId);
+      return ok(`Deleted test plan ${planId}.`);
+    })
+  );
+}
+
+// src/tools/support.ts
+import { z as z9 } from "zod";
+
+// src/logs-format.ts
+var DEFAULT_LOGS_LAST = "1h";
+var DEFAULT_LOGS_LIMIT = 200;
+var MAX_LOGS_LIMIT = 1e3;
+var PAYLOAD_MAX_CHARS = 500;
+var UNIT_MS = { s: 1e3, m: 6e4, h: 36e5, d: 864e5 };
+function parseDuration(value) {
+  const match = value.trim().match(/^(\d+)\s*([smhd])$/i);
+  if (!match) throw new Error(`Invalid duration "${value}". Use a number and a unit: 30m, 6h, 2d.`);
+  return Number(match[1]) * UNIT_MS[match[2].toLowerCase()];
+}
+function parseInstant(value, name) {
   const date = new Date(value);
   if (Number.isNaN(date.getTime())) throw new Error(`Invalid ${name} "${value}". Use an ISO date-time.`);
   return date;
@@ -756,21 +2560,29 @@ function findRunSimulator(records, simulator) {
     (rc) => rc.charger?.baseName?.toLowerCase() === needle || rc.device?.serialNumber?.toLowerCase() === needle
   );
 }
-function summarizeRun(run, simulators, page, steps) {
+function summarizeRun(run, simulators, page2, steps) {
   const records = (simulators?.records ?? []).filter(Boolean);
   const lines = [
     `Test run ${run.id} ("${run.scenario?.name ?? "?"}"): ${run.status}` + (run.failReason ? ` \u2014 ${run.failReason}` : "") + `. Started ${run.realStartTimestamp ?? run.startTimestamp ?? "\u2014"}, stopped ${run.realStopTimestamp ?? "\u2014"}.`,
-    pageSummary("simulator(s)", records.length, simulators?.pageInfo ?? { page })
+    pageSummary("simulator(s)", records.length, simulators?.pageInfo ?? { page: page2 })
   ];
   for (const rc of records) {
-    lines.push(`- ${simulatorName(rc)} (simulator ${rc.charger?.id ?? rc.device?.id ?? "?"}, run entry ${rc.id}): ${rc.status}`);
+    const target = rc.charger?.id ? `simulator ${rc.charger.id}` : `hardware ${rc.device?.id ?? "?"}`;
+    lines.push(`- ${simulatorName(rc)} (${target}, run entry ${rc.id}): ${rc.status}`);
   }
   if (steps) {
     lines.push("", `Steps of ${simulatorName(steps)}:`);
     for (const step of steps.chargerActions ?? []) {
+      const reason = step.displayFailReason ?? step.failReason;
+      const action = step.scenarioAction?.action;
       lines.push(
-        `    step ${step.order} ${step.scenarioAction?.action?.name ?? "?"}: ${step.status}` + (step.failReason ? ` \u2014 ${step.failReason}` : "")
+        `    step ${step.order} ${action?.name ?? "?"} (id: ${step.id}${action?.deviceType === "CSMS" ? ", remote" : ""}): ${step.status}${reason ? ` \u2014 ${reason}` : ""}`
       );
+      for (const result of step.resultComparisons ?? []) {
+        lines.push(
+          `        expected ${result.command} ${JSON.stringify(result.expectedResponse ?? result.expectedRequest ?? {})}, actual ${result.actualCommand ?? "nothing yet"} ${JSON.stringify(result.actualResponse ?? result.actualRequest ?? null)}`
+        );
+      }
     }
   } else if (records.length > 1 || simulators?.pageInfo?.hasNextPage) {
     lines.push("", "Pass `simulator` with one of the names or ids above to see its steps.");
@@ -778,13 +2590,13 @@ function summarizeRun(run, simulators, page, steps) {
   return lines.join("\n");
 }
 function registerSupportTools(server) {
-  const projectArg = z7.string().optional().describe("Project name or id (defaults to active project; a portal link sets its own)");
+  const projectArg = z9.string().optional().describe("Project name or id (defaults to active project; a portal link sets its own)");
   server.registerTool(
     "get_simulator_config",
     {
       title: "Get simulator configuration",
       description: "Read-only. Everything that explains why a simulator behaves the way it does: its OCPP configuration keys (e.g. FreevendEnabled, HeartbeatInterval), behavior settings (vendor behavior, remote start/stop templates, supported commands, timeouts), model and connector types (fixed or flexible cable), live connectors, authorizations, charging profiles, transactions, reservations, and the last test run with its fail reason. Credential values are masked.",
-      inputSchema: { simulator: z7.string().describe(SIMULATOR_ARG_DESCRIPTION), project: projectArg },
+      inputSchema: { simulator: z9.string().describe(SIMULATOR_ARG_DESCRIPTION), project: projectArg },
       annotations: READ_ONLY
     },
     async ({ simulator, project }) => guard(async () => {
@@ -793,31 +2605,33 @@ function registerSupportTools(server) {
       if (!details) return ok(`No simulator found with id ${sim.id}.`);
       const items = await sdk().simulators.getOcppConfigItems(sim.id);
       const safe = { ...details, chargerOcppConfigItems: maskSecretItems(items) };
-      return ok(summarizeSimulator(safe), safe);
+      const unreadable = details.authorizations === null ? "\nIts authorizations could not be read." : "";
+      return ok(`${summarizeSimulator(safe)}${unreadable}`, safe);
     })
   );
   server.registerTool(
     "get_simulator_logs",
     {
-      title: "Get simulator logs",
-      description: "Read-only. The simulator's OCPP message log for a time window, one line per message: `time  direction  action  payload` (payload cut at ~500 chars). Newest messages are kept when the limit cuts the window; lines are printed oldest first. Use `action` to keep one OCPP action, e.g. StatusNotification (its results and errors are kept too).",
+      title: "Get simulator or hardware logs",
+      description: "Read-only. The OCPP message log of a simulator or hardware for a time window, one line per message: `time  direction  action  payload` (payload cut at ~500 chars). Newest messages are kept when the limit cuts the window; lines are printed oldest first. Use `action` to keep one OCPP action, e.g. StatusNotification (its results and errors are kept too).",
       inputSchema: {
-        simulator: z7.string().describe(SIMULATOR_ARG_DESCRIPTION),
-        from: z7.string().optional().describe("Window start, ISO date-time (wins over `last`)"),
-        to: z7.string().optional().describe("Window end, ISO date-time (default now)"),
-        last: z7.string().optional().describe(`Window length back from \`to\`, e.g. 30m, 6h, 2d (default ${DEFAULT_LOGS_LAST})`),
-        limit: z7.number().int().min(1).max(MAX_LOGS_LIMIT).optional().describe(`Max messages to show (default ${DEFAULT_LOGS_LIMIT}, max ${MAX_LOGS_LIMIT})`),
-        action: z7.string().optional().describe("Keep only this OCPP action, e.g. StatusNotification"),
+        simulator: z9.string().optional().describe(SIMULATOR_ARG_DESCRIPTION),
+        hardware: z9.string().optional().describe("Hardware serial number or id (instead of simulator)"),
+        from: z9.string().optional().describe("Window start, ISO date-time (wins over `last`)"),
+        to: z9.string().optional().describe("Window end, ISO date-time (default now)"),
+        last: z9.string().optional().describe(`Window length back from \`to\`, e.g. 30m, 6h, 2d (default ${DEFAULT_LOGS_LAST})`),
+        limit: z9.number().int().min(1).max(MAX_LOGS_LIMIT).optional().describe(`Max messages to show (default ${DEFAULT_LOGS_LIMIT}, max ${MAX_LOGS_LIMIT})`),
+        action: z9.string().optional().describe("Keep only this OCPP action, e.g. StatusNotification"),
         project: projectArg
       },
       annotations: READ_ONLY
     },
-    async ({ simulator, from, to, last, limit, action, project }) => guard(async () => {
+    async ({ simulator, hardware, from, to, last, limit, action, project }) => guard(async () => {
       const window = resolveWindow({ from, to, last });
-      const { sim } = await resolveSimulatorTarget(simulator, project);
+      const target = await resolveRunTarget({ simulator, hardware, project });
       const shown = Math.min(limit ?? DEFAULT_LOGS_LIMIT, MAX_LOGS_LIMIT);
       const result = await sdk().logs.list({
-        simulatorId: sim.id,
+        ...target.kind === "SIMULATOR" ? { simulatorId: target.id } : { hardwareId: target.id },
         from: window.from,
         to: window.to,
         limit: action ? MAX_LOGS_LIMIT : shown
@@ -826,7 +2640,7 @@ function registerSupportTools(server) {
       const matched = action ? all.filter((line) => matchesAction(line, action)) : all;
       const lines = matched.slice(0, shown).reverse();
       const truncated = matched.length > shown || Boolean(result.pageInfo?.hasNextPage);
-      const head = `${sim.baseName} (id: ${sim.id}) ${window.from.toISOString()} \u2026 ${window.to.toISOString()}: ${lines.length} message(s) shown` + (action ? ` matching "${action}" of ${all.length} scanned` : "") + (result.pageInfo?.totalCount != null ? `; ${result.pageInfo.totalCount} in window` : "") + `; truncated: ${truncated ? "yes \u2014 narrow the window or raise the limit" : "no"}.`;
+      const head = `${target.name} (id: ${target.id}) ${window.from.toISOString()} \u2026 ${window.to.toISOString()}: ${lines.length} message(s) shown` + (action ? ` matching "${action}" of ${all.length} scanned` : "") + (result.pageInfo?.totalCount != null ? `; ${result.pageInfo.totalCount} in window` : "") + `; truncated: ${truncated ? "yes \u2014 narrow the window or raise the limit" : "no"}.`;
       return ok([head, "", ...lines.map(formatLine)].join("\n"));
     })
   );
@@ -834,18 +2648,18 @@ function registerSupportTools(server) {
     "get_test_run_details",
     {
       title: "Get test run details",
-      description: `Read-only. A test run's status and fail reason, plus one page of its simulators or devices with their status (${RUN_SIMULATORS_PAGE_SIZE} per page). Steps \u2014 status, fail reason, expected / actual result \u2014 are shown for one simulator at a time: pass \`simulator\` with a name or id from the page. A run with a single simulator shows its steps right away.`,
+      description: `Read-only. A test run's status and fail reason, plus one page of its simulators or hardware with their status (${RUN_SIMULATORS_PAGE_SIZE} per page). Steps, with id, status, fail reason and expected / actual result, are shown for one simulator at a time: pass \`simulator\` with a name or id from the page. A run with a single simulator shows its steps right away. The step id is what complete_test_step and fail_test_step take.`,
       inputSchema: {
-        runId: z7.string().describe("Test run id"),
-        page: z7.number().int().min(1).optional().describe("Page of the run's simulators, starting at 1 (default 1)"),
-        simulator: z7.string().optional().describe("Show the steps of this simulator from the page: its name, simulator id or run entry id")
+        runId: z9.string().describe("Test run id"),
+        page: z9.number().int().min(1).optional().describe("Page of the run's simulators, starting at 1 (default 1)"),
+        simulator: z9.string().optional().describe("Show the steps of this simulator from the page: its name, simulator id or run entry id")
       },
       annotations: READ_ONLY
     },
-    async ({ runId, page, simulator }) => guard(async () => {
+    async ({ runId, page: page2, simulator }) => guard(async () => {
       const run = await sdk().testRuns.getDetails(runId);
       if (!run) return ok(`No test run found with id ${runId}.`);
-      const current = page ?? 1;
+      const current = page2 ?? 1;
       const simulators = await sdk().testRuns.listSimulators(runId, {
         pagination: { page: current, pageSize: RUN_SIMULATORS_PAGE_SIZE }
       });
@@ -868,47 +2682,1049 @@ function registerSupportTools(server) {
   );
 }
 
-// src/tools/index.ts
-var READONLY_ENV = "TIMETICK_MCP_READONLY";
-function isReadOnlyMode(env = process.env) {
-  const value = env[READONLY_ENV]?.trim().toLowerCase();
-  return value === "1" || value === "true";
-}
-function readOnlyView(server) {
-  return new Proxy(server, {
-    get(target, prop, receiver) {
-      if (prop !== "registerTool") return Reflect.get(target, prop, receiver);
-      return (name, config, cb) => config.annotations?.readOnlyHint === true ? target.registerTool(name, config, cb) : void 0;
-    }
-  });
-}
-function registerTools(server, options) {
-  const target = options.readOnly ? readOnlyView(server) : server;
-  registerContextTools(target);
-  registerDataTools(target);
-  registerSimulatorTools(target);
-  registerTestTools(target);
-  registerTestRunTools(target);
-  registerSupportTools(target);
+// src/tools/api-keys.ts
+import { z as z10 } from "zod";
+function registerApiKeyTools(server) {
+  server.registerTool(
+    "list_api_keys",
+    {
+      annotations: { readOnlyHint: true },
+      title: "List API keys",
+      description: "List the API keys on your Timetick account.",
+      inputSchema: {}
+    },
+    async () => guard(async () => {
+      const keys = await sdk().apiKeys.list();
+      return ok(`Found ${keys?.length ?? 0} API key(s).`, keys);
+    })
+  );
+  server.registerTool(
+    "create_api_key",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+      title: "Create API key",
+      description: "Create a new API key for the account. The secret is shown once in the reply \u2014 store it immediately, it cannot be retrieved later. Use this to give another machine or integration access without sharing your login.",
+      inputSchema: {
+        name: z10.string().describe("Key name, e.g. 'CI pipeline'"),
+        expiresAt: z10.string().optional().describe("Optional expiration date (ISO 8601)")
+      }
+    },
+    async ({ name, expiresAt }) => guard(async () => {
+      const key = await sdk().apiKeys.create({ name, enabled: true, expiresAt });
+      return ok(
+        `Created API key "${key?.apiKey?.name}" (id: ${key?.apiKey?.id}). Secret shown once below \u2014 save it now.`,
+        { secretKey: key?.secretKey }
+      );
+    })
+  );
+  server.registerTool(
+    "rotate_api_key",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true },
+      title: "Rotate API key",
+      description: "Rotate an API key's secret: the old secret stops working and a new one is returned (shown once \u2014 save it now).",
+      inputSchema: {
+        keyId: z10.string().describe("API key id (see list_api_keys)")
+      }
+    },
+    async ({ keyId }) => guard(async () => {
+      const stored = peekCredentials();
+      const key = await sdk().apiKeys.rotate(keyId);
+      if (stored?.keyId === keyId && !process.env.TIMETICK_API_TOKEN && key?.secretKey) {
+        await saveCredentials({ ...stored, apiKey: key.secretKey });
+        resetSdk();
+        return ok(`Rotated the API key this server uses (id: ${keyId}) and stored the new secret locally.`);
+      }
+      return ok(
+        `Rotated API key (id: ${key?.apiKey?.id}). The previous secret no longer works. New secret shown once below \u2014 save it now.`,
+        { secretKey: key?.secretKey }
+      );
+    })
+  );
+  server.registerTool(
+    "delete_api_key",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true },
+      title: "Delete API key",
+      description: "Permanently delete an API key. Anything using it loses access immediately. To keep access while changing the secret, use rotate_api_key instead.",
+      inputSchema: {
+        keyId: z10.string().describe("API key id (see list_api_keys)")
+      }
+    },
+    async ({ keyId }) => guard(async () => {
+      if (peekCredentials()?.keyId === keyId && !process.env.TIMETICK_API_TOKEN) {
+        return fail("This is the API key this server is using. Call logout to revoke it and sign out.");
+      }
+      const status = await sdk().apiKeys.delete(keyId);
+      if (status === "ERROR") return fail(`API key ${keyId} could not be deleted.`);
+      return ok(`Deleted API key ${keyId}.`);
+    })
+  );
 }
 
-// src/index.ts
-async function main() {
-  if (!process.env.TIMETICK_API_TOKEN) {
-    console.error(
-      "TIMETICK_API_TOKEN is not set. Generate an API key in the Timetick portal (Account \u2192 API keys) and expose it to the MCP server as TIMETICK_API_TOKEN."
-    );
-    process.exit(1);
-  }
-  const server = new McpServer({ name: "timetick", version: "0.2.1" });
-  const readOnly = isReadOnlyMode();
-  registerTools(server, { readOnly });
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-  console.error(`Timetick MCP server running on stdio${readOnly ? " (read-only)" : ""}`);
+// src/tools/projects.ts
+import { z as z11 } from "zod";
+function registerProjectTools(server) {
+  server.registerTool(
+    "create_project",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+      title: "Create project",
+      description: "Create the account's first project and make it the active one. A project holds its endpoints, models, simulators and tests. Its free trial starts right away, skipping the portal's onboarding. An account that already has a project sets up further ones with payment details in the web portal.",
+      inputSchema: {
+        name: z11.string().describe("Project name"),
+        timezone: z11.string().optional().describe("IANA timezone, e.g. 'Europe/Amsterdam' (default: this machine's)"),
+        website: z11.string().optional().describe("Company website")
+      }
+    },
+    async ({ name, timezone, website }) => guard(async () => {
+      const existing = await sdk().projects.list() ?? [];
+      if (existing.length > 0) {
+        const me = await sdk().users.getCurrent();
+        let invitedUnfinished = null;
+        for (const candidate of existing) {
+          if (candidate?.onboardingStatus !== "NOT_STARTED" && candidate?.onboardingStatus !== "IN_PROGRESS") continue;
+          const role = me?.id ? await sdk().projects.getUserRole(candidate.id, me.id).catch(() => null) : null;
+          if (role === "OWNER") {
+            return fail(
+              `Project "${candidate.name}" (id: ${candidate.id}) has not started its free trial: call start_trial with project "${candidate.id}". An account has one trial, so a new project would use it and leave that one read-only.`
+            );
+          }
+          invitedUnfinished ??= candidate.name ?? null;
+        }
+        return fail(
+          `This account already has a project, so another one needs payment details, set up in the web portal: ${portalUrl("/projects/new")}. Use use_project to work in an existing one.` + (invitedUnfinished ? ` Project "${invitedUnfinished}" is read-only until its owner starts its trial.` : "")
+        );
+      }
+      const project = await sdk().projects.create({
+        project: { name, timezone: timezone ?? Intl.DateTimeFormat().resolvedOptions().timeZone, website }
+      });
+      let onboardingStatus = project?.onboardingStatus;
+      let trialNote = "";
+      if (project?.id && project.onboardingStatus === "NOT_STARTED") {
+        const reason = await sdk().projects.update({ id: project.id, onboardingStatus: "SKIPPED" }).then(
+          () => "",
+          (err) => ` (${err instanceof Error ? err.message : String(err)})`
+        );
+        const created = await sdk().projects.get(project.id).catch(() => null);
+        onboardingStatus = created?.onboardingStatus ?? (reason ? onboardingStatus : "SKIPPED");
+        if (!created && reason) {
+          trialNote = ` Could not confirm the free trial started${reason}: do not create the project again, call start_trial.`;
+        } else if (created && !created.projectPlan) {
+          const canRetry = created.onboardingStatus === "NOT_STARTED" || created.onboardingStatus === "IN_PROGRESS";
+          trialNote = ` The free trial did not start${reason}, so the project is read-only: do not create it again.` + (canRetry ? " Call start_trial." : " A paid plan is set up in the web portal.");
+        }
+      }
+      const active = project?.id ? await useProject({ project: project.id }).catch(() => null) : null;
+      return ok(
+        `Created project "${project?.name}" (id: ${project?.id})` + (active ? ", now active." : ". Select it with use_project.") + trialNote,
+        { ...project, onboardingStatus }
+      );
+    })
+  );
+  server.registerTool(
+    "start_trial",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+      title: "Start the free trial",
+      description: "Start the free trial of a project whose onboarding was never finished in the portal, the same as its Skip button. Only the project's owner can. Until then the project is read-only. get_context shows whether it is needed.",
+      inputSchema: {
+        project: z11.string().optional().describe("Project name or id (defaults to active project)")
+      }
+    },
+    async ({ project }) => guard(async () => {
+      const ctx = await resolveSimWorld(project);
+      const current = await sdk().projects.get(ctx.projectId);
+      if (current?.projectPlan) {
+        return ok(`Project "${ctx.projectName}" already has a plan: ${current.projectPlan.plan?.name ?? "unknown"}.`);
+      }
+      if (current?.onboardingStatus !== "NOT_STARTED" && current?.onboardingStatus !== "IN_PROGRESS") {
+        return fail(`Project "${ctx.projectName}" has no active plan. A paid plan is set up in the web portal.`);
+      }
+      const me = await sdk().users.getCurrent();
+      const role = me?.id ? await sdk().projects.getUserRole(ctx.projectId, me.id) : null;
+      if (role !== "OWNER") {
+        return fail(`Only the owner of project "${ctx.projectName}" can start its trial. Ask them to do it.`);
+      }
+      await sdk().projects.update({ id: ctx.projectId, onboardingStatus: "SKIPPED" });
+      const after = await sdk().projects.get(ctx.projectId);
+      if (!after?.projectPlan) {
+        return fail(`The trial of project "${ctx.projectName}" did not start. A paid plan is set up in the web portal.`);
+      }
+      return ok(`Started the free trial of project "${ctx.projectName}": ${after.projectPlan.plan?.name ?? "unknown"}.`);
+    })
+  );
+  server.registerTool(
+    "update_project",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+      title: "Update project",
+      description: "Rename a project or change its timezone / website.",
+      inputSchema: {
+        projectId: z11.string().describe("Project id (see list_projects)"),
+        name: z11.string().optional(),
+        timezone: z11.string().optional().describe("IANA timezone, e.g. 'Europe/Amsterdam'"),
+        website: z11.string().optional()
+      }
+    },
+    async ({ projectId, name, timezone, website }) => guard(async () => {
+      const project = await sdk().projects.update({ id: projectId, name, timezone, website });
+      return ok(`Updated project (id: ${projectId}).`, project);
+    })
+  );
+  server.registerTool(
+    "delete_project",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true },
+      title: "Delete project",
+      description: "Permanently delete a project with everything in it \u2014 simulators, tests, runs, history. There is no undo.",
+      inputSchema: {
+        projectId: z11.string().describe("Project id (see list_projects)")
+      }
+    },
+    async ({ projectId }) => guard(async () => {
+      await sdk().projects.delete(projectId);
+      if (peekContext()?.projectId === projectId) resetContext();
+      return ok(`Deleted project ${projectId}.`);
+    })
+  );
+}
+
+// src/tools/catalog.ts
+import { z as z12 } from "zod";
+var protocolEnum4 = z12.enum(["OCPP_1_6", "OCPP_2_0_1"]);
+var connectorsSchema = z12.array(
+  z12.object({
+    type: z12.enum(["J1772", "MENNEKES", "GBT", "CHADEMO", "CCS1", "CCS2", "TESLA"]),
+    maxPower: z12.number().int().optional().describe("Max power in kW (default: the model's power, rounded)"),
+    number: z12.number().int().min(1).optional().describe("Connector number (default: its position, from 1)"),
+    cableFixed: z12.boolean().optional().describe("Fixed cable (default true)"),
+    evseId: z12.number().int().min(1).optional().describe("EVSE id: required on OCPP 2.0.1, not allowed on OCPP 1.6")
+  })
+).min(1);
+function connectorParams(connectors, protocol, power) {
+  return connectors.map((connector, index) => {
+    if (protocol === "OCPP_2_0_1" && !connector.evseId) {
+      throw new Error("Every connector of an OCPP 2.0.1 model needs `evseId`.");
+    }
+    if (protocol === "OCPP_1_6" && connector.evseId != null) {
+      throw new Error("Connectors of an OCPP 1.6 model must not have `evseId`.");
+    }
+    return {
+      ...connector,
+      number: connector.number ?? index + 1,
+      maxPower: connector.maxPower ?? (power === void 0 ? void 0 : Math.round(power))
+    };
+  });
+}
+var PRIVATE_HOST = /^(localhost|127\.\d+\.\d+\.\d+|10\.\d+\.\d+\.\d+|192\.168\.\d+\.\d+|172\.(1[6-9]|2\d|3[01])\.\d+\.\d+|0\.0\.0\.0|\[::1\]|.*\.local)$/i;
+function externalEndpointProblem(uri) {
+  if (!uri) return "An EXTERNAL endpoint needs `uri`: the CSMS websocket URL.";
+  let url;
+  try {
+    url = new URL(uri);
+  } catch {
+    return `"${uri}" is not a valid URL.`;
+  }
+  if (url.protocol !== "ws:" && url.protocol !== "wss:") return `The CSMS URL must start with ws:// or wss://, got "${uri}".`;
+  if (PRIVATE_HOST.test(url.hostname)) {
+    return `${url.hostname} is not reachable: simulators connect from Timetick's cloud, so the CSMS needs a public address. Expose it through a public host or a tunnel, and pass that URL.`;
+  }
+  return null;
+}
+function registerCatalogTools(server) {
+  const projectArg = z12.string().optional().describe("Project name or id (defaults to active project)");
+  server.registerTool(
+    "list_manufacturers",
+    {
+      annotations: { readOnlyHint: true },
+      title: "List manufacturers",
+      description: "List manufacturers in the active project's sim world. Manufacturers group models; create one with create_manufacturer if yours is missing.",
+      inputSchema: {
+        search: z12.string().optional().describe("Filter by manufacturer name"),
+        ...paginationArgs,
+        project: projectArg
+      }
+    },
+    async ({ search, page: page2, pageSize, project }) => guard(async () => {
+      const ctx = await resolveSimWorld(project);
+      const result = await sdk().manufacturers.list({
+        simWorldId: ctx.simWorldId,
+        searchValue: search,
+        pagination: pagination(page2, pageSize)
+      });
+      return ok(
+        pageSummary("manufacturer(s)", result?.records?.length ?? 0, result?.pageInfo),
+        result
+      );
+    })
+  );
+  server.registerTool(
+    "create_manufacturer",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+      title: "Create manufacturer",
+      description: "Create a manufacturer, the vendor of the chargers you want to simulate. Next step: create a model under it with create_model.",
+      inputSchema: {
+        name: z12.string().describe("Manufacturer name, e.g. 'ABB'"),
+        description: z12.string().optional(),
+        project: projectArg
+      }
+    },
+    async ({ name, description, project }) => guard(async () => {
+      const ctx = await resolveSimWorld(project);
+      const manufacturer = await sdk().manufacturers.create({
+        simWorldId: ctx.simWorldId,
+        name,
+        type: "CHARGER",
+        description
+      });
+      return ok(`Created manufacturer "${name}" (id: ${manufacturer?.id}).`, manufacturer);
+    })
+  );
+  server.registerTool(
+    "update_manufacturer",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+      title: "Update manufacturer",
+      description: "Rename a manufacturer or change its description.",
+      inputSchema: {
+        manufacturerId: z12.string().describe("Manufacturer id (see list_manufacturers)"),
+        name: z12.string().optional(),
+        description: z12.string().optional(),
+        project: projectArg
+      }
+    },
+    async ({ manufacturerId, name, description, project }) => guard(async () => {
+      const ctx = await resolveSimWorld(project);
+      const current = await sdk().manufacturers.get(manufacturerId);
+      if (!current) return fail(`No manufacturer found with id ${manufacturerId}.`);
+      const manufacturer = await sdk().manufacturers.update({
+        id: manufacturerId,
+        simWorldId: ctx.simWorldId,
+        name: name ?? current.name,
+        description
+      });
+      return ok(`Updated manufacturer (id: ${manufacturerId}).`, manufacturer);
+    })
+  );
+  server.registerTool(
+    "delete_manufacturer",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true },
+      title: "Delete manufacturer",
+      description: "Permanently delete a manufacturer.",
+      inputSchema: {
+        manufacturerId: z12.string().describe("Manufacturer id (see list_manufacturers)")
+      }
+    },
+    async ({ manufacturerId }) => guard(async () => {
+      const status = await sdk().manufacturers.delete(manufacturerId);
+      if (status === "ERROR") return fail(`Manufacturer ${manufacturerId} could not be deleted.`);
+      return ok(`Deleted manufacturer ${manufacturerId}.`);
+    })
+  );
+  server.registerTool(
+    "list_models",
+    {
+      annotations: { readOnlyHint: true },
+      title: "List simulator models",
+      description: "List models in the active project's sim world. A model defines protocol, power, firmware and connectors; simulators are created from models. Create one with create_model.",
+      inputSchema: {
+        search: z12.string().optional().describe("Filter by model name"),
+        protocol: protocolEnum4.optional(),
+        ...paginationArgs,
+        project: projectArg
+      }
+    },
+    async ({ search, protocol, page: page2, pageSize, project }) => guard(async () => {
+      const ctx = await resolveSimWorld(project);
+      const result = await sdk().models.list({
+        simWorldId: ctx.simWorldId,
+        searchValue: search,
+        filters: protocol ? { protocol } : void 0,
+        pagination: pagination(page2, pageSize)
+      });
+      return ok(pageSummary("model(s)", result?.records?.length ?? 0, result?.pageInfo), result);
+    })
+  );
+  server.registerTool(
+    "create_model",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+      title: "Create simulator model",
+      description: "Create a model. Needs a manufacturer (list_manufacturers / create_manufacturer), a simulator config (list_simulator_configs) and, for OCPP 1.6, an OCPP config (list_ocpp_configs). Next step: create simulators from this model with create_simulator.",
+      inputSchema: {
+        name: z12.string().describe("Model name, e.g. 'Terra 54'"),
+        manufacturerId: z12.string().describe("Manufacturer id (see list_manufacturers)"),
+        simulatorConfigId: z12.string().describe("Simulator config id (see list_simulator_configs)"),
+        ocppConfigId: z12.string().optional().describe("OCPP config id (see list_ocpp_configs); required on OCPP 1.6"),
+        protocol: protocolEnum4,
+        power: z12.number().describe("Max power in kW"),
+        currentType: z12.enum(["AC", "DC"]),
+        firmwareVersion: z12.string().describe("Firmware version string, e.g. '1.2.3'"),
+        connectors: connectorsSchema.describe("Connector definitions, e.g. [{ type: 'CCS2', maxPower: 150 }]"),
+        project: projectArg
+      }
+    },
+    async ({ name, manufacturerId, simulatorConfigId, ocppConfigId, protocol, power, currentType, firmwareVersion, connectors, project }) => guard(async () => {
+      if (protocol === "OCPP_1_6" && !ocppConfigId) {
+        return fail("An OCPP 1.6 model needs `ocppConfigId` (see list_ocpp_configs or create_ocpp_config).");
+      }
+      const ctx = await resolveSimWorld(project);
+      const model = await sdk().models.create({
+        simWorldId: ctx.simWorldId,
+        name,
+        deviceManufacturerId: manufacturerId,
+        chargerConfigId: simulatorConfigId,
+        ocppConfigId,
+        protocol,
+        power,
+        type: currentType,
+        firmwareVersion,
+        connectorModelsParams: connectorParams(connectors, protocol, power)
+      });
+      return ok(`Created model "${name}" (id: ${model?.id}).`, model);
+    })
+  );
+  server.registerTool(
+    "update_model",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+      title: "Update simulator model",
+      description: "Update a model's name, firmware, power or connectors.",
+      inputSchema: {
+        modelId: z12.string().describe("Model id (see list_models)"),
+        name: z12.string().optional(),
+        firmwareVersion: z12.string().optional(),
+        power: z12.number().optional().describe("Max power in kW"),
+        connectors: connectorsSchema.optional().describe("Replaces all connectors; omit to keep them"),
+        project: projectArg
+      }
+    },
+    async ({ modelId, name, firmwareVersion, power, connectors, project }) => guard(async () => {
+      const ctx = await resolveSimWorld(project);
+      const existing = await sdk().models.get(modelId);
+      if (!existing) return fail(`No model found with id ${modelId}.`);
+      await sdk().models.update({
+        id: modelId,
+        simWorldId: ctx.simWorldId,
+        name,
+        firmwareVersion,
+        power,
+        connectorModelsParams: connectors ? connectorParams(connectors, existing.protocol, power ?? existing.power) : (existing.connectorModels ?? []).map(({ number, type, maxPower, cableFixed, evseId }) => ({
+          number,
+          type,
+          maxPower,
+          cableFixed,
+          evseId
+        }))
+      });
+      return ok(`Updated model (id: ${modelId}).`, await sdk().models.get(modelId));
+    })
+  );
+  server.registerTool(
+    "delete_model",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true },
+      title: "Delete simulator model",
+      description: "Permanently delete a model. Refused while a simulator or hardware that used it exists, including deleted ones the platform still retains, for up to a year. A manufacturer can't be deleted while it has a model.",
+      inputSchema: {
+        modelId: z12.string().describe("Model id (see list_models)")
+      }
+    },
+    async ({ modelId }) => guard(async () => {
+      await sdk().models.delete(modelId);
+      return ok(`Deleted model ${modelId}.`);
+    })
+  );
+  server.registerTool(
+    "list_endpoints",
+    {
+      annotations: { readOnlyHint: true },
+      title: "List endpoints",
+      description: "List CSMS endpoints in the active project's sim world. An endpoint is the OCPP server (URL) simulators connect to. Every simulator needs one \u2014 create it with create_endpoint.",
+      inputSchema: {
+        search: z12.string().optional().describe("Filter by endpoint name"),
+        protocol: protocolEnum4.optional(),
+        ...paginationArgs,
+        project: projectArg
+      }
+    },
+    async ({ search, protocol, page: page2, pageSize, project }) => guard(async () => {
+      const ctx = await resolveSimWorld(project);
+      const result = await sdk().endpoints.list({
+        simWorldId: ctx.simWorldId,
+        searchValue: search,
+        filters: protocol ? { protocol } : void 0,
+        pagination: pagination(page2, pageSize)
+      });
+      return ok(pageSummary("endpoint(s)", result?.records?.length ?? 0, result?.pageInfo), result);
+    })
+  );
+  server.registerTool(
+    "create_endpoint",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+      title: "Create endpoint",
+      description: "Create a CSMS endpoint, the OCPP server URL simulators connect to. New projects already have TIMETICK endpoints pointing at Timetick's CSMS. To test your own CSMS create an EXTERNAL one with its public ws(s):// URL. Protocol must match the simulators you plan to add.",
+      inputSchema: {
+        name: z12.string().describe("Endpoint name, e.g. 'My CSMS'"),
+        protocol: protocolEnum4,
+        endpointType: z12.enum(["TIMETICK", "EXTERNAL"]),
+        uri: z12.string().optional().describe("Public CSMS websocket URL for EXTERNAL endpoints, e.g. 'wss://csms.example.com/ocpp'"),
+        config: z12.string().optional().describe("Optional JSON config"),
+        project: projectArg
+      }
+    },
+    async ({ name, protocol, endpointType, uri, config, project }) => guard(async () => {
+      const problem = endpointType === "EXTERNAL" ? externalEndpointProblem(uri) : null;
+      if (problem) return fail(problem);
+      const ctx = await resolveSimWorld(project);
+      const endpoint = await sdk().endpoints.create({
+        simWorldId: ctx.simWorldId,
+        name,
+        protocol,
+        type: endpointType,
+        uri,
+        config
+      });
+      return ok(`Created endpoint "${name}" (id: ${endpoint?.id}).`, endpoint);
+    })
+  );
+  server.registerTool(
+    "update_endpoint",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+      title: "Update endpoint",
+      description: "Update an endpoint's name, URI, protocol or config.",
+      inputSchema: {
+        endpointId: z12.string().describe("Endpoint id (see list_endpoints)"),
+        name: z12.string().optional(),
+        uri: z12.string().optional(),
+        protocol: protocolEnum4.optional(),
+        config: z12.string().optional()
+      }
+    },
+    async ({ endpointId, name, uri, protocol, config }) => guard(async () => {
+      const problem = uri ? externalEndpointProblem(uri) : null;
+      if (problem) return fail(problem);
+      const endpoint = await sdk().endpoints.update({ id: endpointId, name, uri, protocol, config });
+      return ok(`Updated endpoint (id: ${endpointId}).`, endpoint);
+    })
+  );
+  server.registerTool(
+    "delete_endpoint",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true },
+      title: "Delete endpoint",
+      description: "Permanently delete an endpoint.",
+      inputSchema: {
+        endpointId: z12.string().describe("Endpoint id (see list_endpoints)")
+      }
+    },
+    async ({ endpointId }) => guard(async () => {
+      await sdk().endpoints.delete(endpointId);
+      return ok(`Deleted endpoint ${endpointId}.`);
+    })
+  );
+}
+
+// src/tools/ocpp-configs.ts
+import { z as z13 } from "zod";
+var protocolEnum5 = z13.enum(["OCPP_1_6", "OCPP_2_0_1"]);
+var items1_6 = z13.array(z13.object({ key: z13.string(), value: z13.string().optional(), readonly: z13.boolean() })).describe("OCPP 1.6 configuration keys, e.g. [{ key: 'HeartbeatInterval', value: '60', readonly: false }]");
+var items2_0_1 = z13.array(
+  z13.object({
+    componentName: z13.string(),
+    variableName: z13.string(),
+    value: z13.string().describe("Value. An item without a value is not stored."),
+    mutabilityMode: z13.enum(["ReadOnly", "WriteOnly", "ReadWrite"]).optional(),
+    componentInstance: z13.string().optional(),
+    variableInstance: z13.string().optional(),
+    evseId: z13.number().int().optional(),
+    evseConnectorId: z13.number().int().optional()
+  })
+).describe(
+  "OCPP 2.0.1 component/variable pairs, e.g. [{ componentName: 'OCPPCommCtrlr', variableName: 'HeartbeatInterval', value: '30' }]"
+);
+var OUTPUT_ONLY = /* @__PURE__ */ new Set(["__typename", "simWorldId", "ocppConfigId"]);
+var V201_IDENTITY = ["componentName", "componentInstance", "variableName", "variableInstance", "evseId", "evseConnectorId"];
+function identityOf(item, isV201) {
+  return (isV201 ? V201_IDENTITY : ["key"]).map((field) => String(item[field] ?? "")).join("|");
+}
+function mergeItems(existing, changes, remove, isV201) {
+  const nameOf = (item) => String((isV201 ? item.variableName : item.key) ?? "");
+  const removed = /* @__PURE__ */ new Set();
+  for (const name of remove) {
+    const matches = existing.filter(
+      (item) => String(item.id) === name || nameOf(item) === name || `${item.componentName}/${item.variableName}` === name
+    );
+    if (matches.length === 0) throw new Error(`Nothing to remove for: ${name}.`);
+    if (matches.length > 1) {
+      const places = matches.map((item) => `${item.componentName}/${item.variableName}`).join(", ");
+      throw new Error(`"${name}" matches several items (${places}). Pass the item id from get_ocpp_config.`);
+    }
+    removed.add(matches[0]);
+  }
+  const kept = existing.filter((item) => !removed.has(item)).map((item) => Object.fromEntries(Object.entries(item).filter(([field]) => !OUTPUT_ONLY.has(field))));
+  const byIdentity = new Map(kept.map((item) => [identityOf(item, isV201), item]));
+  for (const change of changes) {
+    const current = byIdentity.get(identityOf(change, isV201));
+    if (current) Object.assign(current, change);
+    else {
+      kept.push(change);
+      byIdentity.set(identityOf(change, isV201), change);
+    }
+  }
+  return kept;
+}
+function registerOcppConfigTools(server) {
+  const projectArg = z13.string().optional().describe("Project name or id (defaults to active project)");
+  server.registerTool(
+    "list_ocpp_configs",
+    {
+      annotations: { readOnlyHint: true },
+      title: "List OCPP configs",
+      description: "List OCPP configurations in the active project's sim world. A config defines the OCPP key/values a simulator answers with; attach one when creating a simulator.",
+      inputSchema: {
+        search: z13.string().optional().describe("Filter by config name"),
+        ...paginationArgs,
+        project: projectArg
+      }
+    },
+    async ({ search, page: page2, pageSize, project }) => guard(async () => {
+      const ctx = await resolveSimWorld(project);
+      const result = await sdk().ocppConfigs.list({
+        simWorldId: ctx.simWorldId,
+        searchValue: search,
+        pagination: pagination(page2, pageSize)
+      });
+      return ok(
+        pageSummary("OCPP config(s)", result?.records?.length ?? 0, result?.pageInfo),
+        result
+      );
+    })
+  );
+  server.registerTool(
+    "get_ocpp_config",
+    {
+      annotations: { readOnlyHint: true },
+      title: "Get OCPP config",
+      description: "Get an OCPP configuration by id, with all its items.",
+      inputSchema: {
+        configId: z13.string().describe("OCPP config id (see list_ocpp_configs)")
+      }
+    },
+    async ({ configId }) => guard(async () => {
+      const config = await sdk().ocppConfigs.get(configId);
+      if (!config) return ok(`No OCPP config found with id ${configId}.`);
+      return ok(`OCPP config (id: ${configId}).`, {
+        ...config,
+        configItems: maskSecretItems(config.configItems ?? [])
+      });
+    })
+  );
+  server.registerTool(
+    "create_ocpp_config",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+      title: "Create OCPP config",
+      description: "Create an OCPP configuration. Items depend on protocol: 1.6 uses key/value entries, 2.0.1 uses component/variable entries. Next step: attach it to a simulator via create_simulator's ocppConfigId.",
+      inputSchema: {
+        name: z13.string().describe("Config name, e.g. 'Default 1.6 heartbeat 60'"),
+        protocol: protocolEnum5,
+        items1_6: items1_6.optional().describe("Required when protocol is OCPP_1_6"),
+        items2_0_1: items2_0_1.optional().describe("Required when protocol is OCPP_2_0_1"),
+        project: projectArg
+      }
+    },
+    async ({ name, protocol, items1_6: i16, items2_0_1: i201, project }) => guard(async () => {
+      const items = protocol === "OCPP_1_6" ? i16 : i201;
+      if (!items?.length) {
+        return fail(`Pass ${protocol === "OCPP_1_6" ? "items1_6" : "items2_0_1"} for a ${protocol} config.`);
+      }
+      const ctx = await resolveSimWorld(project);
+      const config = protocol === "OCPP_1_6" ? await sdk().ocppConfigs.create1_6({ simWorldId: ctx.simWorldId, name, configItems: i16 }) : await sdk().ocppConfigs.create2_0_1({ simWorldId: ctx.simWorldId, name, configItems: i201 });
+      return ok(`Created OCPP config "${name}" (id: ${config?.id}).`, config);
+    })
+  );
+  server.registerTool(
+    "update_ocpp_config",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+      title: "Update OCPP config",
+      description: "Update an OCPP configuration's name and items. Items you pass are changed or added; all others stay as they are. `remove` deletes items.",
+      inputSchema: {
+        configId: z13.string().describe("OCPP config id (see list_ocpp_configs)"),
+        name: z13.string().optional(),
+        items1_6: items1_6.optional().describe("For OCPP_1_6 configs: items to change or add"),
+        items2_0_1: items2_0_1.optional().describe("For OCPP_2_0_1 configs: items to change or add"),
+        remove: z13.array(z13.string()).optional().describe("Items to delete: item id from get_ocpp_config, key (1.6), variable name or component/variable (2.0.1)"),
+        project: projectArg
+      }
+    },
+    async ({ configId, name, items1_6: i16, items2_0_1: i201, remove, project }) => guard(async () => {
+      const ctx = await resolveSimWorld(project);
+      const current = await sdk().ocppConfigs.get(configId);
+      if (!current) return fail(`No OCPP config found with id ${configId}.`);
+      const isV201 = current.protocol === "OCPP_2_0_1";
+      if (isV201 ? i16 : i201) {
+        return fail(`Config ${configId} is ${current.protocol}: pass ${isV201 ? "items2_0_1" : "items1_6"}.`);
+      }
+      const changes = isV201 ? i201 : i16;
+      const configItems = changes || remove ? mergeItems(current.configItems ?? [], changes ?? [], remove ?? [], isV201) : void 0;
+      const config = isV201 ? await sdk().ocppConfigs.update2_0_1({ id: configId, simWorldId: ctx.simWorldId, name, configItems }) : await sdk().ocppConfigs.update1_6({ id: configId, simWorldId: ctx.simWorldId, name, configItems });
+      return ok(`Updated OCPP config (id: ${configId}).`, config);
+    })
+  );
+  server.registerTool(
+    "delete_ocpp_config",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true },
+      title: "Delete OCPP config",
+      description: "Permanently delete an OCPP configuration.",
+      inputSchema: {
+        configId: z13.string().describe("OCPP config id (see list_ocpp_configs)")
+      }
+    },
+    async ({ configId }) => guard(async () => {
+      await sdk().ocppConfigs.delete(configId);
+      return ok(`Deleted OCPP config ${configId}.`);
+    })
+  );
+}
+
+// src/tools/simulator-configs.ts
+import { z as z14 } from "zod";
+var protocolEnum6 = z14.enum(["OCPP_1_6", "OCPP_2_0_1"]);
+var chargingDirection = z14.enum(["CHARGING", "DISCHARGING", "BOTH"]);
+var powerDistribution = z14.enum(["SEQUENTIAL", "PARALLEL"]);
+function registerSimulatorConfigTools(server) {
+  const projectArg = z14.string().optional().describe("Project name or id (defaults to active project)");
+  server.registerTool(
+    "list_simulator_configs",
+    {
+      annotations: { readOnlyHint: true },
+      title: "List simulator configs",
+      description: "List simulator configs (behavior templates) in the active project's sim world, with their protocol, intervals, charging direction and vendor behavior. Models reference one. get_simulator_config shows what a specific simulator actually uses.",
+      inputSchema: {
+        search: z14.string().optional().describe("Filter by config name"),
+        ...paginationArgs,
+        project: projectArg
+      }
+    },
+    async ({ search, page: page2, pageSize, project }) => guard(async () => {
+      const ctx = await resolveSimWorld(project);
+      const result = await sdk().simulatorConfigs.list({
+        simWorldId: ctx.simWorldId,
+        searchValue: search,
+        pagination: pagination(page2, pageSize)
+      });
+      return ok(
+        pageSummary("simulator config(s)", result?.records?.length ?? 0, result?.pageInfo),
+        result
+      );
+    })
+  );
+  server.registerTool(
+    "create_simulator_config",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+      title: "Create simulator config",
+      description: "Create a simulator config (behavior template). New projects already have a default per protocol, so usually copy those values. Next step: reference it in create_model. Intervals are in seconds.",
+      inputSchema: {
+        name: z14.string().describe("Config name, e.g. 'Generic DC 150kW'"),
+        protocol: protocolEnum6,
+        supportedCommands: z14.array(z14.string()).describe("OCPP commands the charger supports, e.g. ['Reset', 'UnlockConnector']"),
+        callTimeoutInterval: z14.number().describe("Call timeout in seconds"),
+        defaultRetryInterval: z14.number().describe("Retry interval in seconds"),
+        authorizationExpirationTime: z14.number().describe("Authorization expiration in seconds"),
+        hardResetInterval: z14.number().describe("Hard reset interval in seconds"),
+        softResetInterval: z14.number().describe("Soft reset interval in seconds"),
+        heartbeatDefaultInterval: z14.number().int().optional().describe("Heartbeat interval in seconds"),
+        validIdTag: z14.string().optional().describe("idTag the simulator treats as valid"),
+        chargingDirection,
+        powerDistribution,
+        useRemoteTemplates: z14.boolean().describe(
+          "After a remote start: true plays the config's transaction template (default configs), false plays nothing, so the test needs a 'Charge a Vehicle' step"
+        ),
+        roundSocMeasurand: z14.boolean().describe("Round SoC values to integers"),
+        behavior: z14.string().describe("Vendor behavior: GENERIC, or a vendor name such as ABB, AUTEL, KEMPOWER"),
+        project: projectArg
+      }
+    },
+    async (input) => guard(async () => {
+      const ctx = await resolveSimWorld(input.project);
+      const {
+        project: _project,
+        supportedCommands,
+        ...rest
+      } = input;
+      const config = await sdk().simulatorConfigs.create({
+        simWorldId: ctx.simWorldId,
+        supportedCommands,
+        ...rest,
+        behavior: rest.behavior
+      });
+      return ok(`Created simulator config "${input.name}" (id: ${config?.id}).`, config);
+    })
+  );
+  server.registerTool(
+    "update_simulator_config",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+      title: "Update simulator config",
+      description: "Update a simulator config. Only the fields you pass change.",
+      inputSchema: {
+        configId: z14.string().describe("Simulator config id (see list_simulator_configs)"),
+        name: z14.string().optional(),
+        supportedCommands: z14.array(z14.string()).optional(),
+        callTimeoutInterval: z14.number().int().optional(),
+        defaultRetryInterval: z14.number().int().optional(),
+        authorizationExpirationTime: z14.number().int().optional(),
+        hardResetInterval: z14.number().int().optional(),
+        softResetInterval: z14.number().int().optional(),
+        heartbeatDefaultInterval: z14.number().int().optional(),
+        validIdTag: z14.string().optional(),
+        chargingDirection: chargingDirection.optional(),
+        powerDistribution: powerDistribution.optional(),
+        useRemoteTemplates: z14.boolean().optional(),
+        roundSocMeasurand: z14.boolean().optional(),
+        behavior: z14.string().optional().describe("GENERIC, or a vendor name such as ABB, AUTEL, KEMPOWER"),
+        project: projectArg
+      }
+    },
+    async ({ configId, project, behavior, chargingDirection: chargingDirection2, powerDistribution: powerDistribution2, useRemoteTemplates, roundSocMeasurand, ...rest }) => guard(async () => {
+      const ctx = await resolveSimWorld(project);
+      const current = await sdk().simulatorConfigs.get(configId);
+      if (!current) return fail(`No simulator config found with id ${configId}.`);
+      const config = await sdk().simulatorConfigs.update({
+        id: configId,
+        simWorldId: ctx.simWorldId,
+        ...rest,
+        supportedCommands: rest.supportedCommands ?? current.supportedCommands,
+        validIdTag: rest.validIdTag ?? current.validIdTag ?? void 0,
+        behavior,
+        chargingDirection: chargingDirection2 ?? current.chargingDirection,
+        powerDistribution: powerDistribution2 ?? current.powerDistribution,
+        useRemoteTemplates: useRemoteTemplates ?? current.useRemoteTemplates,
+        roundSocMeasurand: roundSocMeasurand ?? current.roundSocMeasurand
+      });
+      return ok(`Updated simulator config (id: ${configId}).`, config);
+    })
+  );
+  server.registerTool(
+    "delete_simulator_config",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true },
+      title: "Delete simulator config",
+      description: "Permanently delete a simulator config.",
+      inputSchema: {
+        configId: z14.string().describe("Simulator config id (see list_simulator_configs)")
+      }
+    },
+    async ({ configId }) => guard(async () => {
+      await sdk().simulatorConfigs.delete(configId);
+      return ok(`Deleted simulator config ${configId}.`);
+    })
+  );
+}
+
+// src/tools/tags.ts
+import { z as z15 } from "zod";
+var ENTITY_TYPES2 = { SIMULATOR: "CHARGER", TEST: "SCENARIO", TEST_PLAN: "TEST_PLAN", HARDWARE: "DEVICE" };
+var entityType = z15.enum(["SIMULATOR", "TEST", "TEST_PLAN", "HARDWARE"]);
+function registerTagTools(server) {
+  const projectArg = z15.string().optional().describe("Project name or id (defaults to active project)");
+  server.registerTool(
+    "list_tags",
+    {
+      annotations: { readOnlyHint: true },
+      title: "List tags",
+      description: "List tags in the active project. Tags label simulators, tests, plans and hardware.",
+      inputSchema: {
+        search: z15.string().optional().describe("Filter by tag name"),
+        ...paginationArgs,
+        project: projectArg
+      }
+    },
+    async ({ search, page: page2, pageSize, project }) => guard(async () => {
+      const ctx = await resolveSimWorld(project);
+      const result = await sdk().tags.list({
+        projectId: ctx.projectId,
+        searchValue: search,
+        pagination: pagination(page2, pageSize)
+      });
+      return ok(pageSummary("tag(s)", result?.records?.length ?? 0, result?.pageInfo), result);
+    })
+  );
+  server.registerTool(
+    "create_tag",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+      title: "Create tag",
+      description: "Create a tag in the active project.",
+      inputSchema: {
+        name: z15.string(),
+        color: z15.string().describe("Hex color, e.g. '#2563eb'"),
+        project: projectArg
+      }
+    },
+    async ({ name, color, project }) => guard(async () => {
+      const ctx = await resolveSimWorld(project);
+      const tag = await sdk().tags.create({ projectId: ctx.projectId, name, color });
+      return ok(`Created tag "${name}" (id: ${tag?.id}).`, tag);
+    })
+  );
+  server.registerTool(
+    "update_tag",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+      title: "Update tag",
+      description: "Rename a tag or change its color.",
+      inputSchema: {
+        tagId: z15.string().describe("Tag id (see list_tags)"),
+        name: z15.string().optional(),
+        color: z15.string().optional().describe("Hex color, e.g. '#2563eb'"),
+        project: projectArg
+      }
+    },
+    async ({ tagId, name, color, project }) => guard(async () => {
+      const ctx = await resolveSimWorld(project);
+      const tag = await sdk().tags.update({ id: tagId, projectId: ctx.projectId, name, color });
+      if (!tag) return fail(`No tag ${tagId} in project "${ctx.projectName}".`);
+      return ok(`Updated tag (id: ${tagId}).`, tag);
+    })
+  );
+  server.registerTool(
+    "delete_tag",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true },
+      title: "Delete tag",
+      description: "Permanently delete a tag and remove it from everything it labels.",
+      inputSchema: {
+        tagId: z15.string().describe("Tag id (see list_tags)"),
+        project: projectArg
+      }
+    },
+    async ({ tagId, project }) => guard(async () => {
+      const ctx = await resolveSimWorld(project);
+      const status = await sdk().tags.delete(tagId, ctx.projectId);
+      if (status === "ERROR") return fail(`No tag ${tagId} in project "${ctx.projectName}"; nothing was deleted.`);
+      return ok(`Deleted tag ${tagId}.`);
+    })
+  );
+  server.registerTool(
+    "link_tag",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+      title: "Link tag",
+      description: "Attach a tag to a simulator, test, test plan or hardware. Creates the tag if it doesn't exist yet (then name is required).",
+      inputSchema: {
+        entityId: z15.string().describe("Id of the simulator, test, plan or hardware to label"),
+        entityType,
+        tagId: z15.string().optional().describe("Existing tag id (see list_tags)"),
+        name: z15.string().optional().describe("Create-and-link when tagId is omitted"),
+        color: z15.string().optional().describe("Hex color for a created tag"),
+        project: projectArg
+      }
+    },
+    async ({ entityId, entityType: entityType2, tagId, name, color, project }) => guard(async () => {
+      const ctx = await resolveSimWorld(project);
+      const existing = tagId ? await sdk().tags.get(tagId, ctx.projectId) : null;
+      if (tagId && !existing) return fail(`No tag found with id ${tagId}.`);
+      if (!existing && (!name || !color)) return fail("Pass `tagId`, or `name` and `color` to create a tag.");
+      const tag = await sdk().tags.linkOrCreate({
+        projectId: ctx.projectId,
+        entityId,
+        entityType: ENTITY_TYPES2[entityType2],
+        tagId,
+        name: existing?.name ?? name,
+        color: existing?.color ?? color
+      });
+      return ok(`Linked tag "${tag?.name}" (id: ${tag?.id}) to ${entityType2} ${entityId}.`, tag);
+    })
+  );
+  server.registerTool(
+    "unlink_tag",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+      title: "Unlink tag",
+      description: "Remove a tag from a simulator, test, test plan or hardware. The tag itself stays.",
+      inputSchema: {
+        tagId: z15.string().describe("Tag id"),
+        entityId: z15.string().describe("Id of the labelled simulator, test, plan or hardware"),
+        entityType,
+        project: projectArg
+      }
+    },
+    async ({ tagId, entityId, entityType: entityType2, project }) => guard(async () => {
+      const ctx = await resolveSimWorld(project);
+      const status = await sdk().tags.unlink({
+        projectId: ctx.projectId,
+        tagId,
+        entityId,
+        entityType: ENTITY_TYPES2[entityType2]
+      });
+      if (status === "ERROR") return fail(`Tag ${tagId} is not on ${entityType2} ${entityId}; nothing changed.`);
+      return ok(`Unlinked tag ${tagId} from ${entityType2} ${entityId}.`);
+    })
+  );
+}
+
+// src/tools/index.ts
+var READONLY_ENV = "TIMETICK_MCP_READONLY";
+function isReadOnlyMode(env = process.env) {
+  const value = env[READONLY_ENV]?.trim().toLowerCase();
+  return value === "1" || value === "true";
+}
+function readOnlyView(server) {
+  return new Proxy(server, {
+    get(target, prop, receiver) {
+      if (prop !== "registerTool") return Reflect.get(target, prop, receiver);
+      return (name, config, cb) => config.annotations?.readOnlyHint === true ? target.registerTool(name, config, cb) : void 0;
+    }
+  });
+}
+function registerTools(server, options) {
+  const target = options.readOnly ? readOnlyView(server) : server;
+  registerAuthTools(server, target);
+  registerContextTools(target);
+  registerDataTools(target);
+  registerSimulatorTools(target);
+  registerTestTools(target);
+  registerTestRunTools(target);
+  registerTestPlanTools(target);
+  registerSupportTools(target);
+  registerApiKeyTools(target);
+  registerProjectTools(target);
+  registerCatalogTools(target);
+  registerOcppConfigTools(target);
+  registerSimulatorConfigTools(target);
+  registerTagTools(target);
+}
+
+// src/index.ts
+async function main() {
+  allowSlowConnections();
+  const loggedIn = await loadCredentials();
+  const readOnly = isReadOnlyMode();
+  const server = new McpServer(
+    { name: "timetick", version: VERSION },
+    { instructions: SERVER_INSTRUCTIONS }
+  );
+  registerTools(server, { readOnly });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error(
+    `Timetick MCP server ${VERSION} running on stdio${readOnly ? " (read-only)" : ""}${loggedIn || process.env.TIMETICK_API_TOKEN ? "" : ": not logged in yet, call the login tool"}`
+  );
+  void updateNotice().then((notice) => {
+    if (notice) console.error(`Timetick MCP: ${notice}`);
+  });
 }
 main().catch((error) => {
-  console.error("Fatal error starting Timetick MCP server:", error);
+  console.error("Fatal error in Timetick MCP server:", error);
   process.exit(1);
 });
-//# sourceMappingURL=index.js.map