trxa-tool 0.1.1 → 0.2.0

package/studio/server/dist/index.js

@@ -1,7 +1,7 @@
 // studio/server/index.ts
 import express2 from "express";
 import { existsSync } from "node:fs";
-import path11 from "node:path";
+import path15 from "node:path";
 
 // studio/server/routes/recordings.ts
 import { Router } from "express";
@@ -569,10 +569,11 @@ function propertyHint(step) {
       note: `Value was entered on a grid-bound control (UserActionType="${UserActionType}"); may be a filter rather than a cell edit.`
     };
   }
+  const liveControlName = ControlName === "PurchParmTable_gridParmTableNum" ? "PurchParmTable_Num" : ControlName;
   return {
     tool: "form_set_control_values",
     confidence: "high",
-    params: { setControlValues: [{ controlName: ControlName, value: formattedValue }] },
+    params: { setControlValues: [{ controlName: liveControlName, value: formattedValue }] },
     followUp: [
       {
         tool: "form_save_form",
@@ -737,6 +738,9 @@ var TESTRUNS_DIR = path.join(WORKING_FOLDER, "testruns");
 var SUITES_DIR = path.join(WORKING_FOLDER, "suites");
 var PLANS_DIR = path.join(WORKING_FOLDER, "plans");
 var RUNS_DIR = path.join(WORKING_FOLDER, "runs");
+function getWorkingFolder() {
+  return WORKING_FOLDER;
+}
 function allDataDirs() {
   return [RECORDINGS_DIR, TESTCASES_DIR, TESTDATA_DIR, TESTSCRIPTS_DIR, TESTRUNS_DIR, SUITES_DIR, PLANS_DIR, RUNS_DIR];
 }
@@ -942,6 +946,7 @@ testCasesRouter.get("/", async (_req, res) => {
         description: testCase.description,
         inputCount: testCase.inputs.length,
         outputCount: testCase.outputs.length,
+        inputs: testCase.inputs,
         sourceRecordingFolder: testCase.sourceRecordingFolder
       });
     } catch (err) {
@@ -951,6 +956,7 @@ testCasesRouter.get("/", async (_req, res) => {
         description: `Invalid test case file: ${err instanceof Error ? err.message : String(err)}`,
         inputCount: 0,
         outputCount: 0,
+        inputs: [],
         invalid: true
       });
     }
@@ -1008,7 +1014,7 @@ testCasesRouter.post("/", async (req, res) => {
   const testCase = validateTestCase({
     id,
     name: body.name,
-    description: trimmedDescription.length > 0 ? trimmedDescription : `Created via trxa-tool Studio from ${body.sourceRecording}.`,
+    description: trimmedDescription.length > 0 ? trimmedDescription : `Created via TRXA Studio from ${body.sourceRecording}.`,
     testScriptPath: `../testscripts/${testScriptFileName}`,
     ...sourceRecordingFolder ? { sourceRecordingFolder } : {},
     inputs: body.inputs ?? [],
@@ -1038,157 +1044,511 @@ testCasesRouter.delete("/:id", async (req, res) => {
 
 // studio/server/routes/fixtures.ts
 import { Router as Router3 } from "express";
-import { readdir as readdir3, readFile as readFile3, writeFile as writeFile2, unlink as unlink2, stat as stat2 } from "node:fs/promises";
-import path4 from "node:path";
+import { readdir as readdir4, readFile as readFile4, writeFile as writeFile3, unlink as unlink3, rename } from "node:fs/promises";
+import path5 from "node:path";
 
 // src/fixture-schema.ts
+var FIXTURE_NAME_MAX_LENGTH = 64;
+var FIXTURE_NAME_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9 ._-]*[A-Za-z0-9_-])?$/;
+function fixtureNameProblem(name) {
+  if (name.length === 0) return "must not be empty";
+  if (name.length > FIXTURE_NAME_MAX_LENGTH) return `must be at most ${FIXTURE_NAME_MAX_LENGTH} characters`;
+  if (!FIXTURE_NAME_PATTERN.test(name)) {
+    return "may only use letters, digits, spaces, dots, underscores and hyphens, starting with a letter or digit and not ending with a dot or space";
+  }
+  return null;
+}
 function fail2(field, reason) {
   throw new Error(`Invalid Fixture: ${field} ${reason}`);
 }
 function assertString2(value, field) {
   if (typeof value !== "string" || value.length === 0) fail2(field, "must be a non-empty string");
 }
+function assertStringMap(value, field) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    fail2(field, "must be an object mapping param names to string values");
+  }
+  for (const [key, val] of Object.entries(value)) {
+    if (typeof val !== "string") fail2(`${field}.${key}`, "must be a string");
+  }
+}
+function isLegacyFixture(value) {
+  return typeof value === "object" && value !== null && "testCaseId" in value && !("testCases" in value);
+}
 function validateFixture(value) {
+  if (typeof value !== "object" || value === null) fail2("fixture", "must be an object");
+  const v = value;
+  assertString2(v.name, "name");
+  const problem = fixtureNameProblem(v.name);
+  if (problem) fail2("name", problem);
+  if (typeof v.description !== "string") fail2("description", "must be a string");
+  if (typeof v.testCases !== "object" || v.testCases === null || Array.isArray(v.testCases)) {
+    fail2("testCases", "must be an object mapping test case ids to their values");
+  }
+  const testCases = {};
+  for (const [testCaseId, values] of Object.entries(v.testCases)) {
+    if (testCaseId.length === 0) fail2("testCases", "must not contain an empty test case id");
+    assertStringMap(values, `testCases.${testCaseId}`);
+    testCases[testCaseId] = { ...values };
+  }
+  return { name: v.name, description: v.description, testCases };
+}
+function validateLegacyFixture(value) {
   if (typeof value !== "object" || value === null) fail2("fixture", "must be an object");
   const v = value;
   assertString2(v.testCaseId, "testCaseId");
   assertString2(v.name, "name");
-  assertString2(v.description, "description");
-  if (typeof v.values !== "object" || v.values === null || Array.isArray(v.values)) {
-    fail2("values", "must be an object mapping param names to string values");
+  if (typeof v.description !== "string") fail2("description", "must be a string");
+  assertStringMap(v.values, "values");
+  return { testCaseId: v.testCaseId, name: v.name, description: v.description, values: { ...v.values } };
+}
+function validateFixtureFile(value) {
+  if (!isLegacyFixture(value)) return validateFixture(value);
+  const legacy = validateLegacyFixture(value);
+  return { name: legacy.name, description: legacy.description, testCases: { [legacy.testCaseId]: legacy.values } };
+}
+function mergeFixtures(sources) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const { source, fixture } of sources) {
+    const key = fixture.name.toLowerCase();
+    let entry = merged.get(key);
+    if (!entry) {
+      entry = { fixture: { name: fixture.name, description: fixture.description, testCases: {} }, sources: [], slices: /* @__PURE__ */ new Map() };
+      merged.set(key, entry);
+    }
+    if (!entry.fixture.description && fixture.description) entry.fixture.description = fixture.description;
+    entry.sources.push(source);
+    for (const [testCaseId, values] of Object.entries(fixture.testCases)) {
+      const previous = entry.slices.get(testCaseId);
+      if (previous) {
+        throw new Error(
+          `Fixture "${fixture.name}" has values for test case "${testCaseId}" in both ${previous} and ${source}. Keep one of them.`
+        );
+      }
+      entry.slices.set(testCaseId, source);
+      entry.fixture.testCases[testCaseId] = { ...values };
+    }
+  }
+  return [...merged.values()].map(({ fixture, sources: sources2 }) => ({ fixture, sources: sources2 }));
+}
+function serializeFixture(fixture) {
+  const testCases = {};
+  for (const id of Object.keys(fixture.testCases).sort((a, b) => a.localeCompare(b))) testCases[id] = fixture.testCases[id];
+  return JSON.stringify({ name: fixture.name, description: fixture.description, testCases }, null, 2) + "\n";
+}
+
+// src/fixture-store.ts
+import { readdir as readdir3, readFile as readFile3, writeFile as writeFile2, unlink as unlink2 } from "node:fs/promises";
+import path4 from "node:path";
+async function readFixtureFolder(dir) {
+  let entries;
+  try {
+    entries = (await readdir3(dir)).filter((f) => f.endsWith(".json")).sort((a, b) => a.localeCompare(b));
+  } catch {
+    return { fixtures: [], legacyFiles: [], invalid: [] };
+  }
+  const sources = [];
+  const legacyFiles = [];
+  const invalid = [];
+  for (const file of entries) {
+    try {
+      const raw = JSON.parse(await readFile3(path4.join(dir, file), "utf-8"));
+      if (isLegacyFixture(raw)) legacyFiles.push(file);
+      sources.push({ source: file, fixture: validateFixtureFile(raw) });
+    } catch (err) {
+      invalid.push({ file, error: err instanceof Error ? err.message : String(err) });
+    }
+  }
+  sources.sort((a, b) => Number(legacyFiles.includes(a.source)) - Number(legacyFiles.includes(b.source)));
+  const fixtures = mergeFixtures(sources).map(({ fixture, sources: sources2 }) => ({ fixture, files: sources2 }));
+  return { fixtures, legacyFiles, invalid };
+}
+function needsMigration(fixture, files, legacyFiles) {
+  if (files.some((f) => legacyFiles.includes(f))) return true;
+  return files.length !== 1 || files[0].toLowerCase() !== `${fixture.name}.json`.toLowerCase();
+}
+async function migrateFixtureFolder(dir, options = {}) {
+  const folder = await readFixtureFolder(dir);
+  if (folder.invalid.length > 0) {
+    throw new Error(
+      `Fix or remove these files first: ${folder.invalid.map((i) => `${i.file} (${i.error})`).join("; ")}`
+    );
+  }
+  const plan = [];
+  for (const { fixture, files } of folder.fixtures) {
+    if (!needsMigration(fixture, files, folder.legacyFiles)) continue;
+    const problem = fixtureNameProblem(fixture.name);
+    if (problem) {
+      throw new Error(`Fixture name "${fixture.name}" (in ${files.join(", ")}) can't be used as a file name: it ${problem}. Rename it first.`);
+    }
+    const file = `${fixture.name}.json`;
+    plan.push({ file, fixture, from: files });
+  }
+  const result = {
+    written: plan.map(({ file, fixture, from }) => ({ file, fixture: fixture.name, from })),
+    removed: plan.flatMap(({ file, from }) => from.filter((f) => f.toLowerCase() !== file.toLowerCase()))
+  };
+  if (options.dryRun) return result;
+  for (const { file, fixture } of plan) await writeFile2(path4.join(dir, file), serializeFixture(fixture), "utf-8");
+  for (const file of result.removed) await unlink2(path4.join(dir, file));
+  return result;
+}
+
+// src/suite-schema.ts
+function fail3(field, reason) {
+  throw new Error(`Invalid TestSuite: ${field} ${reason}`);
+}
+function assertString3(value, field) {
+  if (typeof value !== "string" || value.length === 0) fail3(field, "must be a non-empty string");
+}
+function validateInputBinding(value, field) {
+  if (typeof value !== "object" || value === null) fail3(field, "must be an object");
+  const v = value;
+  if (v.kind === "fixture") {
+    assertString3(v.fixtureName, `${field}.fixtureName`);
+    assertString3(v.param, `${field}.param`);
+  } else if (v.kind === "testCaseOutput") {
+    assertString3(v.testCaseId, `${field}.testCaseId`);
+    assertString3(v.outputName, `${field}.outputName`);
+  } else if (v.kind === "literal") {
+    assertString3(v.value, `${field}.value`);
+  } else if (v.kind === "autogenerated") {
+  } else {
+    fail3(`${field}.kind`, 'must be "fixture", "testCaseOutput", "literal", or "autogenerated"');
+  }
+  return v;
+}
+var VALID_COMPARATORS = ["equals", "notEquals", "contains", "greaterThan", "lessThan"];
+function validateRunCondition(value, field) {
+  if (typeof value !== "object" || value === null) fail3(field, "must be an object");
+  const v = value;
+  assertString3(v.testCaseId, `${field}.testCaseId`);
+  assertString3(v.outputName, `${field}.outputName`);
+  if (!VALID_COMPARATORS.includes(v.comparator)) {
+    fail3(`${field}.comparator`, `must be one of ${VALID_COMPARATORS.join(", ")}`);
+  }
+  assertString3(v.value, `${field}.value`);
+  return v;
+}
+function validateTestSuiteEntry(value, index) {
+  if (typeof value !== "object" || value === null) fail3(`entries[${index}]`, "must be an object");
+  const v = value;
+  assertString3(v.testCaseId, `entries[${index}].testCaseId`);
+  if (!Array.isArray(v.dependsOn) || !v.dependsOn.every((d) => typeof d === "string")) {
+    fail3(`entries[${index}].dependsOn`, "must be an array of testCaseId strings");
+  }
+  if (typeof v.inputBindings !== "object" || v.inputBindings === null || Array.isArray(v.inputBindings)) {
+    fail3(`entries[${index}].inputBindings`, "must be an object mapping param names to bindings");
   }
-  for (const [key, val] of Object.entries(v.values)) {
-    if (typeof val !== "string") fail2(`values.${key}`, "must be a string");
+  const inputBindings = {};
+  for (const [param, binding] of Object.entries(v.inputBindings)) {
+    inputBindings[param] = validateInputBinding(binding, `entries[${index}].inputBindings.${param}`);
   }
+  if (v.legalEntity !== void 0) assertString3(v.legalEntity, `entries[${index}].legalEntity`);
+  const runIf = v.runIf !== void 0 ? validateRunCondition(v.runIf, `entries[${index}].runIf`) : void 0;
   return {
     testCaseId: v.testCaseId,
+    dependsOn: v.dependsOn,
+    inputBindings,
+    ...v.legalEntity !== void 0 ? { legalEntity: v.legalEntity } : {},
+    ...runIf !== void 0 ? { runIf } : {}
+  };
+}
+function validateTestSuite(value) {
+  if (typeof value !== "object" || value === null) fail3("suite", "must be an object");
+  const v = value;
+  assertString3(v.id, "id");
+  assertString3(v.name, "name");
+  assertString3(v.description, "description");
+  if (!Array.isArray(v.entries)) fail3("entries", "must be an array");
+  return {
+    id: v.id,
     name: v.name,
     description: v.description,
-    values: v.values
+    entries: v.entries.map(validateTestSuiteEntry)
   };
 }
 
 // studio/server/routes/fixtures.ts
 var fixturesRouter = Router3();
-async function fileExists2(filePath) {
-  try {
-    await stat2(filePath);
+var sameName = (a, b) => a.toLowerCase() === b.toLowerCase();
+var fixturePath = (name) => path5.join(TESTDATA_DIR, `${name}.json`);
+async function findFixture(name) {
+  const folder = await readFixtureFolder(TESTDATA_DIR);
+  const found = folder.fixtures.find((f) => sameName(f.fixture.name, name));
+  return found ? { ...found, needsMigration: needsMigration(found.fixture, found.files, folder.legacyFiles) } : null;
+}
+async function rejectNewName(res, name, except) {
+  if (typeof name !== "string") {
+    res.status(400).json({ error: "A fixture name is required" });
+    return true;
+  }
+  const problem = fixtureNameProblem(name);
+  if (problem) {
+    res.status(400).json({ error: `A fixture name ${problem}` });
+    return true;
+  }
+  if (except && sameName(name, except)) return false;
+  if (await findFixture(name)) {
+    res.status(409).json({ error: `A fixture named "${name}" already exists` });
     return true;
-  } catch {
-    return false;
   }
+  return false;
 }
-fixturesRouter.get("/", async (_req, res) => {
-  const files = (await readdir3(TESTDATA_DIR)).filter((f) => f.endsWith(".json"));
-  const summaries = [];
+async function readSuites() {
+  const files = (await readdir4(SUITES_DIR)).filter((f) => f.endsWith(".json"));
+  const suites = [];
   for (const file of files) {
-    const slug = file.replace(/\.json$/, "");
     try {
-      const raw = JSON.parse(await readFile3(path4.join(TESTDATA_DIR, file), "utf-8"));
-      const fixture = validateFixture(raw);
-      summaries.push({ file: slug, name: fixture.name, testCaseId: fixture.testCaseId, description: fixture.description });
-    } catch (err) {
-      summaries.push({
-        file: slug,
-        name: file,
-        testCaseId: "",
-        description: "",
-        invalid: true,
-        error: err instanceof Error ? err.message : String(err)
-      });
+      suites.push({ file: file.replace(/\.json$/, ""), suite: validateTestSuite(JSON.parse(await readFile4(path5.join(SUITES_DIR, file), "utf-8"))) });
+    } catch {
     }
   }
-  res.json({ fixtures: summaries });
+  return suites;
+}
+function usageOf(suite, fixtureName) {
+  return suite.entries.filter((e) => Object.values(e.inputBindings).some((b) => b.kind === "fixture" && sameName(b.fixtureName, fixtureName))).map((e) => e.testCaseId);
+}
+fixturesRouter.get("/", async (_req, res) => {
+  const folder = await readFixtureFolder(TESTDATA_DIR);
+  const fixtures = folder.fixtures.map(({ fixture, files }) => ({
+    name: fixture.name,
+    description: fixture.description,
+    testCaseIds: Object.keys(fixture.testCases),
+    ...needsMigration(fixture, files, folder.legacyFiles) ? { needsMigration: true } : {}
+  }));
+  for (const bad of folder.invalid) {
+    fixtures.push({ name: bad.file, description: "", testCaseIds: [], invalid: true, error: bad.error });
+  }
+  res.json({ fixtures, legacyFiles: folder.legacyFiles });
 });
-fixturesRouter.get("/:file", async (req, res) => {
-  const slug = safeFileName(req.params.file);
-  const raw = JSON.parse(await readFile3(path4.join(TESTDATA_DIR, `${slug}.json`), "utf-8"));
-  res.json(validateFixture(raw));
+fixturesRouter.post("/migrate", async (_req, res) => {
+  res.json(await migrateFixtureFolder(TESTDATA_DIR));
+});
+fixturesRouter.get("/:name", async (req, res) => {
+  const found = await findFixture(req.params.name);
+  if (!found) {
+    res.status(404).json({ error: `No fixture named "${req.params.name}"` });
+    return;
+  }
+  res.json({ ...found.fixture, needsMigration: found.needsMigration });
+});
+fixturesRouter.get("/:name/usage", async (req, res) => {
+  const usage = [];
+  for (const { file, suite } of await readSuites()) {
+    const testCaseIds = usageOf(suite, req.params.name);
+    if (testCaseIds.length > 0) usage.push({ file, id: suite.id, name: suite.name, testCaseIds });
+  }
+  res.json({ suites: usage });
 });
 fixturesRouter.post("/", async (req, res) => {
   const body = req.body;
-  if (typeof body.file !== "string" || body.file.length === 0) {
-    res.status(400).json({ error: '"file" (the filename slug) is required' });
+  if (await rejectNewName(res, body.name)) return;
+  const fixture = validateFixture({ testCases: {}, ...body });
+  await writeFile3(fixturePath(fixture.name), serializeFixture(fixture), "utf-8");
+  res.status(201).json(fixture);
+});
+fixturesRouter.post("/:name/duplicate", async (req, res) => {
+  const found = await findFixture(req.params.name);
+  if (!found) {
+    res.status(404).json({ error: `No fixture named "${req.params.name}"` });
     return;
   }
-  const slug = safeFileName(body.file);
-  const fixture = validateFixture(body);
-  const filePath = path4.join(TESTDATA_DIR, `${slug}.json`);
-  if (await fileExists2(filePath)) {
-    res.status(409).json({ error: `Fixture file "${slug}.json" already exists` });
+  const body = req.body;
+  if (await rejectNewName(res, body.name)) return;
+  const copy = validateFixture({
+    name: body.name,
+    description: typeof body.description === "string" ? body.description : found.fixture.description,
+    testCases: found.fixture.testCases
+  });
+  await writeFile3(fixturePath(copy.name), serializeFixture(copy), "utf-8");
+  res.status(201).json(copy);
+});
+fixturesRouter.put("/:name/testcases/:testCaseId", async (req, res) => {
+  const { name, testCaseId } = req.params;
+  const body = req.body;
+  const found = await findFixture(name);
+  if (found?.needsMigration) {
+    res.status(409).json({ error: `Fixture "${found.fixture.name}" uses the old file format. Merge the fixture files on the Fixtures screen first.` });
     return;
   }
-  await writeFile2(filePath, JSON.stringify(fixture, null, 2) + "\n", "utf-8");
-  res.status(201).json({ file: slug, ...fixture });
+  if (!found && await rejectNewName(res, name)) return;
+  const fixture = found ? found.fixture : { name, description: typeof body.description === "string" ? body.description : "", testCases: {} };
+  if (fixture.testCases[testCaseId]) {
+    res.status(409).json({ error: `Fixture "${fixture.name}" already has values for test case "${testCaseId}"` });
+    return;
+  }
+  const next = validateFixture({ ...fixture, testCases: { ...fixture.testCases, [testCaseId]: body.values ?? {} } });
+  await writeFile3(fixturePath(next.name), serializeFixture(next), "utf-8");
+  res.json(next);
 });
-fixturesRouter.put("/:file", async (req, res) => {
-  const slug = safeFileName(req.params.file);
-  const filePath = path4.join(TESTDATA_DIR, `${slug}.json`);
-  if (!await fileExists2(filePath)) {
-    res.status(404).json({ error: `Fixture file "${slug}.json" does not exist` });
+fixturesRouter.put("/:name", async (req, res) => {
+  const found = await findFixture(req.params.name);
+  if (!found) {
+    res.status(404).json({ error: `No fixture named "${req.params.name}"` });
     return;
   }
-  const existing = validateFixture(JSON.parse(await readFile3(filePath, "utf-8")));
-  const fixture = validateFixture({ ...req.body, testCaseId: existing.testCaseId });
-  await writeFile2(filePath, JSON.stringify(fixture, null, 2) + "\n", "utf-8");
-  res.json({ file: slug, ...fixture });
+  if (found.needsMigration) {
+    res.status(409).json({ error: `Fixture "${found.fixture.name}" uses the old file format. Merge the fixture files first.` });
+    return;
+  }
+  const oldName = found.fixture.name;
+  const body = req.body;
+  if (await rejectNewName(res, body.name, oldName)) return;
+  const fixture = validateFixture(body);
+  const suitesUpdated = [];
+  if (fixture.name !== oldName) {
+    await rename(path5.join(TESTDATA_DIR, found.files[0]), fixturePath(fixture.name));
+    for (const { file, suite } of await readSuites()) {
+      if (usageOf(suite, oldName).length === 0) continue;
+      for (const entry of suite.entries) {
+        for (const binding of Object.values(entry.inputBindings)) {
+          if (binding.kind === "fixture" && sameName(binding.fixtureName, oldName)) binding.fixtureName = fixture.name;
+        }
+      }
+      await writeFile3(path5.join(SUITES_DIR, `${file}.json`), JSON.stringify(suite, null, 2) + "\n", "utf-8");
+      suitesUpdated.push(file);
+    }
+  }
+  await writeFile3(fixturePath(fixture.name), serializeFixture(fixture), "utf-8");
+  res.json({ fixture, suitesUpdated });
 });
-fixturesRouter.delete("/:file", async (req, res) => {
-  const slug = safeFileName(req.params.file);
-  await unlink2(path4.join(TESTDATA_DIR, `${slug}.json`));
+fixturesRouter.delete("/:name", async (req, res) => {
+  const found = await findFixture(req.params.name);
+  if (!found) {
+    res.status(404).json({ error: `No fixture named "${req.params.name}"` });
+    return;
+  }
+  for (const file of found.files) await unlink3(path5.join(TESTDATA_DIR, file));
   res.status(204).end();
 });
 
 // studio/server/routes/testruns.ts
 import { Router as Router4 } from "express";
-import { readdir as readdir4, readFile as readFile4, unlink as unlink3 } from "node:fs/promises";
-import path5 from "node:path";
+import { readdir as readdir5, readFile as readFile5, unlink as unlink4 } from "node:fs/promises";
+import path6 from "node:path";
+
+// src/planrun-schema.ts
+var RUN_NAME_MAX_LENGTH = 120;
+function normalizeRunName(value, field = "name") {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "string") throw new Error(`Invalid run name: ${field} must be a string`);
+  const name = value.trim().replace(/\s+/g, " ");
+  if (name.length > RUN_NAME_MAX_LENGTH) {
+    throw new Error(`Invalid run name: ${field} must be at most ${RUN_NAME_MAX_LENGTH} characters`);
+  }
+  return name || void 0;
+}
+function createPlanRun(planId, suites, name) {
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const runName = normalizeRunName(name);
+  return {
+    id: startedAt.replace(/:/g, "-"),
+    planId,
+    startedAt,
+    suiteIds: suites.map((s) => s.id),
+    suiteNames: Object.fromEntries(suites.map((s) => [s.id, s.name])),
+    ...runName ? { name: runName } : {}
+  };
+}
+function fail4(field, reason) {
+  throw new Error(`Invalid PlanRun: ${field} ${reason}`);
+}
+function assertString4(value, field) {
+  if (typeof value !== "string" || value.length === 0) fail4(field, "must be a non-empty string");
+}
+function assertSuiteIds(value) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value)) fail4("suiteIds", "must be an array of strings");
+  for (const [i, entry] of value.entries()) assertString4(entry, `suiteIds[${i}]`);
+  return value;
+}
+function assertSuiteNames(value) {
+  if (value === void 0) return {};
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    fail4("suiteNames", "must be an object mapping suiteId to name");
+  }
+  const v = value;
+  for (const [id, name] of Object.entries(v)) assertString4(name, `suiteNames.${id}`);
+  return v;
+}
+function validatePlanRun(value) {
+  if (typeof value !== "object" || value === null) fail4("planRun", "must be an object");
+  const v = value;
+  assertString4(v.id, "id");
+  assertString4(v.planId, "planId");
+  assertString4(v.startedAt, "startedAt");
+  const suiteIds = assertSuiteIds(v.suiteIds);
+  const suiteNames = assertSuiteNames(v.suiteNames);
+  let name;
+  try {
+    name = normalizeRunName(v.name);
+  } catch (err) {
+    fail4("name", err.message.replace(/^Invalid run name: name /, ""));
+  }
+  return { id: v.id, planId: v.planId, startedAt: v.startedAt, suiteIds, suiteNames, ...name ? { name } : {} };
+}
 
 // src/report-schema.ts
 var TERMINAL_STATUSES = /* @__PURE__ */ new Set(
   ["passed", "failed", "blocked", "skipped"]
 );
-function fail3(field, reason) {
+function createTestRun(suiteId, testCaseIds, extra = {}) {
+  const name = normalizeRunName(extra.name);
+  const results = {};
+  for (const id of testCaseIds) {
+    results[id] = { status: "pending", outputs: {}, assertionResults: [] };
+  }
+  return {
+    suiteId,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    results,
+    ...extra.scope !== void 0 ? { scope: extra.scope } : {},
+    ...extra.agentRunId !== void 0 ? { agentRunId: extra.agentRunId } : {},
+    ...name ? { name } : {}
+  };
+}
+function fail5(field, reason) {
   throw new Error(`Invalid TestRun: ${field} ${reason}`);
 }
-function assertString3(value, field) {
-  if (typeof value !== "string" || value.length === 0) fail3(field, "must be a non-empty string");
+function assertString5(value, field) {
+  if (typeof value !== "string" || value.length === 0) fail5(field, "must be a non-empty string");
 }
 var VALID_STATUSES = ["pending", "running", "passed", "failed", "blocked", "skipped"];
 function validateTestCaseResult(value, testCaseId) {
   if (typeof value !== "object" || value === null) {
-    fail3(`results.${testCaseId}`, "must be an object");
+    fail5(`results.${testCaseId}`, "must be an object");
   }
   const v = value;
   if (!VALID_STATUSES.includes(v.status)) {
-    fail3(`results.${testCaseId}.status`, `must be one of ${VALID_STATUSES.join(", ")}`);
+    fail5(`results.${testCaseId}.status`, `must be one of ${VALID_STATUSES.join(", ")}`);
   }
   if (typeof v.outputs !== "object" || v.outputs === null || Array.isArray(v.outputs)) {
-    fail3(`results.${testCaseId}.outputs`, "must be an object");
+    fail5(`results.${testCaseId}.outputs`, "must be an object");
   }
   if (!Array.isArray(v.assertionResults)) {
-    fail3(`results.${testCaseId}.assertionResults`, "must be an array");
+    fail5(`results.${testCaseId}.assertionResults`, "must be an array");
   }
   if (v.sequence !== void 0 && typeof v.sequence !== "number") {
-    fail3(`results.${testCaseId}.sequence`, "must be a number");
+    fail5(`results.${testCaseId}.sequence`, "must be a number");
   }
   if (v.inputs !== void 0 && (typeof v.inputs !== "object" || v.inputs === null || Array.isArray(v.inputs))) {
-    fail3(`results.${testCaseId}.inputs`, "must be an object");
+    fail5(`results.${testCaseId}.inputs`, "must be an object");
   }
   if (v.startedAt !== void 0 && typeof v.startedAt !== "string") {
-    fail3(`results.${testCaseId}.startedAt`, "must be a string");
+    fail5(`results.${testCaseId}.startedAt`, "must be a string");
   }
   if (v.durationMs !== void 0 && typeof v.durationMs !== "number") {
-    fail3(`results.${testCaseId}.durationMs`, "must be a number");
+    fail5(`results.${testCaseId}.durationMs`, "must be a number");
   }
   if (v.tokensUsed !== void 0 && typeof v.tokensUsed !== "number") {
-    fail3(`results.${testCaseId}.tokensUsed`, "must be a number");
+    fail5(`results.${testCaseId}.tokensUsed`, "must be a number");
   }
   if (v.costUsd !== void 0 && typeof v.costUsd !== "number") {
-    fail3(`results.${testCaseId}.costUsd`, "must be a number");
+    fail5(`results.${testCaseId}.costUsd`, "must be a number");
   }
   if (v.messages !== void 0 && (!Array.isArray(v.messages) || !v.messages.every((m) => typeof m === "string"))) {
-    fail3(`results.${testCaseId}.messages`, "must be an array of strings");
+    fail5(`results.${testCaseId}.messages`, "must be an array of strings");
   }
   return {
     status: v.status,
@@ -1204,35 +1564,59 @@ function validateTestCaseResult(value, testCaseId) {
   };
 }
 function validateTestRun(value) {
-  if (typeof value !== "object" || value === null) fail3("testRun", "must be an object");
+  if (typeof value !== "object" || value === null) fail5("testRun", "must be an object");
   const v = value;
-  assertString3(v.suiteId, "suiteId");
-  assertString3(v.startedAt, "startedAt");
+  assertString5(v.suiteId, "suiteId");
+  assertString5(v.startedAt, "startedAt");
   if (typeof v.results !== "object" || v.results === null || Array.isArray(v.results)) {
-    fail3("results", "must be an object mapping testCaseId to TestCaseResult");
+    fail5("results", "must be an object mapping testCaseId to TestCaseResult");
   }
   const results = {};
   for (const [id, result] of Object.entries(v.results)) {
     results[id] = validateTestCaseResult(result, id);
   }
-  return { suiteId: v.suiteId, startedAt: v.startedAt, results };
+  if (v.scope !== void 0 && v.scope !== "suite" && v.scope !== "testcase") {
+    fail5("scope", "must be suite or testcase");
+  }
+  if (v.agentRunId !== void 0 && typeof v.agentRunId !== "string") fail5("agentRunId", "must be a string");
+  let name;
+  try {
+    name = normalizeRunName(v.name);
+  } catch (err) {
+    fail5("name", err.message.replace(/^Invalid run name: name /, ""));
+  }
+  return {
+    suiteId: v.suiteId,
+    startedAt: v.startedAt,
+    results,
+    ...v.scope !== void 0 ? { scope: v.scope } : {},
+    ...v.agentRunId !== void 0 ? { agentRunId: v.agentRunId } : {},
+    ...name ? { name } : {}
+  };
 }
 
 // studio/server/routes/testruns.ts
 var testRunsRouter = Router4();
 testRunsRouter.get("/", async (_req, res) => {
-  const files = (await readdir4(TESTRUNS_DIR)).filter((f) => f.endsWith(".json"));
+  const files = (await readdir5(TESTRUNS_DIR)).filter((f) => f.endsWith(".json"));
   const summaries = [];
   for (const file of files) {
     const slug = file.replace(/\.json$/, "");
     try {
-      const raw = JSON.parse(await readFile4(path5.join(TESTRUNS_DIR, file), "utf-8"));
+      const raw = JSON.parse(await readFile5(path6.join(TESTRUNS_DIR, file), "utf-8"));
       const testRun = validateTestRun(raw);
       const counts = {};
       for (const result of Object.values(testRun.results)) {
         counts[result.status] = (counts[result.status] ?? 0) + 1;
       }
-      summaries.push({ file: slug, suiteId: testRun.suiteId, startedAt: testRun.startedAt, counts });
+      summaries.push({
+        file: slug,
+        suiteId: testRun.suiteId,
+        startedAt: testRun.startedAt,
+        counts,
+        ...testRun.scope ? { scope: testRun.scope } : {},
+        ...testRun.agentRunId ? { agentRunId: testRun.agentRunId } : {}
+      });
     } catch (err) {
       summaries.push({
         file: slug,
@@ -1249,94 +1633,19 @@ testRunsRouter.get("/", async (_req, res) => {
 });
 testRunsRouter.get("/:file", async (req, res) => {
   const slug = safeFileName(req.params.file);
-  const raw = JSON.parse(await readFile4(path5.join(TESTRUNS_DIR, `${slug}.json`), "utf-8"));
+  const raw = JSON.parse(await readFile5(path6.join(TESTRUNS_DIR, `${slug}.json`), "utf-8"));
   res.json(validateTestRun(raw));
 });
 testRunsRouter.delete("/:file", async (req, res) => {
   const slug = safeFileName(req.params.file);
-  await unlink3(path5.join(TESTRUNS_DIR, `${slug}.json`));
+  await unlink4(path6.join(TESTRUNS_DIR, `${slug}.json`));
   res.status(204).end();
 });
 
 // studio/server/routes/suites.ts
 import { Router as Router5 } from "express";
-import { readdir as readdir5, readFile as readFile5, writeFile as writeFile3, unlink as unlink4, stat as stat3 } from "node:fs/promises";
-import path6 from "node:path";
-
-// src/suite-schema.ts
-function fail4(field, reason) {
-  throw new Error(`Invalid TestSuite: ${field} ${reason}`);
-}
-function assertString4(value, field) {
-  if (typeof value !== "string" || value.length === 0) fail4(field, "must be a non-empty string");
-}
-function validateInputBinding(value, field) {
-  if (typeof value !== "object" || value === null) fail4(field, "must be an object");
-  const v = value;
-  if (v.kind === "fixture") {
-    assertString4(v.fixtureName, `${field}.fixtureName`);
-    assertString4(v.param, `${field}.param`);
-  } else if (v.kind === "testCaseOutput") {
-    assertString4(v.testCaseId, `${field}.testCaseId`);
-    assertString4(v.outputName, `${field}.outputName`);
-  } else if (v.kind === "literal") {
-    assertString4(v.value, `${field}.value`);
-  } else if (v.kind === "autogenerated") {
-  } else {
-    fail4(`${field}.kind`, 'must be "fixture", "testCaseOutput", "literal", or "autogenerated"');
-  }
-  return v;
-}
-var VALID_COMPARATORS = ["equals", "notEquals", "contains", "greaterThan", "lessThan"];
-function validateRunCondition(value, field) {
-  if (typeof value !== "object" || value === null) fail4(field, "must be an object");
-  const v = value;
-  assertString4(v.testCaseId, `${field}.testCaseId`);
-  assertString4(v.outputName, `${field}.outputName`);
-  if (!VALID_COMPARATORS.includes(v.comparator)) {
-    fail4(`${field}.comparator`, `must be one of ${VALID_COMPARATORS.join(", ")}`);
-  }
-  assertString4(v.value, `${field}.value`);
-  return v;
-}
-function validateTestSuiteEntry(value, index) {
-  if (typeof value !== "object" || value === null) fail4(`entries[${index}]`, "must be an object");
-  const v = value;
-  assertString4(v.testCaseId, `entries[${index}].testCaseId`);
-  if (!Array.isArray(v.dependsOn) || !v.dependsOn.every((d) => typeof d === "string")) {
-    fail4(`entries[${index}].dependsOn`, "must be an array of testCaseId strings");
-  }
-  if (typeof v.inputBindings !== "object" || v.inputBindings === null || Array.isArray(v.inputBindings)) {
-    fail4(`entries[${index}].inputBindings`, "must be an object mapping param names to bindings");
-  }
-  const inputBindings = {};
-  for (const [param, binding] of Object.entries(v.inputBindings)) {
-    inputBindings[param] = validateInputBinding(binding, `entries[${index}].inputBindings.${param}`);
-  }
-  if (v.legalEntity !== void 0) assertString4(v.legalEntity, `entries[${index}].legalEntity`);
-  const runIf = v.runIf !== void 0 ? validateRunCondition(v.runIf, `entries[${index}].runIf`) : void 0;
-  return {
-    testCaseId: v.testCaseId,
-    dependsOn: v.dependsOn,
-    inputBindings,
-    ...v.legalEntity !== void 0 ? { legalEntity: v.legalEntity } : {},
-    ...runIf !== void 0 ? { runIf } : {}
-  };
-}
-function validateTestSuite(value) {
-  if (typeof value !== "object" || value === null) fail4("suite", "must be an object");
-  const v = value;
-  assertString4(v.id, "id");
-  assertString4(v.name, "name");
-  assertString4(v.description, "description");
-  if (!Array.isArray(v.entries)) fail4("entries", "must be an array");
-  return {
-    id: v.id,
-    name: v.name,
-    description: v.description,
-    entries: v.entries.map(validateTestSuiteEntry)
-  };
-}
+import { readdir as readdir6, readFile as readFile6, writeFile as writeFile4, unlink as unlink5, stat as stat2 } from "node:fs/promises";
+import path7 from "node:path";
 
 // src/suite-runner.ts
 function topologicalOrder(suite) {
@@ -1383,9 +1692,9 @@ function topologicalOrder(suite) {
 
 // studio/server/routes/suites.ts
 var suitesRouter = Router5();
-async function fileExists3(filePath) {
+async function fileExists2(filePath) {
   try {
-    await stat3(filePath);
+    await stat2(filePath);
     return true;
   } catch {
     return false;
@@ -1397,12 +1706,12 @@ function validateAndCheckDag(value) {
   return suite;
 }
 suitesRouter.get("/", async (_req, res) => {
-  const files = (await readdir5(SUITES_DIR)).filter((f) => f.endsWith(".json"));
+  const files = (await readdir6(SUITES_DIR)).filter((f) => f.endsWith(".json"));
   const summaries = [];
   for (const file of files) {
     const slug = file.replace(/\.json$/, "");
     try {
-      const raw = JSON.parse(await readFile5(path6.join(SUITES_DIR, file), "utf-8"));
+      const raw = JSON.parse(await readFile6(path7.join(SUITES_DIR, file), "utf-8"));
       const suite = validateTestSuite(raw);
       summaries.push({ file: slug, id: suite.id, name: suite.name, description: suite.description, entryCount: suite.entries.length });
     } catch (err) {
@@ -1421,7 +1730,7 @@ suitesRouter.get("/", async (_req, res) => {
 });
 suitesRouter.get("/:file", async (req, res) => {
   const slug = safeFileName(req.params.file);
-  const raw = JSON.parse(await readFile5(path6.join(SUITES_DIR, `${slug}.json`), "utf-8"));
+  const raw = JSON.parse(await readFile6(path7.join(SUITES_DIR, `${slug}.json`), "utf-8"));
   res.json(validateTestSuite(raw));
 });
 suitesRouter.post("/", async (req, res) => {
@@ -1431,60 +1740,60 @@ suitesRouter.post("/", async (req, res) => {
     return;
   }
   const slug = safeFileName(body.file);
-  const filePath = path6.join(SUITES_DIR, `${slug}.json`);
-  if (await fileExists3(filePath)) {
+  const filePath = path7.join(SUITES_DIR, `${slug}.json`);
+  if (await fileExists2(filePath)) {
     res.status(409).json({ error: `Suite file "${slug}.json" already exists` });
     return;
   }
   const suite = validateAndCheckDag(body);
-  await writeFile3(filePath, JSON.stringify(suite, null, 2) + "\n", "utf-8");
+  await writeFile4(filePath, JSON.stringify(suite, null, 2) + "\n", "utf-8");
   res.status(201).json({ file: slug, ...suite });
 });
 suitesRouter.put("/:file", async (req, res) => {
   const slug = safeFileName(req.params.file);
-  const filePath = path6.join(SUITES_DIR, `${slug}.json`);
-  if (!await fileExists3(filePath)) {
+  const filePath = path7.join(SUITES_DIR, `${slug}.json`);
+  if (!await fileExists2(filePath)) {
     res.status(404).json({ error: `Suite file "${slug}.json" does not exist` });
     return;
   }
-  const existing = validateTestSuite(JSON.parse(await readFile5(filePath, "utf-8")));
+  const existing = validateTestSuite(JSON.parse(await readFile6(filePath, "utf-8")));
   const body = req.body;
   const suite = validateAndCheckDag({ ...body, id: existing.id });
-  await writeFile3(filePath, JSON.stringify(suite, null, 2) + "\n", "utf-8");
+  await writeFile4(filePath, JSON.stringify(suite, null, 2) + "\n", "utf-8");
   res.json({ file: slug, ...suite });
 });
 suitesRouter.delete("/:file", async (req, res) => {
   const slug = safeFileName(req.params.file);
-  await unlink4(path6.join(SUITES_DIR, `${slug}.json`));
+  await unlink5(path7.join(SUITES_DIR, `${slug}.json`));
   res.status(204).end();
 });
 
 // studio/server/routes/plans.ts
 import { Router as Router6 } from "express";
-import { readdir as readdir7, readFile as readFile7, writeFile as writeFile5, unlink as unlink5, stat as stat4 } from "node:fs/promises";
-import path8 from "node:path";
+import { readdir as readdir8, readFile as readFile8, writeFile as writeFile6, unlink as unlink6, stat as stat3 } from "node:fs/promises";
+import path9 from "node:path";
 
 // src/plan-schema.ts
-function fail5(field, reason) {
+function fail6(field, reason) {
   throw new Error(`Invalid TestPlan: ${field} ${reason}`);
 }
-function assertString5(value, field) {
-  if (typeof value !== "string" || value.length === 0) fail5(field, "must be a non-empty string");
+function assertString6(value, field) {
+  if (typeof value !== "string" || value.length === 0) fail6(field, "must be a non-empty string");
 }
 function validateTestPlanEntry(value, index) {
-  if (typeof value !== "object" || value === null) fail5(`suites[${index}]`, "must be an object");
+  if (typeof value !== "object" || value === null) fail6(`suites[${index}]`, "must be an object");
   const v = value;
-  assertString5(v.suiteId, `suites[${index}].suiteId`);
-  assertString5(v.suitePath, `suites[${index}].suitePath`);
+  assertString6(v.suiteId, `suites[${index}].suiteId`);
+  assertString6(v.suitePath, `suites[${index}].suitePath`);
   return { suiteId: v.suiteId, suitePath: v.suitePath };
 }
 function validateTestPlan(value) {
-  if (typeof value !== "object" || value === null) fail5("plan", "must be an object");
+  if (typeof value !== "object" || value === null) fail6("plan", "must be an object");
   const v = value;
-  assertString5(v.id, "id");
-  assertString5(v.name, "name");
-  assertString5(v.description, "description");
-  if (!Array.isArray(v.suites)) fail5("suites", "must be an array");
+  assertString6(v.id, "id");
+  assertString6(v.name, "name");
+  assertString6(v.description, "description");
+  if (!Array.isArray(v.suites)) fail6("suites", "must be an array");
   return {
     id: v.id,
     name: v.name,
@@ -1520,68 +1829,23 @@ function aggregatePlanStatus(run, testRuns) {
 }
 
 // src/planrun.ts
-import { mkdir as mkdir2, readdir as readdir6, readFile as readFile6, writeFile as writeFile4 } from "node:fs/promises";
-import path7 from "node:path";
-
-// src/planrun-schema.ts
-function createPlanRun(planId, suites) {
-  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-  return {
-    id: startedAt.replace(/:/g, "-"),
-    planId,
-    startedAt,
-    suiteIds: suites.map((s) => s.id),
-    suiteNames: Object.fromEntries(suites.map((s) => [s.id, s.name]))
-  };
-}
-function fail6(field, reason) {
-  throw new Error(`Invalid PlanRun: ${field} ${reason}`);
-}
-function assertString6(value, field) {
-  if (typeof value !== "string" || value.length === 0) fail6(field, "must be a non-empty string");
-}
-function assertSuiteIds(value) {
-  if (value === void 0) return [];
-  if (!Array.isArray(value)) fail6("suiteIds", "must be an array of strings");
-  for (const [i, entry] of value.entries()) assertString6(entry, `suiteIds[${i}]`);
-  return value;
-}
-function assertSuiteNames(value) {
-  if (value === void 0) return {};
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    fail6("suiteNames", "must be an object mapping suiteId to name");
-  }
-  const v = value;
-  for (const [id, name] of Object.entries(v)) assertString6(name, `suiteNames.${id}`);
-  return v;
-}
-function validatePlanRun(value) {
-  if (typeof value !== "object" || value === null) fail6("planRun", "must be an object");
-  const v = value;
-  assertString6(v.id, "id");
-  assertString6(v.planId, "planId");
-  assertString6(v.startedAt, "startedAt");
-  const suiteIds = assertSuiteIds(v.suiteIds);
-  const suiteNames = assertSuiteNames(v.suiteNames);
-  return { id: v.id, planId: v.planId, startedAt: v.startedAt, suiteIds, suiteNames };
-}
-
-// src/planrun.ts
+import { mkdir as mkdir2, readdir as readdir7, readFile as readFile7, writeFile as writeFile5 } from "node:fs/promises";
+import path8 from "node:path";
 async function readPlanRun(filePath) {
-  const raw = await readFile6(filePath, "utf-8");
+  const raw = await readFile7(filePath, "utf-8");
   return validatePlanRun(JSON.parse(raw));
 }
 async function listPlanRuns(dir, planId) {
   let files;
   try {
-    files = (await readdir6(dir)).filter((f) => f.endsWith(".json"));
+    files = (await readdir7(dir)).filter((f) => f.endsWith(".json"));
   } catch {
     return [];
   }
   const runs = [];
   for (const file of files) {
     try {
-      const run = await readPlanRun(path7.join(dir, file));
+      const run = await readPlanRun(path8.join(dir, file));
       if (!planId || run.planId === planId) runs.push(run);
     } catch {
     }
@@ -1589,19 +1853,19 @@ async function listPlanRuns(dir, planId) {
   runs.sort((a, b) => b.startedAt.localeCompare(a.startedAt));
   return runs;
 }
-async function initPlanRun(planId, suites, dir) {
-  const planRun = createPlanRun(planId, suites);
-  const filePath = path7.join(dir, `${planRun.id}.json`);
+async function initPlanRun(planId, suites, dir, name) {
+  const planRun = createPlanRun(planId, suites, name);
+  const filePath = path8.join(dir, `${planRun.id}.json`);
   await mkdir2(dir, { recursive: true });
-  await writeFile4(filePath, JSON.stringify(planRun, null, 2), "utf-8");
+  await writeFile5(filePath, JSON.stringify(planRun, null, 2), "utf-8");
   return { planRun, filePath };
 }
 
 // studio/server/routes/plans.ts
 var plansRouter = Router6();
-async function fileExists4(filePath) {
+async function fileExists3(filePath) {
   try {
-    await stat4(filePath);
+    await stat3(filePath);
     return true;
   } catch {
     return false;
@@ -1609,19 +1873,19 @@ async function fileExists4(filePath) {
 }
 async function entryFromSuiteFile(suiteFile) {
   const slug = safeFileName(suiteFile);
-  const suitePath = path8.join(SUITES_DIR, `${slug}.json`);
-  const raw = JSON.parse(await readFile7(suitePath, "utf-8"));
+  const suitePath = path9.join(SUITES_DIR, `${slug}.json`);
+  const raw = JSON.parse(await readFile8(suitePath, "utf-8"));
   const suite = validateTestSuite(raw);
-  const relative = path8.relative(PLANS_DIR, suitePath).replace(/\\/g, "/");
+  const relative = path9.relative(PLANS_DIR, suitePath).replace(/\\/g, "/");
   return { suiteId: suite.id, suitePath: relative };
 }
 plansRouter.get("/", async (_req, res) => {
-  const files = (await readdir7(PLANS_DIR)).filter((f) => f.endsWith(".json"));
+  const files = (await readdir8(PLANS_DIR)).filter((f) => f.endsWith(".json"));
   const summaries = [];
   for (const file of files) {
     const slug = file.replace(/\.json$/, "");
     try {
-      const raw = JSON.parse(await readFile7(path8.join(PLANS_DIR, file), "utf-8"));
+      const raw = JSON.parse(await readFile8(path9.join(PLANS_DIR, file), "utf-8"));
       const plan = validateTestPlan(raw);
       summaries.push({
         file: slug,
@@ -1646,7 +1910,7 @@ plansRouter.get("/", async (_req, res) => {
 });
 plansRouter.get("/:file", async (req, res) => {
   const slug = safeFileName(req.params.file);
-  const raw = JSON.parse(await readFile7(path8.join(PLANS_DIR, `${slug}.json`), "utf-8"));
+  const raw = JSON.parse(await readFile8(path9.join(PLANS_DIR, `${slug}.json`), "utf-8"));
   res.json(validateTestPlan(raw));
 });
 plansRouter.post("/", async (req, res) => {
@@ -1660,24 +1924,24 @@ plansRouter.post("/", async (req, res) => {
     return;
   }
   const slug = safeFileName(body.file);
-  const filePath = path8.join(PLANS_DIR, `${slug}.json`);
-  if (await fileExists4(filePath)) {
+  const filePath = path9.join(PLANS_DIR, `${slug}.json`);
+  if (await fileExists3(filePath)) {
     res.status(409).json({ error: `Plan file "${slug}.json" already exists` });
     return;
   }
   const suites = await Promise.all(body.suiteFiles.map((f) => entryFromSuiteFile(f)));
   const plan = validateTestPlan({ id: body.id, name: body.name, description: body.description, suites });
-  await writeFile5(filePath, JSON.stringify(plan, null, 2) + "\n", "utf-8");
+  await writeFile6(filePath, JSON.stringify(plan, null, 2) + "\n", "utf-8");
   res.status(201).json({ file: slug, ...plan });
 });
 plansRouter.put("/:file", async (req, res) => {
   const slug = safeFileName(req.params.file);
-  const filePath = path8.join(PLANS_DIR, `${slug}.json`);
-  if (!await fileExists4(filePath)) {
+  const filePath = path9.join(PLANS_DIR, `${slug}.json`);
+  if (!await fileExists3(filePath)) {
     res.status(404).json({ error: `Plan file "${slug}.json" does not exist` });
     return;
   }
-  const existing = validateTestPlan(JSON.parse(await readFile7(filePath, "utf-8")));
+  const existing = validateTestPlan(JSON.parse(await readFile8(filePath, "utf-8")));
   const body = req.body;
   if (!Array.isArray(body.suiteFiles)) {
     res.status(400).json({ error: '"suiteFiles" must be an array of suite file slugs' });
@@ -1685,36 +1949,36 @@ plansRouter.put("/:file", async (req, res) => {
   }
   const suites = await Promise.all(body.suiteFiles.map((f) => entryFromSuiteFile(f)));
   const plan = validateTestPlan({ id: existing.id, name: body.name, description: body.description, suites });
-  await writeFile5(filePath, JSON.stringify(plan, null, 2) + "\n", "utf-8");
+  await writeFile6(filePath, JSON.stringify(plan, null, 2) + "\n", "utf-8");
   res.json({ file: slug, ...plan });
 });
 plansRouter.delete("/:file", async (req, res) => {
   const slug = safeFileName(req.params.file);
-  await unlink5(path8.join(PLANS_DIR, `${slug}.json`));
+  await unlink6(path9.join(PLANS_DIR, `${slug}.json`));
   res.status(204).end();
 });
 plansRouter.get("/:file/runs", async (req, res) => {
   const slug = safeFileName(req.params.file);
-  const plan = validateTestPlan(JSON.parse(await readFile7(path8.join(PLANS_DIR, `${slug}.json`), "utf-8")));
+  const plan = validateTestPlan(JSON.parse(await readFile8(path9.join(PLANS_DIR, `${slug}.json`), "utf-8")));
   const runs = await listPlanRuns(RUNS_DIR, plan.id);
   res.json({ runs });
 });
 plansRouter.post("/:file/runs", async (req, res) => {
   const slug = safeFileName(req.params.file);
-  const plan = validateTestPlan(JSON.parse(await readFile7(path8.join(PLANS_DIR, `${slug}.json`), "utf-8")));
+  const plan = validateTestPlan(JSON.parse(await readFile8(path9.join(PLANS_DIR, `${slug}.json`), "utf-8")));
   const suites = await Promise.all(
     plan.suites.map(async (entry) => {
-      const raw = JSON.parse(await readFile7(safeSuitePathFromPlan(entry.suitePath), "utf-8"));
+      const raw = JSON.parse(await readFile8(safeSuitePathFromPlan(entry.suitePath), "utf-8"));
       const suite = validateTestSuite(raw);
       return { id: suite.id, name: suite.name };
     })
   );
-  const { planRun } = await initPlanRun(plan.id, suites, RUNS_DIR);
+  const { planRun } = await initPlanRun(plan.id, suites, RUNS_DIR, req.body?.name);
   res.status(201).json(planRun);
 });
 plansRouter.delete("/:file/runs/:runId", async (req, res) => {
   const runId = safeFileName(req.params.runId);
-  await unlink5(path8.join(RUNS_DIR, `${runId}.json`));
+  await unlink6(path9.join(RUNS_DIR, `${runId}.json`));
   res.status(204).end();
 });
 plansRouter.get("/:file/status", async (req, res) => {
@@ -1724,17 +1988,17 @@ plansRouter.get("/:file/status", async (req, res) => {
     res.status(400).json({ error: '"runId" query parameter is required' });
     return;
   }
-  const plan = validateTestPlan(JSON.parse(await readFile7(path8.join(PLANS_DIR, `${slug}.json`), "utf-8")));
-  const run = await readPlanRun(path8.join(RUNS_DIR, `${safeFileName(runId)}.json`));
+  const plan = validateTestPlan(JSON.parse(await readFile8(path9.join(PLANS_DIR, `${slug}.json`), "utf-8")));
+  const run = await readPlanRun(path9.join(RUNS_DIR, `${safeFileName(runId)}.json`));
   if (run.planId !== plan.id) {
     res.status(400).json({ error: `Plan run "${run.id}" belongs to plan "${run.planId}", not "${plan.id}"` });
     return;
   }
   const testRuns = /* @__PURE__ */ new Map();
   for (const suiteId of run.suiteIds) {
-    const testRunPath = path8.join(TESTRUNS_DIR, `${suiteId}-${run.id}.json`);
+    const testRunPath = path9.join(TESTRUNS_DIR, `${suiteId}-${run.id}.json`);
     try {
-      testRuns.set(suiteId, validateTestRun(JSON.parse(await readFile7(testRunPath, "utf-8"))));
+      testRuns.set(suiteId, validateTestRun(JSON.parse(await readFile8(testRunPath, "utf-8"))));
     } catch {
       testRuns.set(suiteId, null);
     }
@@ -1747,13 +2011,13 @@ import { Router as Router7 } from "express";
 import express from "express";
 
 // src/library-archive.ts
-import { readFile as readFile8, writeFile as writeFile6, readdir as readdir8, mkdir as mkdir3, stat as stat5 } from "node:fs/promises";
-import path9 from "node:path";
+import { readFile as readFile9, writeFile as writeFile7, readdir as readdir9, mkdir as mkdir3, stat as stat4 } from "node:fs/promises";
+import path10 from "node:path";
 import JSZip3 from "jszip";
 var LIBRARY_DIRS = ["recordings", "testcases", "testdata", "testscripts", "suites", "plans", "testruns"];
-async function fileExists5(p) {
+async function fileExists4(p) {
   try {
-    await stat5(p);
+    await stat4(p);
     return true;
   } catch {
     return false;
@@ -1762,18 +2026,18 @@ async function fileExists5(p) {
 async function addDirToZip(zip, dirAbsPath, zipPrefix) {
   let entries;
   try {
-    entries = await readdir8(dirAbsPath, { withFileTypes: true });
+    entries = await readdir9(dirAbsPath, { withFileTypes: true });
   } catch {
     return 0;
   }
   let count = 0;
   for (const entry of entries) {
-    const abs = path9.join(dirAbsPath, entry.name);
+    const abs = path10.join(dirAbsPath, entry.name);
     const zipPath = `${zipPrefix}/${entry.name}`;
     if (entry.isDirectory()) {
       count += await addDirToZip(zip, abs, zipPath);
     } else if (entry.isFile()) {
-      zip.file(zipPath, await readFile8(abs));
+      zip.file(zipPath, await readFile9(abs));
       count++;
     }
   }
@@ -1783,7 +2047,7 @@ async function buildLibraryZip(baseDir) {
   const zip = new JSZip3();
   let fileCount = 0;
   for (const dir of LIBRARY_DIRS) {
-    fileCount += await addDirToZip(zip, path9.join(baseDir, dir), dir);
+    fileCount += await addDirToZip(zip, path10.join(baseDir, dir), dir);
   }
   const buffer = await zip.generateAsync({ type: "nodebuffer", compression: "DEFLATE" });
   return { buffer, fileCount, dirs: LIBRARY_DIRS };
@@ -1791,15 +2055,15 @@ async function buildLibraryZip(baseDir) {
 async function extractLibraryZip(bytes, baseDir, force) {
   const zip = await JSZip3.loadAsync(bytes);
   const entries = Object.values(zip.files).filter((f) => !f.dir);
-  const baseAbs = path9.resolve(baseDir);
+  const baseAbs = path10.resolve(baseDir);
   const targets = [];
   for (const entry of entries) {
     const topDir = entry.name.split("/")[0];
     if (!LIBRARY_DIRS.includes(topDir)) {
       throw new Error(`Refusing to import: "${entry.name}" is outside the recognized library directories (${LIBRARY_DIRS.join(", ")}) -- this doesn't look like an trxa-tool library backup.`);
     }
-    const targetPath = path9.resolve(baseAbs, entry.name);
-    if (!targetPath.startsWith(baseAbs + path9.sep)) {
+    const targetPath = path10.resolve(baseAbs, entry.name);
+    if (!targetPath.startsWith(baseAbs + path10.sep)) {
       throw new Error(`Refusing to import: "${entry.name}" resolves outside the target directory.`);
     }
     targets.push({ entry, targetPath });
@@ -1807,15 +2071,15 @@ async function extractLibraryZip(bytes, baseDir, force) {
   if (!force) {
     const collisions = [];
     for (const { entry, targetPath } of targets) {
-      if (await fileExists5(targetPath)) collisions.push(entry.name);
+      if (await fileExists4(targetPath)) collisions.push(entry.name);
     }
     if (collisions.length > 0) {
       return { fileCount: 0, collisions };
     }
   }
   for (const { entry, targetPath } of targets) {
-    await mkdir3(path9.dirname(targetPath), { recursive: true });
-    await writeFile6(targetPath, await entry.async("nodebuffer"));
+    await mkdir3(path10.dirname(targetPath), { recursive: true });
+    await writeFile7(targetPath, await entry.async("nodebuffer"));
   }
   return { fileCount: targets.length, collisions: [] };
 }
@@ -1845,14 +2109,14 @@ libraryRouter.post("/import", express.raw({ type: "application/zip", limit: "200
 
 // studio/server/routes/settings.ts
 import { Router as Router8 } from "express";
-import { stat as stat6 } from "node:fs/promises";
+import { stat as stat5 } from "node:fs/promises";
 
 // studio/server/settings.ts
-import { mkdir as mkdir4, readFile as readFile9, writeFile as writeFile7 } from "node:fs/promises";
-import path10 from "node:path";
+import { mkdir as mkdir4, readFile as readFile10, writeFile as writeFile8 } from "node:fs/promises";
+import path11 from "node:path";
 import os from "node:os";
-var CONFIG_DIR = path10.join(os.homedir(), ".trxa-tool");
-var CONFIG_FILE = path10.join(CONFIG_DIR, "settings.json");
+var CONFIG_DIR = path11.join(os.homedir(), ".trxa-tool");
+var CONFIG_FILE = path11.join(CONFIG_DIR, "settings.json");
 var cached = null;
 async function ensureWorkingFolderDirs() {
   await Promise.all(allDataDirs().map((dir) => mkdir4(dir, { recursive: true })));
@@ -1860,7 +2124,7 @@ async function ensureWorkingFolderDirs() {
 async function loadSettings() {
   if (cached) return cached;
   try {
-    const raw = JSON.parse(await readFile9(CONFIG_FILE, "utf-8"));
+    const raw = JSON.parse(await readFile10(CONFIG_FILE, "utf-8"));
     if (typeof raw.workingFolder === "string" && raw.workingFolder.trim()) {
       cached = { workingFolder: raw.workingFolder };
       setWorkingFolder(cached.workingFolder);
@@ -1870,11 +2134,11 @@ async function loadSettings() {
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
   }
-  return saveSettings({ workingFolder: process.cwd() });
+  return saveSettings({ workingFolder: process.env.STUDIO_DEFAULT_WORKING_FOLDER || process.cwd() });
 }
 async function saveSettings(next) {
   await mkdir4(CONFIG_DIR, { recursive: true });
-  await writeFile7(CONFIG_FILE, JSON.stringify(next, null, 2) + "\n", "utf-8");
+  await writeFile8(CONFIG_FILE, JSON.stringify(next, null, 2) + "\n", "utf-8");
   cached = next;
   setWorkingFolder(next.workingFolder);
   await ensureWorkingFolderDirs();
@@ -1896,7 +2160,7 @@ settingsRouter.put("/", async (req, res, next) => {
     if (typeof workingFolder !== "string" || !workingFolder.trim()) {
       throw new Error("workingFolder must be a non-empty string");
     }
-    const info = await stat6(workingFolder).catch(() => null);
+    const info = await stat5(workingFolder).catch(() => null);
     if (!info || !info.isDirectory()) {
       throw new Error(`Not a directory: "${workingFolder}"`);
     }
@@ -1906,6 +2170,978 @@ settingsRouter.put("/", async (req, res, next) => {
   }
 });
 
+// studio/server/routes/agent.ts
+import { Router as Router9 } from "express";
+import { execFile } from "node:child_process";
+import { access, readFile as readFile13 } from "node:fs/promises";
+import os2 from "node:os";
+import path13 from "node:path";
+
+// studio/server/agent-run.ts
+import { mkdir as mkdir5, readFile as readFile12, readdir as readdir10, stat as stat6, writeFile as writeFile10 } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import path12 from "node:path";
+import { spawn } from "node:child_process";
+import { CopilotClient, approveAll } from "@github/copilot-sdk";
+
+// src/report.ts
+import { readFile as readFile11, writeFile as writeFile9 } from "node:fs/promises";
+async function writeTestRun(testRun, path16) {
+  await writeFile9(path16, JSON.stringify(testRun, null, 2), "utf-8");
+}
+async function initTestRun(suite, path16, extra = {}) {
+  const testRun = createTestRun(
+    suite.id,
+    suite.entries.map((e) => e.testCaseId),
+    { ...extra, scope: "suite" }
+  );
+  await writeTestRun(testRun, path16);
+  return testRun;
+}
+async function initTestCaseRun(testCaseId, path16, extra = {}) {
+  const testRun = createTestRun(testCaseId, [testCaseId], { ...extra, scope: "testcase" });
+  await writeTestRun(testRun, path16);
+  return testRun;
+}
+
+// studio/server/agent-run.ts
+var TARGET_DIRS = {
+  testcase: { dir: "testcases", label: "Test Case" },
+  suite: { dir: "suites", label: "Test Suite" },
+  plan: { dir: "plans", label: "Test Plan" }
+};
+var NAVIGATION_TOOLS = /* @__PURE__ */ new Set([
+  "form_open_menu_item",
+  "form_find_menu_item",
+  "form_find_controls",
+  "form_select_grid_row",
+  "form_filter_form",
+  "form_filter_grid",
+  "form_sort_grid_column",
+  "form_open_or_close_tab",
+  "form_open_lookup",
+  "form_close_form",
+  "get_current_user",
+  "api_find_actions",
+  "data_find_entity_type",
+  "data_find_entities_sql",
+  "data_get_entity_metadata"
+]);
+var ALLOWED_SHELL = /^\s*(trxa|node\s+\S*dist[\\/]index\.js|get-content|get-childitem|select-string|test-path|cat|type|dir|ls|where|git\s+(status|log|diff|--no-pager))\b/i;
+var SAFE_CMDLETS = /* @__PURE__ */ new Set(
+  [
+    "get-content",
+    "get-childitem",
+    "get-item",
+    "select-string",
+    "test-path",
+    "resolve-path",
+    "split-path",
+    "join-path",
+    "convertfrom-json",
+    "convertto-json",
+    "foreach-object",
+    "where-object",
+    "select-object",
+    "sort-object",
+    "group-object",
+    "measure-object",
+    "out-string",
+    "format-table",
+    "format-list",
+    "write-output",
+    "write-host"
+  ]
+);
+var SAFE_ALIASES = /* @__PURE__ */ new Set(["cat", "type", "dir", "ls", "gc", "select", "sort", "group", "measure", "ft", "fl", "where", "%", "?", "foreach"]);
+var SCRATCH_FILE = /^(\.[\\/])?(scratch|tmp)-[\w.*-]+\.json$/i;
+var UNSAFE_WORD = /(?<![\w-])(rm|del|erase|ri|rmdir|rd|mv|move|mi|cp|copy|cpi|ni|sc|set|sv|ac|iex|iwr|irm|curl|wget|saps|start|kill|spps|node|npm|npx|python|powershell|pwsh|cmd|invoke|add|clear|new|out-file|tee)(?![\w-])/i;
+function splitStatements(cmd) {
+  const parts = [];
+  let depth = 0;
+  let quote = "";
+  let cur = "";
+  for (const ch of cmd) {
+    if (quote) {
+      if (ch === quote) quote = "";
+    } else if (ch === "'" || ch === '"') quote = ch;
+    else if ("({[".includes(ch)) depth++;
+    else if (")}]".includes(ch)) depth--;
+    if (!quote && depth === 0 && (ch === ";" || ch === "|" || ch === "\n")) {
+      parts.push(cur);
+      cur = "";
+    } else cur += ch;
+  }
+  parts.push(cur);
+  return parts.map((p) => p.trim()).filter(Boolean);
+}
+function stripQuotedText(cmd) {
+  return cmd.replace(/'[^']*'|"[^"]*"/g, "''");
+}
+function shellAllowed(rawCmd) {
+  const cmd = rawCmd.replace(/\s2>&1/g, "");
+  if (ALLOWED_SHELL.test(cmd) && !/[;|&<>`$(]/.test(cmd.replace(/'[^']*'|"[^"]*"/g, ""))) return true;
+  const code = stripQuotedText(cmd).replace(/\btrxa\s+[a-z][a-z-]*/gi, "trxa");
+  if (/[>&`]/.test(code) || /\bforeach-object\b[^{]*\bnew\b/i.test(code)) return false;
+  for (const m of code.matchAll(/(?<![\w\\./-])((?:get|set|add|new|remove|clear|invoke|start|stop|out|copy|move|rename|write|export|import|tee|select|sort|group|measure|format|convertfrom|convertto|foreach|where|test|resolve|split|join)-[A-Za-z]+)(?![\w-])/gi)) {
+    const name = m[1].toLowerCase();
+    if (!SAFE_CMDLETS.has(name) && name !== "remove-item") return false;
+  }
+  if (UNSAFE_WORD.test(code.replace(/-[A-Za-z]+/g, " ").replace(/\bremove-item\b/gi, ""))) return false;
+  for (const stmt of splitStatements(cmd)) {
+    const body = stmt.replace(/^\$\w+\s*=\s*/, "");
+    const first = (/^['"]?[\w%?-]+/.exec(body)?.[0] ?? "").replace(/^['"]/, "").toLowerCase();
+    if (first === "remove-item") {
+      const args = body.split(/\s+/).slice(1).filter((a) => !a.startsWith("-")).map((a) => a.replace(/^['"]|['"]$|,$/g, ""));
+      if (args.length === 0 || !args.every((a) => SCRATCH_FILE.test(a))) return false;
+    } else if (first === "trxa" || /^node\s+\S*dist[\\/]index\.js/i.test(body)) {
+      continue;
+    } else if (first === "git") {
+      if (!/^git\s+(--no-pager\s+)?(status|log|diff)\b/i.test(body)) return false;
+    } else if (/^[$[(]/.test(body)) {
+      continue;
+    } else if (!SAFE_CMDLETS.has(first) && !SAFE_ALIASES.has(first)) {
+      return false;
+    }
+  }
+  return true;
+}
+var MCP_TOOL_PREFIX = /^d365-erp-mcp-/;
+var active = /* @__PURE__ */ new Map();
+var MAX_EVENT_TEXT = 2e4;
+var MAX_EVENTS = 2e4;
+var PERSIST_EVERY_MS = 3e3;
+function runsDir() {
+  return path12.join(getWorkingFolder(), "agent-runs");
+}
+function samePathOrInside(parent, child) {
+  const rel = path12.relative(parent.toLowerCase(), child.toLowerCase());
+  return rel === "" || !rel.startsWith("..") && !path12.isAbsolute(rel);
+}
+function decide(req, depth, workingFolder) {
+  switch (req.kind) {
+    case "write": {
+      const file = String(req.fileName ?? "");
+      if (!file || !samePathOrInside(workingFolder, path12.resolve(workingFolder, file))) {
+        return { allow: false, reason: `Writing outside the working folder is not allowed (${file || "unknown path"}).` };
+      }
+      return { allow: true };
+    }
+    case "shell": {
+      const cmd = String(req.fullCommandText ?? "");
+      if (!shellAllowed(cmd)) return { allow: false, reason: `Shell command not allowed: ${cmd.slice(0, 120)}` };
+      return { allow: true };
+    }
+    case "mcp": {
+      const mcp = req;
+      const server = String(mcp.serverName ?? "");
+      const tool = String(mcp.toolName ?? "");
+      const bare = tool.startsWith(server + "-") ? tool.slice(server.length + 1) : tool;
+      if (depth === "navigation") {
+        if (server === "d365-erp-mcp" || MCP_TOOL_PREFIX.test(tool)) {
+          if (!NAVIGATION_TOOLS.has(bare)) {
+            return { allow: false, reason: `"${bare}" could change data, which a navigation-only run does not allow.` };
+          }
+        } else if (!mcp.readOnly) {
+          return { allow: false, reason: `"${bare}" is not read-only, which a navigation-only run requires.` };
+        }
+      }
+      return { allow: true };
+    }
+    default:
+      return { allow: true };
+  }
+}
+function buildPrompt(req, relPath, target) {
+  const label = TARGET_DIRS[req.kind].label;
+  const depthText = req.depth === "navigation" ? "NAVIGATION ONLY: open forms and read values, but do not save, post, create, update or delete anything. Do not click buttons that change data. Mark steps you could not run for that reason as skipped, and say so in the report." : "FULL RUN: execute every step, including saving and posting, as the test defines.";
+  const files = (target?.testRunFiles ?? []).map((f) => `testruns/${f}.json`);
+  let records = "";
+  if (req.kind === "plan" && target?.planRunId) {
+    records = `The Plan run \`${target.planRunId}\` and every suite's Test Run file already exist, all entries pending. Do NOT run \`trxa init-plan-run\` or \`trxa init-run\`; use these files:
+${files.map((f) => `- ${f}`).join("\n")}`;
+  } else if (req.kind === "suite" && files.length > 0) {
+    records = `The Test Run file \`${files[0]}\` already exists with every entry pending. Do NOT run \`trxa init-run\`; use that file with \`resolve-next\` and \`record-result\`.`;
+  } else if (req.kind === "testcase" && files.length > 0) {
+    records = `The Test Run file \`${files[0]}\` already exists with one pending entry keyed by the test case id. There is no suite, so do not use \`resolve-next\`; replay the test case and record its result in that file with \`trxa record-result\`.`;
+  }
+  return `Use the replay-trxa-testplan skill to run the ${label} \`${relPath}\` in the current working folder.
+
+This run is UNATTENDED. Nobody is available to answer questions, so never ask one. If you cannot continue, or need input you do not have, stop and finish your final message with a single line of the form \`BLOCKED: <reason>\`.
+
+Before you execute any step:
+- Check the live D365 session with the d365-erp-mcp tools and note which environment and company it points at.
+- I expect environment "${req.environment}" and company "${req.company}". The D365 session reports the company but NOT the environment host, so do not search config files for it: verify the company, treat the environment as the one the MCP server is connected to, and say in your report that the host was not independently verified. If the company does not match, execute nothing and finish with \`BLOCKED: <what you saw versus what was expected>\`.
+
+Run depth: ${depthText}
+
+${records}
+
+Record results with \`trxa record-result\`, passing JSON through the --outputs-file / --assertions-file / --inputs-file / --messages-file flags. Write those JSON files only as \`scratch-<name>.json\` in the working folder and delete them with \`Remove-Item scratch-*.json\` when you are done. Do not edit the trxa-tool source, dist or any file outside this working folder. When finished, summarize what passed, failed or was skipped.
+
+Working rules:
+- Call only tools that exist in this session; never invent a tool name.
+- D365 form tools are stateful: call one at a time, never in parallel.
+- To read a test script, use PowerShell (\`Get-Content <file> -Raw | ConvertFrom-Json\`, with \`Select-Object\`/\`ForEach-Object\`) or grep. \`node -e\` and other interpreters are not allowed.
+- Control names in a test script's hints can differ from the live form. If a control is not found, use \`form_find_controls\` rather than guessing.
+- While an async operation is processing (\`BACKGROUND_PROCESS_IN_PROGRESS\`), keep polling with \`__TimerForAsyncTaskPolling\` without commentary between polls.`;
+}
+async function prepareRecords(req, agentRunId) {
+  const runId = (/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-");
+  await mkdir5(TESTRUNS_DIR, { recursive: true });
+  const slug = (base) => `${base}-${runId}`;
+  const file = (s) => path12.join(TESTRUNS_DIR, `${s}.json`);
+  if (req.kind === "testcase") {
+    const s = slug(req.id);
+    await initTestCaseRun(req.id, file(s), { agentRunId, name: req.name });
+    return { testRunFiles: [s] };
+  }
+  if (req.kind === "suite") {
+    const suite = validateTestSuite(JSON.parse(await readFile12(path12.join(getWorkingFolder(), "suites", `${req.id}.json`), "utf-8")));
+    const s = slug(suite.id);
+    await initTestRun(suite, file(s), { agentRunId, name: req.name });
+    return { testRunFiles: [s] };
+  }
+  const plan = validateTestPlan(JSON.parse(await readFile12(path12.join(PLANS_DIR, `${req.id}.json`), "utf-8")));
+  const suites = await Promise.all(
+    plan.suites.map(async (entry) => validateTestSuite(JSON.parse(await readFile12(safeSuitePathFromPlan(entry.suitePath), "utf-8"))))
+  );
+  const { planRun } = await initPlanRun(plan.id, suites.map((s) => ({ id: s.id, name: s.name })), RUNS_DIR, req.name);
+  const files = [];
+  for (const suite of suites) {
+    const s = `${suite.id}-${planRun.id}`;
+    await initTestRun(suite, file(s), { agentRunId });
+    files.push(s);
+  }
+  return { planRunId: planRun.id, testRunFiles: files };
+}
+async function resolveTarget(req) {
+  if (!/^[\w .()-]+$/.test(req.id)) throw new Error("Invalid test id");
+  const { dir } = TARGET_DIRS[req.kind];
+  const rel = path12.join(dir, `${req.id}.json`);
+  const info = await stat6(path12.join(getWorkingFolder(), rel)).catch(() => null);
+  if (!info?.isFile()) throw new Error(`${rel} does not exist in the working folder`);
+  return rel.replace(/\\/g, "/");
+}
+function validateRequest(body) {
+  const kind = body?.kind;
+  const depth = body?.depth;
+  if (!(kind in TARGET_DIRS)) throw new Error("kind must be testcase, suite or plan");
+  if (depth !== "navigation" && depth !== "full") throw new Error("depth must be navigation or full");
+  for (const f of ["id", "environment", "company"]) {
+    if (typeof body?.[f] !== "string" || !body[f].trim()) throw new Error(`${f} is required`);
+  }
+  if (depth === "full" && body.confirmFull !== true) throw new Error("A full run needs explicit confirmation");
+  const agent = body.agent === "claude" ? "claude" : "copilot";
+  const name = normalizeRunName(body.name);
+  return {
+    kind,
+    depth,
+    agent,
+    id: body.id.trim(),
+    environment: body.environment.trim(),
+    company: body.company.trim(),
+    ...name ? { name } : {}
+  };
+}
+async function persist(run) {
+  await mkdir5(runsDir(), { recursive: true });
+  await writeFile10(path12.join(runsDir(), `${run.record.id}.json`), JSON.stringify(run.record, null, 2), "utf-8");
+}
+function emit(run, e) {
+  if (e.text && e.text.length > MAX_EVENT_TEXT) e = { ...e, text: e.text.slice(0, MAX_EVENT_TEXT) + " \u2026(truncated)" };
+  const event = { t: Date.now() - run.t0, ...e };
+  if (run.record.events.length >= MAX_EVENTS && event.type !== "finished" && event.type !== "error") return;
+  run.record.events.push(event);
+  for (const l of run.listeners) l(event);
+  if (Date.now() - run.lastPersist > PERSIST_EVERY_MS) {
+    run.lastPersist = Date.now();
+    void persist(run).catch(() => {
+    });
+  }
+}
+function clip(value) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  const text2 = typeof value === "string" ? value : JSON.stringify(value);
+  return text2.length > MAX_EVENT_TEXT ? text2.slice(0, MAX_EVENT_TEXT) + " \u2026(truncated)" : text2;
+}
+async function settleRecords(target, reason) {
+  for (const slug of target?.testRunFiles ?? []) {
+    const file = path12.join(TESTRUNS_DIR, `${slug}.json`);
+    try {
+      const testRun = JSON.parse(await readFile12(file, "utf-8"));
+      let changed = false;
+      for (const result of Object.values(testRun.results ?? {})) {
+        if (result.status !== "pending" && result.status !== "running") continue;
+        result.status = "blocked";
+        result.messages = [...result.messages ?? [], reason];
+        changed = true;
+      }
+      if (changed) await writeFile10(file, JSON.stringify(testRun, null, 2), "utf-8");
+    } catch {
+    }
+  }
+}
+function settleOrphan(r) {
+  if (r.status === "running" && !active.has(r.id)) {
+    r.status = "interrupted";
+    r.finishedAt = r.finishedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+    r.events.push({ t: 0, type: "error", text: "Run was interrupted (Studio closed or restarted) before it finished." });
+    void settleRecords(r.target, "Agent run was interrupted before this test case ran.");
+  }
+  return r;
+}
+function friendlyError(message) {
+  if (/401|unauthori[sz]ed|not (logged|signed) in|authentication|bad credentials/i.test(message)) {
+    return `GitHub Copilot sign-in failed or expired. Run \`copilot login\` in a terminal, then try again. (${message})`;
+  }
+  if (/ENOENT|spawn|not found|ECONNREFUSED|ECONNRESET|ETIMEDOUT|ENOTFOUND/i.test(message)) {
+    return `Could not reach the Copilot agent or its tools. Check Settings > Agent runs, your network, and that the d365-erp-mcp server is connected. (${message})`;
+  }
+  return message;
+}
+function finish(run, status, text2) {
+  if (run.record.status !== "running") return;
+  if (status === "finished") {
+    const lastMsg = [...run.record.events].reverse().find((e) => e.type === "message");
+    const blocked = lastMsg?.text?.match(/^\s*BLOCKED:\s*(.+)$/im);
+    if (blocked) {
+      status = "failed";
+      text2 = `Blocked: ${blocked[1].trim()}`;
+    }
+  }
+  run.record.status = status;
+  run.record.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+  if (status !== "finished") void settleRecords(run.record.target, text2 ?? `Agent run ${status} before this test case ran.`);
+  emit(run, { type: status === "failed" ? "error" : "finished", text: text2 && status === "failed" ? friendlyError(text2) : text2, ok: status === "finished" });
+  void persist(run).catch(() => {
+  });
+}
+async function startRun(req) {
+  if ([...active.values()].some((r) => r.record.status === "running")) {
+    throw new Error("Another run is already in progress");
+  }
+  const relPath = await resolveTarget(req);
+  const workingFolder = getWorkingFolder();
+  const agentRunId = randomUUID();
+  const target = await prepareRecords(req, agentRunId);
+  const run = {
+    record: { id: agentRunId, request: req, status: "running", startedAt: (/* @__PURE__ */ new Date()).toISOString(), events: [], target },
+    t0: Date.now(),
+    lastPersist: Date.now(),
+    listeners: /* @__PURE__ */ new Set()
+  };
+  active.set(run.record.id, run);
+  emit(run, { type: "started", text: `${TARGET_DIRS[req.kind].label}: ${relPath}` });
+  void persist(run).catch(() => {
+  });
+  if (req.agent === "claude") {
+    runClaude(run, req, relPath, workingFolder);
+    return run.record;
+  }
+  void (async () => {
+    const client = new CopilotClient({ workingDirectory: workingFolder });
+    try {
+      const session = await client.createSession({
+        workingDirectory: workingFolder,
+        enableConfigDiscovery: true,
+        streaming: true,
+        onPermissionRequest: (request) => {
+          const verdict = decide(request, req.depth, workingFolder);
+          if (verdict.allow) return approveAll(request, { sessionId: "" });
+          emit(run, { type: "denied", text: verdict.reason });
+          return { kind: "reject", feedback: verdict.reason };
+        },
+        onUserInputRequest: async (q) => {
+          emit(run, { type: "question", text: q.question });
+          const answer = "This run is unattended and nobody can answer. Do not ask again. Stop and finish your final message with a line `BLOCKED: <reason>`.";
+          emit(run, { type: "answer", text: answer });
+          return { answer, wasFreeform: true };
+        }
+      });
+      run.session = session;
+      const idle = new Promise((resolve) => session.on("session.idle", () => resolve()));
+      session.on((raw) => {
+        const d = raw.data ?? {};
+        switch (raw.type) {
+          case "assistant.message":
+            if (d.content) emit(run, { type: "message", text: String(d.content) });
+            break;
+          case "tool.execution_start":
+            emit(run, { type: "tool", id: d.toolCallId, tool: d.toolName, text: d.toolTitle, args: clip(d.arguments) });
+            break;
+          case "tool.execution_complete":
+            emit(run, {
+              type: "tool-result",
+              id: d.toolCallId,
+              ok: d.success !== false,
+              result: clip(d.result?.detailedContent ?? d.result?.content ?? d.error?.message)
+            });
+            break;
+          case "session.error":
+            emit(run, { type: "error", text: friendlyError(String(d.message ?? "Unknown error")) });
+            break;
+        }
+      });
+      await session.send({ prompt: buildPrompt(req, relPath, run.record.target) });
+      await idle;
+      finish(run, "finished");
+    } catch (err) {
+      finish(run, run.record.status === "cancelled" ? "cancelled" : "failed", err instanceof Error ? err.message : String(err));
+    } finally {
+      await client.stop().catch(() => {
+      });
+      run.session = void 0;
+    }
+  })();
+  return run.record;
+}
+function subscribe(id, listener) {
+  const run = active.get(id);
+  if (!run) return null;
+  run.listeners.add(listener);
+  return () => run.listeners.delete(listener);
+}
+async function getRun(id) {
+  const live = active.get(id);
+  if (live) return live.record;
+  if (!/^[0-9a-f-]{36}$/.test(id)) return null;
+  try {
+    return settleOrphan(JSON.parse(await readFile12(path12.join(runsDir(), `${id}.json`), "utf-8")));
+  } catch {
+    return null;
+  }
+}
+async function listRuns() {
+  const records = /* @__PURE__ */ new Map();
+  const files = await readdir10(runsDir()).catch(() => []);
+  for (const f of files.filter((n) => n.endsWith(".json"))) {
+    try {
+      const r = JSON.parse(await readFile12(path12.join(runsDir(), f), "utf-8"));
+      records.set(r.id, settleOrphan(r));
+    } catch {
+    }
+  }
+  for (const [id, a] of active) records.set(id, a.record);
+  return [...records.values()].sort((a, b) => b.startedAt.localeCompare(a.startedAt)).map(({ id, request, status, startedAt, finishedAt, target }) => ({ id, request, status, startedAt, finishedAt, target }));
+}
+function busyTestRunFiles() {
+  const busy = /* @__PURE__ */ new Set();
+  for (const run of active.values()) {
+    if (run.record.status === "running") for (const f of run.record.target?.testRunFiles ?? []) busy.add(f);
+  }
+  return busy;
+}
+async function cancelRun(id) {
+  const run = active.get(id);
+  if (!run || run.record.status !== "running") return false;
+  run.record.status = "cancelled";
+  run.record.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+  emit(run, { type: "finished", text: "Cancelled", ok: false });
+  void settleRecords(run.record.target, "Agent run was stopped before this test case ran.");
+  await run.session?.abort().catch(() => {
+  });
+  run.stop?.();
+  await persist(run).catch(() => {
+  });
+  return true;
+}
+function claudeArgs(req, prompt) {
+  const nav = req.depth === "navigation";
+  const allowed = ["Bash(trxa:*)", "Read", "Glob", "Grep", "Edit", "Write", ...nav ? [...NAVIGATION_TOOLS].map((t) => `mcp__d365-erp-mcp__${t}`) : ["mcp__d365-erp-mcp"]];
+  const args = ["-p", prompt, "--output-format", "stream-json", "--verbose", "--permission-mode", "acceptEdits", "--allowedTools", allowed.join(",")];
+  if (nav) args.push("--disallowedTools", "mcp__d365-erp-mcp");
+  return args;
+}
+function runClaude(run, req, relPath, cwd) {
+  const prompt = buildPrompt(req, relPath, run.record.target);
+  const args = claudeArgs(req, prompt);
+  const nav = req.depth === "navigation";
+  const child = spawn("claude", args.map((a) => /[\s"()*&|<>^]/.test(a) ? `"${a.replace(/"/g, '\\"')}"` : a), { cwd, shell: true, windowsHide: true });
+  run.stop = () => {
+    if (child.pid) spawn("taskkill", ["/pid", String(child.pid), "/t", "/f"], { windowsHide: true }).on("error", () => child.kill());
+  };
+  let buf = "";
+  let stderr = "";
+  const handle = (line) => {
+    let m;
+    try {
+      m = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (m.type === "assistant") {
+      for (const c of m.message?.content ?? []) {
+        if (c.type === "text" && c.text) emit(run, { type: "message", text: c.text });
+        if (c.type === "tool_use") emit(run, { type: "tool", id: c.id, tool: String(c.name).replace(/^mcp__d365-erp-mcp__/, ""), text: void 0, args: clip(c.input) });
+      }
+    } else if (m.type === "user") {
+      for (const c of m.message?.content ?? []) {
+        if (c.type === "tool_result") {
+          const body = Array.isArray(c.content) ? c.content.map((x) => x?.text ?? "").join("\n") : c.content;
+          emit(run, { type: "tool-result", id: c.tool_use_id, ok: !c.is_error, result: clip(body) });
+          if (c.is_error && nav && /permission|not allowed|denied/i.test(JSON.stringify(c.content))) emit(run, { type: "denied", text: "A tool was blocked by the navigation-only rules." });
+        }
+      }
+    }
+  };
+  child.stdout.on("data", (d) => {
+    buf += d.toString();
+    const lines = buf.split(/\r?\n/);
+    buf = lines.pop() ?? "";
+    lines.forEach(handle);
+  });
+  child.stderr.on("data", (d) => {
+    stderr += d.toString();
+  });
+  child.on("error", (err) => finish(run, "failed", err.message));
+  child.on("close", (code) => {
+    if (buf.trim()) handle(buf);
+    if (run.record.status !== "running") return;
+    if (code === 0) finish(run, "finished");
+    else finish(run, "failed", stderr.trim().slice(-500) || `Claude Code exited with code ${code}`);
+  });
+}
+
+// studio/server/routes/agent.ts
+var agentRouter = Router9();
+var REPLAY_SKILL = "replay-trxa-testplan";
+var REQUIRED_MCP = "d365-erp-mcp";
+function cliVersion(cmd) {
+  return new Promise((resolve) => {
+    execFile(cmd, ["--version"], { shell: true, timeout: 15e3, windowsHide: true }, (err, stdout) => {
+      if (err) return resolve(null);
+      const first = stdout.split(/\r?\n/).find((l) => l.trim());
+      resolve(first ? first.trim() : null);
+    });
+  });
+}
+async function exists(p) {
+  try {
+    await access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readCommentedJson(file) {
+  try {
+    const raw = (await readFile13(file, "utf-8")).replace(/^\uFEFF/, "");
+    return JSON.parse(raw.split(/\r?\n/).filter((l) => !l.trim().startsWith("//")).join("\n"));
+  } catch {
+    return null;
+  }
+}
+async function copilotSignedInUser() {
+  const cfg = await readCommentedJson(path13.join(os2.homedir(), ".copilot", "config.json"));
+  const login = cfg?.lastLoggedInUser?.login ?? cfg?.loggedInUsers?.[0]?.login;
+  if (typeof login === "string" && login) return login;
+  if (process.env.COPILOT_GITHUB_TOKEN || process.env.GH_TOKEN || process.env.GITHUB_TOKEN) return "token from environment";
+  return null;
+}
+async function copilotMcpServers() {
+  const cfg = await readCommentedJson(path13.join(os2.homedir(), ".copilot", "mcp-config.json"));
+  return Object.keys(cfg?.mcpServers ?? cfg?.servers ?? {});
+}
+var normalizedPath = (p) => path13.resolve(p).split(path13.sep).join("/").toLowerCase();
+var samePath = (a, b) => normalizedPath(a) === normalizedPath(b);
+async function claudeMcpServers() {
+  const workingFolder = getWorkingFolder();
+  const [user, project] = await Promise.all([
+    readCommentedJson(path13.join(os2.homedir(), ".claude.json")),
+    readCommentedJson(path13.join(workingFolder, ".mcp.json"))
+  ]);
+  const projects = Object.entries(user?.projects ?? {}).filter(([dir]) => samePath(dir, workingFolder)).flatMap(([, p]) => Object.keys(p?.mcpServers ?? {}));
+  return [...Object.keys(user?.mcpServers ?? {}), ...projects, ...Object.keys(project?.mcpServers ?? {})];
+}
+async function replaySkillFound() {
+  const roots = [
+    path13.join(getWorkingFolder(), ".claude", "skills"),
+    path13.join(getWorkingFolder(), ".github", "skills"),
+    path13.join(os2.homedir(), ".claude", "skills"),
+    path13.join(os2.homedir(), ".copilot", "skills")
+  ];
+  const hits = await Promise.all(roots.map((r) => exists(path13.join(r, REPLAY_SKILL, "SKILL.md"))));
+  return hits.some(Boolean);
+}
+var SETUP_GUIDE = "https://github.com/elcanelo/trxa-tool/blob/master/SETUP.md";
+var guide = (anchor) => `${SETUP_GUIDE}#${anchor}`;
+async function checkReadiness() {
+  const [trxaVersion, copilotVersion, claudeVersion, user, copilotMcp, claudeMcp, skill, claudeCreds] = await Promise.all([
+    cliVersion("trxa"),
+    cliVersion("copilot"),
+    cliVersion("claude"),
+    copilotSignedInUser(),
+    copilotMcpServers(),
+    claudeMcpServers(),
+    replaySkillFound(),
+    exists(path13.join(os2.homedir(), ".claude", ".credentials.json"))
+  ]);
+  const mcpFor = { copilot: copilotMcp.includes(REQUIRED_MCP), claude: claudeMcp.includes(REQUIRED_MCP) };
+  const claudeSignedIn = claudeCreds || Boolean(process.env.ANTHROPIC_API_KEY);
+  const checks = [
+    // Every replay drives the run through `trxa resolve-next` / `record-result`. The desktop app
+    // ships its own copy and puts it on the server's PATH (desktop/main.cjs), so this only fails
+    // for a browser Studio started some other way than from an installed `trxa`.
+    trxaVersion ? { id: "trxa-cli", label: "TRXA CLI", status: "ok", detail: trxaVersion } : {
+      id: "trxa-cli",
+      label: "TRXA CLI",
+      status: "missing",
+      detail: "The trxa command was not found. The agent uses it to track and record the run.",
+      fix: "Install it with: npm install -g trxa-tool",
+      help: guide("step-1-install-trxa-tool")
+    },
+    copilotVersion ? { id: "copilot-cli", label: "GitHub Copilot CLI", status: "ok", detail: copilotVersion } : {
+      id: "copilot-cli",
+      label: "GitHub Copilot CLI",
+      status: "missing",
+      detail: "Not installed, or not found on PATH.",
+      fix: "Install it in PowerShell 7 with: winget install GitHub.Copilot",
+      help: guide("step-2-install-an-agent")
+    },
+    user ? { id: "copilot-login", label: "Copilot sign-in", status: "ok", detail: `Signed in as ${user}` } : {
+      id: "copilot-login",
+      label: "Copilot sign-in",
+      status: "missing",
+      detail: "No signed-in GitHub account found.",
+      fix: "Run copilot login in a terminal and follow the prompts.",
+      help: guide("step-3-sign-in-to-the-agent")
+    },
+    mcpFor.copilot || mcpFor.claude ? {
+      id: "mcp-d365",
+      label: "D365 ERP MCP server",
+      status: "ok",
+      detail: `${REQUIRED_MCP} is configured for ${[mcpFor.copilot && "GitHub Copilot", mcpFor.claude && "Claude Code"].filter(Boolean).join(" and ")}.`
+    } : {
+      id: "mcp-d365",
+      label: "D365 ERP MCP server",
+      status: "missing",
+      detail: `No MCP server named ${REQUIRED_MCP} is configured for GitHub Copilot or Claude Code.`,
+      fix: `Add ${REQUIRED_MCP} to your agent's MCP settings so it can work in D365.`,
+      help: guide("step-5-connect-the-agent-to-dynamics-365")
+    },
+    skill ? { id: "replay-skill", label: "Replay skill", status: "ok", detail: `${REPLAY_SKILL} found` } : {
+      id: "replay-skill",
+      label: "Replay skill",
+      status: "warn",
+      detail: `${REPLAY_SKILL} was not found in the working folder or your home skills folders.`,
+      fix: "Install it into the working folder, or run trxa init-skill there.",
+      help: guide("step-6-install-the-replay-skill"),
+      ...trxaVersion ? { action: "install-skill" } : {}
+    },
+    claudeVersion ? {
+      id: "claude-cli",
+      label: "Claude Code CLI",
+      status: claudeSignedIn ? "ok" : "warn",
+      detail: claudeSignedIn ? claudeVersion : `${claudeVersion} (installed, but no sign-in found)`,
+      ...claudeSignedIn ? {} : { fix: "Run claude once in a terminal and sign in.", help: guide("step-3-sign-in-to-the-agent") }
+    } : {
+      id: "claude-cli",
+      label: "Claude Code CLI",
+      status: "warn",
+      detail: "Not installed, or not found on PATH (optional).",
+      fix: "Install it in PowerShell with: irm https://claude.ai/install.ps1 | iex",
+      help: guide("step-2-install-an-agent")
+    }
+  ];
+  const ok = (id) => checks.find((c) => c.id === id)?.status === "ok";
+  const common = ok("trxa-cli") && ok("replay-skill");
+  return {
+    checks,
+    ready: {
+      copilot: ok("copilot-cli") && ok("copilot-login") && mcpFor.copilot && common,
+      claude: ok("claude-cli") && mcpFor.claude && common
+    }
+  };
+}
+agentRouter.get("/readiness", async (_req, res, next) => {
+  try {
+    res.json(await checkReadiness());
+  } catch (err) {
+    next(err);
+  }
+});
+agentRouter.post("/install-skill", (_req, res) => {
+  execFile("trxa", ["init-skill"], { shell: true, cwd: getWorkingFolder(), timeout: 3e4, windowsHide: true }, (err, _stdout, stderr) => {
+    const message = stderr.trim().split(/\r?\n/).filter(Boolean).pop() ?? "";
+    if (err) res.status(400).json({ error: message || err.message });
+    else res.json({ message });
+  });
+});
+agentRouter.post("/runs", async (req, res) => {
+  try {
+    const readiness = await checkReadiness();
+    const request = validateRequest(req.body);
+    const agent = request.agent ?? "copilot";
+    if (!readiness.ready[agent]) {
+      res.status(409).json({ error: `${agent === "claude" ? "Claude Code" : "GitHub Copilot"} is not ready. See Settings > Agent readiness.` });
+      return;
+    }
+    res.status(201).json(await startRun(request));
+  } catch (err) {
+    res.status(400).json({ error: err instanceof Error ? err.message : String(err) });
+  }
+});
+agentRouter.get("/runs", async (_req, res, next) => {
+  try {
+    res.json(await listRuns());
+  } catch (err) {
+    next(err);
+  }
+});
+agentRouter.get("/runs/:id", async (req, res, next) => {
+  try {
+    const run = await getRun(req.params.id);
+    if (!run) res.status(404).json({ error: "Run not found" });
+    else res.json(run);
+  } catch (err) {
+    next(err);
+  }
+});
+agentRouter.get("/runs/:id/events", async (req, res) => {
+  const run = await getRun(req.params.id);
+  if (!run) {
+    res.status(404).json({ error: "Run not found" });
+    return;
+  }
+  res.set({ "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive" });
+  res.flushHeaders();
+  const send = (e) => res.write(`data: ${JSON.stringify(e)}
+
+`);
+  run.events.forEach(send);
+  const unsubscribe = run.status === "running" ? subscribe(run.id, send) : null;
+  if (!unsubscribe) {
+    res.end();
+    return;
+  }
+  req.on("close", unsubscribe);
+});
+agentRouter.get("/runs/:id/log", async (req, res) => {
+  const run = await getRun(req.params.id);
+  if (!run) return res.status(404).json({ error: "Run not found" });
+  res.setHeader("Content-Disposition", `attachment; filename="agent-run-${run.id}.json"`);
+  res.json(run);
+});
+agentRouter.delete("/runs/:id", async (req, res) => {
+  res.json({ cancelled: await cancelRun(req.params.id) });
+});
+
+// studio/server/routes/runs.ts
+import { Router as Router10 } from "express";
+import { readdir as readdir11, readFile as readFile14, writeFile as writeFile11 } from "node:fs/promises";
+import path14 from "node:path";
+var EMPTY_CASES = () => ({ total: 0, pending: 0, running: 0, passed: 0, failed: 0, blocked: 0, skipped: 0 });
+async function readJsonDir(dir, parse) {
+  const out = /* @__PURE__ */ new Map();
+  const files = await readdir11(dir).catch(() => []);
+  for (const f of files.filter((n) => n.endsWith(".json"))) {
+    try {
+      out.set(f.replace(/\.json$/, ""), parse(JSON.parse(await readFile14(path14.join(dir, f), "utf-8"))));
+    } catch {
+    }
+  }
+  return out;
+}
+async function namesById(dir) {
+  const files = await readJsonDir(dir, (raw) => raw);
+  const names = /* @__PURE__ */ new Map();
+  for (const [slug, v] of files) {
+    const id = typeof v.id === "string" ? v.id : slug;
+    if (typeof v.name === "string" && v.name.trim()) names.set(id, v.name);
+  }
+  return names;
+}
+function addCases(cases, extras, testRun) {
+  for (const r of Object.values(testRun.results)) {
+    cases[r.status]++;
+    cases.total++;
+    if (r.tokensUsed !== void 0) {
+      extras.tokens += r.tokensUsed;
+      extras.hasTokens = true;
+    }
+    if (r.costUsd !== void 0) {
+      extras.cost += r.costUsd;
+      extras.hasCost = true;
+    }
+    if (r.startedAt && r.durationMs !== void 0) extras.lastEnd = Math.max(extras.lastEnd, Date.parse(r.startedAt) + r.durationMs);
+  }
+}
+function outcomeOf(cases, agentStatus, missingSuites) {
+  if (agentStatus === "running") return "running";
+  if (cases.total === 0 && agentStatus === "finished") return "no-results";
+  if (cases.failed > 0) return "failed";
+  if (agentStatus === "cancelled" || agentStatus === "interrupted") return agentStatus;
+  if (agentStatus === "failed" || cases.blocked > 0) return "failed";
+  if (cases.running > 0) return "running";
+  if (cases.total === 0 || cases.pending === cases.total) return "not-started";
+  if (cases.pending > 0 || missingSuites) return "incomplete";
+  return "passed";
+}
+async function buildRunRows() {
+  const [plans, planRuns, testRuns, agentRuns, suiteNames, caseNames] = await Promise.all([
+    readJsonDir(PLANS_DIR, validateTestPlan),
+    listPlanRuns(RUNS_DIR),
+    readJsonDir(TESTRUNS_DIR, validateTestRun),
+    listRuns(),
+    namesById(SUITES_DIR),
+    namesById(TESTCASES_DIR)
+  ]);
+  const planFileById = new Map([...plans].map(([file, plan]) => [plan.id, { file, name: plan.name }]));
+  const agentFor = (pred) => agentRuns.find(pred);
+  const claimedAgents = /* @__PURE__ */ new Set();
+  const claimedTestRuns = /* @__PURE__ */ new Set();
+  const rows = [];
+  const agentInfo = (a) => a && {
+    id: a.id,
+    status: a.status,
+    agent: a.request.agent ?? "copilot",
+    environment: a.request.environment,
+    company: a.request.company,
+    depth: a.request.depth
+  };
+  function finishRow(row, extras, missingSuites, agent) {
+    const end = agent?.finishedAt ? Date.parse(agent.finishedAt) : agent?.status === "running" ? Date.now() : extras.lastEnd;
+    return {
+      ...row,
+      ...agent?.finishedAt ? { finishedAt: agent.finishedAt } : {},
+      ...end > 0 ? { durationMs: Math.max(0, end - Date.parse(row.startedAt)) } : {},
+      outcome: outcomeOf(row.cases, agent?.status, missingSuites),
+      ...extras.hasTokens ? { tokens: extras.tokens } : {},
+      ...extras.hasCost ? { costUsd: extras.cost } : {}
+    };
+  }
+  for (const run of planRuns) {
+    const plan = planFileById.get(run.planId);
+    const suiteRuns = /* @__PURE__ */ new Map();
+    const cases = EMPTY_CASES();
+    const extras = { tokens: 0, cost: 0, hasTokens: false, hasCost: false, lastEnd: 0 };
+    for (const suiteId of run.suiteIds) {
+      const slug = `${suiteId}-${run.id}`;
+      const testRun = testRuns.get(slug) ?? null;
+      suiteRuns.set(suiteId, testRun);
+      if (testRun) {
+        claimedTestRuns.add(slug);
+        addCases(cases, extras, testRun);
+      }
+    }
+    const status = aggregatePlanStatus(run, suiteRuns);
+    const agent = agentFor((a) => a.target?.planRunId === run.id);
+    if (agent) claimedAgents.add(agent.id);
+    rows.push(
+      finishRow(
+        {
+          key: `run:${plan?.file ?? run.planId}:${run.id}`,
+          kind: "plan",
+          ...run.name ? { name: run.name } : {},
+          targetName: plan?.name ?? run.planId,
+          startedAt: run.startedAt,
+          cases,
+          suites: { total: status.suites.length, done: status.suites.filter((s) => s.status === "passed" || s.status === "failed").length },
+          agent: agentInfo(agent)
+        },
+        extras,
+        status.suites.some((s) => s.status === "missing"),
+        agent
+      )
+    );
+  }
+  for (const [slug, testRun] of testRuns) {
+    if (claimedTestRuns.has(slug)) continue;
+    const kind = testRun.scope === "testcase" ? "testcase" : "suite";
+    const agent = agentFor((a) => (testRun.agentRunId ? a.id === testRun.agentRunId : false) || (a.target?.testRunFiles.includes(slug) ?? false));
+    if (agent) claimedAgents.add(agent.id);
+    const cases = EMPTY_CASES();
+    const extras = { tokens: 0, cost: 0, hasTokens: false, hasCost: false, lastEnd: 0 };
+    addCases(cases, extras, testRun);
+    rows.push(
+      finishRow(
+        {
+          key: `testrun:${slug}`,
+          kind,
+          ...testRun.name ? { name: testRun.name } : {},
+          targetName: (kind === "testcase" ? caseNames : suiteNames).get(testRun.suiteId) ?? testRun.suiteId,
+          startedAt: testRun.startedAt,
+          cases,
+          agent: agentInfo(agent)
+        },
+        extras,
+        false,
+        agent
+      )
+    );
+  }
+  for (const a of agentRuns) {
+    if (claimedAgents.has(a.id)) continue;
+    const kind = a.request.kind;
+    const targetName = kind === "plan" ? plans.get(a.request.id)?.name ?? a.request.id : (kind === "suite" ? suiteNames : caseNames).get(a.request.id) ?? a.request.id;
+    rows.push(
+      finishRow(
+        {
+          key: `agent:${a.id}`,
+          kind,
+          ...a.request.name ? { name: a.request.name } : {},
+          targetName,
+          startedAt: a.startedAt,
+          cases: EMPTY_CASES(),
+          agent: agentInfo(a)
+        },
+        { tokens: 0, cost: 0, hasTokens: false, hasCost: false, lastEnd: 0 },
+        false,
+        a
+      )
+    );
+  }
+  rows.sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+  return rows;
+}
+var runsRouter = Router10();
+runsRouter.get("/", async (_req, res, next) => {
+  try {
+    res.json({ runs: await buildRunRows() });
+  } catch (err) {
+    next(err);
+  }
+});
+runsRouter.put("/name", async (req, res, next) => {
+  try {
+    const key = String(req.body?.key ?? "");
+    let name;
+    try {
+      name = normalizeRunName(req.body?.name);
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+      return;
+    }
+    let file;
+    let check;
+    if (key.startsWith("run:")) {
+      const runId = key.slice(key.indexOf(":", 4) + 1);
+      file = path14.join(RUNS_DIR, `${safeFileName(runId)}.json`);
+      check = validatePlanRun;
+    } else if (key.startsWith("testrun:")) {
+      const slug = safeFileName(key.slice("testrun:".length));
+      if (busyTestRunFiles().has(slug)) {
+        res.status(409).json({ error: "This run is still in progress. Rename it once it finishes." });
+        return;
+      }
+      file = path14.join(TESTRUNS_DIR, `${slug}.json`);
+      check = validateTestRun;
+    } else {
+      res.status(400).json({ error: "Only plan runs and test runs can be renamed." });
+      return;
+    }
+    const raw = JSON.parse(await readFile14(file, "utf-8"));
+    check(raw);
+    if (name) raw.name = name;
+    else delete raw.name;
+    await writeFile11(file, JSON.stringify(raw, null, 2), "utf-8");
+    res.json({ key, ...name ? { name } : {} });
+  } catch (err) {
+    next(err);
+  }
+});
+
 // studio/server/index.ts
 var PORT = Number(process.env.STUDIO_SERVER_PORT ?? 4321);
 var app = express2();
@@ -1918,9 +3154,11 @@ app.use("/api/suites", suitesRouter);
 app.use("/api/plans", plansRouter);
 app.use("/api/library", libraryRouter);
 app.use("/api/settings", settingsRouter);
+app.use("/api/agent", agentRouter);
+app.use("/api/runs", runsRouter);
 var CLIENT_DIST = [
-  path11.join(import.meta.dirname, "..", "client-dist"),
-  path11.join(import.meta.dirname, "..", "..", "client-dist")
+  path15.join(import.meta.dirname, "..", "client-dist"),
+  path15.join(import.meta.dirname, "..", "..", "client-dist")
 ].find((candidate) => existsSync(candidate));
 if (CLIENT_DIST) {
   app.use(express2.static(CLIENT_DIST));
@@ -1933,6 +3171,6 @@ var errorHandler = (err, _req, res, _next) => {
 app.use(errorHandler);
 var settings = await loadSettings();
 app.listen(PORT, "127.0.0.1", () => {
-  console.log(`trxa-tool Studio API listening on http://127.0.0.1:${PORT} (local only, do not expose on a network)`);
+  console.log(`TRXA Studio API listening on http://127.0.0.1:${PORT} (local only, do not expose on a network)`);
   console.log(`Working folder: ${settings.workingFolder}`);
 });