trxa-tool 0.0.0-stage → 0.2.0

package/studio/server/dist/index.js

@@ -0,0 +1,3176 @@
+// studio/server/index.ts
+import express2 from "express";
+import { existsSync } from "node:fs";
+import path15 from "node:path";
+
+// studio/server/routes/recordings.ts
+import { Router } from "express";
+import { readdir } from "node:fs/promises";
+import path2 from "node:path";
+
+// src/build-test-script.ts
+import { readFile } from "node:fs/promises";
+
+// src/extract.ts
+import JSZip from "jszip";
+var RECORDING_ENTRY = "Recording.xml";
+var RESOURCE_ENTRY = "recording_resource.xml";
+var BPM_ENTRY = "BPMPackage.ax7bpm";
+async function extractAxtr(fileBytes) {
+  const zip = await JSZip.loadAsync(fileBytes);
+  const recordingEntry = findEntry(zip, RECORDING_ENTRY);
+  if (!recordingEntry) {
+    throw new Error(`.axtr package does not contain a ${RECORDING_ENTRY} entry`);
+  }
+  const resourceEntry = findEntry(zip, RESOURCE_ENTRY);
+  const bpmEntry = findEntry(zip, BPM_ENTRY);
+  return {
+    recordingXml: await recordingEntry.async("string"),
+    resourceXml: resourceEntry ? await resourceEntry.async("string") : null,
+    bpmPackageBytes: bpmEntry ? await bpmEntry.async("nodebuffer") : null
+  };
+}
+function findEntry(zip, name) {
+  const exact = zip.file(name);
+  if (exact) return exact;
+  const match = Object.values(zip.files).find(
+    (f) => !f.dir && f.name.toLowerCase() === name.toLowerCase()
+  );
+  return match ?? null;
+}
+
+// src/parse.ts
+import { XMLParser } from "fast-xml-parser";
+var ARRAY_TAGS = /* @__PURE__ */ new Set([
+  "Node",
+  "Annotation",
+  "CommandArgument",
+  "string",
+  "KeyValueOfstringFormContextyaScvdpM"
+]);
+function makeParser() {
+  return new XMLParser({
+    ignoreAttributes: false,
+    attributeNamePrefix: "@_",
+    removeNSPrefix: true,
+    parseTagValue: false,
+    parseAttributeValue: false,
+    trimValues: true,
+    isArray: (tagName) => ARRAY_TAGS.has(tagName)
+  });
+}
+function isNil(v) {
+  if (v === void 0 || v === null) return true;
+  if (typeof v === "object" && !Array.isArray(v)) {
+    const o = v;
+    return o["@_nil"] === "true";
+  }
+  return false;
+}
+function text(v) {
+  if (isNil(v)) return null;
+  if (typeof v === "string") return v;
+  return null;
+}
+function textReq(v, field) {
+  const t = text(v);
+  if (t === null) throw new Error(`Expected required text field "${field}" to be present`);
+  return t;
+}
+function num(v) {
+  const t = text(v);
+  if (t === null || t === "") return null;
+  const n = Number(t);
+  return Number.isNaN(n) ? null : n;
+}
+function numReq(v, field) {
+  const n = num(v);
+  if (n === null) throw new Error(`Expected required numeric field "${field}" to be present`);
+  return n;
+}
+function bool(v) {
+  return text(v) === "true";
+}
+function collection(v, childTag) {
+  if (isNil(v)) return [];
+  if (typeof v === "string") return [];
+  const obj = v;
+  const child = obj[childTag];
+  if (child === void 0) return [];
+  return Array.isArray(child) ? child : [child];
+}
+function parseCommandArgument(raw) {
+  return {
+    IsReference: bool(raw.IsReference),
+    Value: textReq(raw.Value, "CommandArgument.Value")
+  };
+}
+function parseFormContext(raw) {
+  return {
+    FormID: textReq(raw.FormID, "FormContext.FormID"),
+    FormName: textReq(raw.FormName, "FormContext.FormName"),
+    RecordingName: textReq(raw.RecordingName, "FormContext.RecordingName"),
+    HasMetadata: bool(raw.HasMetadata),
+    Sequence: numReq(raw.Sequence, "FormContext.Sequence"),
+    Annotations: raw.Annotations
+  };
+}
+function parseFormContexts(raw) {
+  const entries = collection(raw, "KeyValueOfstringFormContextyaScvdpM");
+  const result = {};
+  for (const entry of entries) {
+    const key = textReq(entry.Key, "FormContexts.Key");
+    result[key] = parseFormContext(entry.Value);
+  }
+  return result;
+}
+function nodeBaseFields(raw) {
+  return {
+    Id: textReq(raw.Id, "Node.Id"),
+    Description: text(raw.Description) ?? "",
+    CustomDescription: text(raw.CustomDescription),
+    ParentSequence: numReq(raw.ParentSequence, "Node.ParentSequence"),
+    Sequence: numReq(raw.Sequence, "Node.Sequence"),
+    ScreenshotUri: text(raw.ScreenshotUri)
+  };
+}
+function userActionBaseFields(raw) {
+  return {
+    ...nodeBaseFields(raw),
+    GlobalId: textReq(raw.GlobalId, "UserAction.GlobalId"),
+    SystemGenerated: bool(raw.SystemGenerated)
+  };
+}
+function parseScope(raw) {
+  return {
+    kind: "Scope",
+    ...nodeBaseFields(raw),
+    Name: text(raw.Name) ?? "",
+    IsForm: bool(raw.IsForm),
+    IsStepGroup: bool(raw.IsStepGroup),
+    ScopeType: text(raw.ScopeType) ?? "",
+    Children: collection(raw.Children, "Node").map(
+      (n) => parseNode(n)
+    )
+  };
+}
+function parseMenuItemUserAction(raw) {
+  return {
+    kind: "MenuItemUserAction",
+    ...userActionBaseFields(raw),
+    MenuItemName: textReq(raw.MenuItemName, "MenuItemUserAction.MenuItemName"),
+    MenuItemType: text(raw.MenuItemType) ?? "",
+    NavigationPath: collection(raw.NavigationPath, "string").map((s) => textReq(s, "NavigationPath.string"))
+  };
+}
+function parseCommandUserAction(raw) {
+  return {
+    kind: "CommandUserAction",
+    ...userActionBaseFields(raw),
+    FormId: textReq(raw.FormId, "CommandUserAction.FormId"),
+    ControlName: text(raw.ControlName) ?? "",
+    ControlType: text(raw.ControlType) ?? "",
+    ControlLabel: text(raw.ControlLabel) ?? "",
+    ControlLabelId: text(raw.ControlLabelId) ?? "",
+    CommandName: textReq(raw.CommandName, "CommandUserAction.CommandName"),
+    Arguments: collection(raw.Arguments, "CommandArgument").map(
+      (a) => parseCommandArgument(a)
+    ),
+    ListContext: text(raw.ListContext),
+    RowIndex: num(raw.RowIndex),
+    ReturnType: text(raw.ReturnType) ?? "",
+    ReturnValue: text(raw.ReturnValue),
+    TaskId: text(raw.TaskId)
+  };
+}
+function parsePropertyUserAction(raw) {
+  return {
+    kind: "PropertyUserAction",
+    ...userActionBaseFields(raw),
+    FormId: textReq(raw.FormId, "PropertyUserAction.FormId"),
+    ControlName: text(raw.ControlName) ?? "",
+    ControlType: text(raw.ControlType) ?? "",
+    ControlLabel: text(raw.ControlLabel) ?? "",
+    ControlLabelId: text(raw.ControlLabelId) ?? "",
+    BoundDataSource: text(raw.BoundDataSource) ?? "",
+    BoundProperty: text(raw.BoundProperty) ?? "",
+    PropertyName: text(raw.PropertyName) ?? "",
+    UserActionType: text(raw.UserActionType) ?? "",
+    Value: text(raw.Value) ?? "",
+    ValueLabel: text(raw.ValueLabel),
+    IsReference: bool(raw.IsReference),
+    ListContext: text(raw.ListContext),
+    RowIndex: num(raw.RowIndex)
+  };
+}
+function parseUnknownUserAction(raw, xsiType) {
+  return {
+    kind: "Unknown",
+    ...userActionBaseFields(raw),
+    xsiType,
+    raw
+  };
+}
+function parseNode(raw) {
+  const xsiType = raw["@_type"] ?? "Scope";
+  switch (xsiType) {
+    case "Scope":
+      return parseScope(raw);
+    case "MenuItemUserAction":
+      return parseMenuItemUserAction(raw);
+    case "CommandUserAction":
+      return parseCommandUserAction(raw);
+    case "PropertyUserAction":
+      return parsePropertyUserAction(raw);
+    default:
+      return parseUnknownUserAction(raw, xsiType);
+  }
+}
+function parseRecordingXml(xml) {
+  const parser = makeParser();
+  const doc = parser.parse(xml);
+  const root = doc.Recording;
+  if (!root) {
+    throw new Error("Document does not contain a root <Recording> element");
+  }
+  const rootScopeRaw = root.RootScope;
+  const rootScope = {
+    kind: "Scope",
+    ...nodeBaseFields(rootScopeRaw),
+    Name: text(root.Name) ?? "",
+    IsForm: false,
+    IsStepGroup: false,
+    ScopeType: "Root",
+    Children: collection(rootScopeRaw.Children, "Node").map(
+      (n) => parseNode(n)
+    )
+  };
+  return {
+    CanonicalId: textReq(root.CanonicalId, "Recording.CanonicalId"),
+    CurrentSequence: numReq(root.CurrentSequence, "Recording.CurrentSequence"),
+    Description: text(root.Description) ?? "",
+    Name: textReq(root.Name, "Recording.Name"),
+    FormContexts: parseFormContexts(root.FormContexts),
+    RootScope: rootScope
+  };
+}
+
+// src/normalize.ts
+function formIdOf(node) {
+  if (node.kind === "CommandUserAction" || node.kind === "PropertyUserAction") {
+    return node.FormId;
+  }
+  if (node.kind === "Unknown") {
+    const raw = node.raw.FormId;
+    return typeof raw === "string" ? raw : null;
+  }
+  return null;
+}
+function collectLeaves(node, out) {
+  if (node.kind === "Scope") {
+    for (const child of node.Children) collectLeaves(child, out);
+  } else {
+    out.push(node);
+  }
+}
+function normalizeRecording(recording) {
+  const leaves = [];
+  collectLeaves(recording.RootScope, leaves);
+  const steps = leaves.map((node) => {
+    const formId = formIdOf(node);
+    return {
+      sequence: node.Sequence,
+      description: node.Description,
+      formId,
+      formName: formId ? recording.FormContexts[formId]?.FormName ?? null : null,
+      node
+    };
+  }).sort((a, b) => a.sequence - b.sequence);
+  return {
+    name: recording.Name,
+    canonicalId: recording.CanonicalId,
+    description: recording.Description,
+    steps
+  };
+}
+
+// src/mapping.ts
+function skipHint(step) {
+  if (step.node.kind === "Scope" || !step.node.SystemGenerated) return null;
+  return {
+    tool: "skip",
+    confidence: "high",
+    params: {},
+    note: "SystemGenerated=true in the recording; this was an automatic side effect, not a user action. Nothing to replay for this step."
+  };
+}
+function menuItemHint(step) {
+  if (step.node.kind !== "MenuItemUserAction") return null;
+  return {
+    tool: "form_open_menu_item",
+    confidence: "high",
+    params: { name: step.node.MenuItemName, type: step.node.MenuItemType }
+  };
+}
+function commandHint(step) {
+  if (step.node.kind !== "CommandUserAction") return null;
+  const { CommandName, ControlName, ControlType } = step.node;
+  if (ControlType === "Grid" && CommandName === "ChangeSelectedIndexInCache") {
+    return {
+      tool: "form_filter_grid",
+      confidence: "low",
+      params: { gridName: ControlName },
+      note: "Recording selects a grid row by recorded position (Arguments), which is not portable across environments/data. Confirmed on a live replay where the recorded index no longer pointed at the intended record. Identify the target record from surrounding step context (e.g. a business key mentioned in the description) and supply gridColumnName/gridColumnValue to filter the grid to it before selecting a row."
+    };
+  }
+  if (ControlType === "Grid" && (CommandName === "NavigationAction" || CommandName === "MarkActiveRow")) {
+    return {
+      tool: "form_select_grid_row",
+      confidence: "low",
+      params: { gridName: ControlName },
+      note: `Requires rowNumber (read it off the current grid state after filtering) and, per d365-erp-mcp's own per-grid guidance, usually a marking parameter ("Marked" to check the row's selection box, "Unmarked" to just navigate/highlight it).`
+    };
+  }
+  if (ControlType === "AppBarTab") {
+    return {
+      tool: "form_click_control",
+      confidence: "high",
+      params: { controlName: ControlName },
+      note: "Action Pane / ribbon tab selection."
+    };
+  }
+  if (ControlType === "Tab" || ControlType === "SectionPage" && CommandName === "ExpandedChanged" || ControlType === "PivotItem" && CommandName === "ActivateTab") {
+    return {
+      tool: "form_open_or_close_tab",
+      confidence: "high",
+      params: { tabName: ControlName, tabAction: "Open" },
+      note: ControlType === "SectionPage" ? `Confirmed live (form_open_or_close_tab works identically on ControlType=SectionPage, not just Tab). Recording can't tell you whether the user expanded or collapsed the section. Check the current FormState's Tab[name].IsOpen and only call this if it doesn't already match; use tabAction="Close" instead if collapsing.` : ControlType === "PivotItem" ? `Confirmed live on a purchase order line's detail Pivot (e.g. TabLineProject): opening one PivotItem auto-closes whichever sibling was open, so tabAction="Open" is always the right call here (unlike Tab/SectionPage, there's no independent collapse state to worry about).` : void 0
+    };
+  }
+  if (CommandName === "RequestPopup" && ControlType === "Input") {
+    return {
+      tool: "form_open_lookup",
+      confidence: "high",
+      params: { lookupName: ControlName },
+      note: "Confirmed live against a multi-select Purpose/Roles lookup: opens a SysLookupMultiSelectGrid-style popup form. Follow its own returned Guidance for how to select rows and confirm/cancel."
+    };
+  }
+  if (CommandName === "RequestPopup" && ControlType === "DropDialogButton") {
+    return {
+      tool: "form_click_control",
+      confidence: "high",
+      params: { controlName: ControlName },
+      note: "Confirmed live (e.g. the 'New from template' split button on Free text invoice): a DropDialogButton opens its popup via a plain click, same as CLICKABLE_CONTROL_TYPES below. Unlike RequestPopup on an Input control, this is not a lookup."
+    };
+  }
+  if (CommandName === "ExecuteHyperlink" && ControlType === "Input") {
+    return {
+      tool: "form_click_control",
+      confidence: "high",
+      params: { controlName: ControlName },
+      note: "Confirmed live (e.g. clicking a grid row's Name/description link to open its edit dialog): hyperlink-style Input fields are clicked the same way as any other control, despite the different CommandName."
+    };
+  }
+  if (CommandName === "SelectionPathChanged" && ControlType === "Tree") {
+    return {
+      tool: "form_click_control",
+      confidence: "medium",
+      params: { controlName: ControlName },
+      note: `Confirmed live on a category tree lookup (EcoResCategorySingleLookup/ctrlFormTree): tree nodes are clicked via actionId, formatted "Select:<n>" or "Expand:<n>" per the current FormState's Tree[name].Nodes[].Actions. Not a plain click. The node index is a live-session identifier, not portable from the recording (same non-portability caveat as grid row selection): find the target node by matching its Text to the business value you want, expanding parent nodes first if needed, then click with that node's own Actions.Select id.`
+    };
+  }
+  if (CommandName === "RequestClose") {
+    return {
+      tool: "form_close_form",
+      confidence: "high",
+      params: {},
+      note: "Confirmed live: closes the current popup/dialog with no ControlName needed (matches how these steps are recorded; there's no associated button). Some forms with explicit OK/Cancel buttons ask you to use those buttons instead of a direct close; in that case the recording captures a separate Click step on the button, not RequestClose."
+    };
+  }
+  if (ControlName === "buttonUpdateConfirm" && CommandName === "Click") {
+    return {
+      tool: "form_open_menu_item",
+      confidence: "medium",
+      params: { name: "SalesFormLetter_Confirmation", type: "Action" },
+      note: "Confirmed live (headless intercompany replay, 2026-08-20): buttonUpdateConfirm wasn't reachable on the SalesTable order form in this environment. Invoke the SalesFormLetter_Confirmation action menu item directly instead of clicking the recorded button."
+    };
+  }
+  if (ControlName === "buttonUpdateInvoice" && CommandName === "Click") {
+    return {
+      tool: "form_click_control",
+      confidence: "high",
+      params: { controlName: ControlName },
+      note: "Confirmed live (headless intercompany replay, 2026-08-20) on an intercompany purchase order (DEMF): clicking buttonUpdateInvoice from the PO form itself opened a USMF-scoped, empty vendor-invoice list; company context didn't carry through. Clicking it from the DEMF list page instead, with the target row marked and companyId set explicitly on that navigation, opened a correctly pre-populated invoice."
+    };
+  }
+  if (ControlName === "ButtonInterCompanyCustPackingSlipJournal" && CommandName === "Click") {
+    return {
+      tool: "form_click_control",
+      confidence: "high",
+      params: { controlName: ControlName },
+      followUp: [
+        {
+          tool: "form_click_control",
+          note: "Confirmed live (headless intercompany replay, 2026-08-20): generating an intercompany product receipt needs an explicit follow-up click on ButtonInterCompanyUpdate; posting the sales-side packing slip alone doesn't produce it."
+        }
+      ]
+    };
+  }
+  const CLICKABLE_CONTROL_TYPES = /* @__PURE__ */ new Set([
+    "CommandButton",
+    "MenuItemButton",
+    "MenuButton",
+    "MenuItem",
+    "Button"
+  ]);
+  if (CommandName === "Click" && CLICKABLE_CONTROL_TYPES.has(ControlType)) {
+    const isNestedMenuChild = ControlType === "MenuButton" || ControlType === "MenuItem";
+    return {
+      tool: "form_click_control",
+      confidence: "high",
+      params: { controlName: ControlName },
+      ...isNestedMenuChild && {
+        note: "Nested menu button children (ControlType MenuButton/MenuItem) could be clicked directly by name on a live replay; no separate 'open the dropdown' step was needed even though the recording captured two clicks."
+      }
+    };
+  }
+  const filterOrSortHint = filterManagerHint(step.node);
+  if (filterOrSortHint) return filterOrSortHint;
+  const investigated = INVESTIGATED_BUT_UNVERIFIED[`${CommandName}:${ControlType}`];
+  return {
+    tool: "form_find_controls",
+    confidence: "low",
+    params: { controlSearchTerm: ControlName },
+    note: investigated ? `Unmapped CommandUserAction (CommandName=${CommandName}, ControlType=${ControlType}). ${investigated}` : `Unmapped CommandUserAction (CommandName=${CommandName}, ControlType=${ControlType}). Resolve via form_find_controls before acting.`
+  };
+}
+function parseJson(raw) {
+  if (!raw) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function filterGridColumnName(meta) {
+  return `${meta.DataSourceName}_${meta.FieldName}`;
+}
+function filterOperatorToValue(operator, value) {
+  if (!value) return "";
+  switch (operator) {
+    case "BeginsWith":
+      return `${value}*`;
+    case "Contains":
+      return `*${value}*`;
+    case "EndsWith":
+      return `*${value}`;
+    default:
+      return value;
+  }
+}
+var FILTER_MANAGER_GRID_NAME_NOTE = `gridName isn't recorded on this step and isn't always "Grid". Standard lookup popups (e.g. CustTableLookup) commonly expose exactly one grid literally named "Grid" (confirmed live), but list-page forms (e.g. PurchTable) don't; confirm the real gridName from the current FormState before calling.`;
+function filterManagerHint(node) {
+  if (node.kind !== "CommandUserAction") return null;
+  const { CommandName, ControlType, Arguments } = node;
+  if (CommandName === "GetFilters" && ControlType === "FilterManager") {
+    return {
+      tool: "skip",
+      confidence: "medium",
+      params: {},
+      note: "Confirmed across every GetFilters:FilterManager occurrence in the recordings library: the embedded filter-field JSON always has an empty Values array. This step just opens/reads the column filter dropdown for display; nothing to replay. If a future recording ever shows a non-empty Values here, treat it like ApplyFiltersForTaskRecorder instead."
+    };
+  }
+  if (CommandName === "SetSortsForTaskRecorder" && ControlType === "FilterManager") {
+    const meta = parseJson(Arguments[0]?.Value)?.[0];
+    const direction = Arguments[Arguments.length - 1]?.Value;
+    if (meta && direction) {
+      return {
+        tool: "form_sort_grid_column",
+        confidence: "medium",
+        params: {
+          gridColumnName: filterGridColumnName(meta),
+          sortDirection: /z to a/i.test(direction) ? "Descending" : "Ascending"
+        },
+        note: `sortDirection parsed from the recording's human-readable direction ("${direction}"). ${FILTER_MANAGER_GRID_NAME_NOTE}`
+      };
+    }
+  }
+  if (CommandName === "ApplyFiltersForTaskRecorder" && ControlType === "FilterManager") {
+    const meta = parseJson(Arguments[0]?.Value)?.[0];
+    if (meta) {
+      return {
+        tool: "form_filter_grid",
+        confidence: "medium",
+        params: {
+          gridColumnName: filterGridColumnName(meta),
+          gridColumnValue: filterOperatorToValue(meta.Operator, meta.Values?.[0] ?? "")
+        },
+        note: FILTER_MANAGER_GRID_NAME_NOTE
+      };
+    }
+  }
+  if (CommandName === "ApplyFilterForTaskRecorder" && ControlType === "QuickFilter") {
+    const meta = parseJson(Arguments[2]?.Value);
+    if (meta) {
+      return {
+        tool: "form_filter_grid",
+        confidence: "medium",
+        params: { gridColumnName: meta.FieldName, gridColumnValue: meta.Value },
+        note: `gridColumnName/gridColumnValue parsed directly from the step's embedded JSON (already DataSource_Field form here, e.g. "ProjTable_Name", unlike the FilterManager family). ${FILTER_MANAGER_GRID_NAME_NOTE}`
+      };
+    }
+  }
+  if (CommandName === "ApplyFilters" && ControlType === "FilterPane") {
+    const metas = (parseJson(Arguments[2]?.Value) ?? []).filter(
+      (m) => (m.Values?.[0] ?? "") !== ""
+    );
+    if (metas.length > 0) {
+      const [first, ...rest] = metas;
+      return {
+        tool: "form_filter_grid",
+        confidence: "medium",
+        params: {
+          gridColumnName: filterGridColumnName(first),
+          gridColumnValue: filterOperatorToValue(first.Operator, first.Values[0])
+        },
+        followUp: rest.map((m) => ({
+          tool: "form_filter_grid",
+          note: `Also apply gridColumnName=${filterGridColumnName(m)}, gridColumnValue=${filterOperatorToValue(m.Operator, m.Values[0])} on the same grid.`
+        })),
+        note: `A FilterPane step can carry filters for multiple fields at once; fields with an empty recorded value are omitted (blank means "no filter" for that field, not "clear it"). ${FILTER_MANAGER_GRID_NAME_NOTE}`
+      };
+    }
+  }
+  return null;
+}
+var INVESTIGATED_BUT_UNVERIFIED = {
+  "GetFilters:FilterManager": "Expected empty Arguments; see filterManagerHint in this file.",
+  "ApplyFilterForTaskRecorder:QuickFilter": "Expected Arguments[2] to be JSON with FieldName/Value; see filterManagerHint in this file.",
+  "ApplyFiltersForTaskRecorder:FilterManager": "Expected Arguments[0] to be a JSON array with DataSourceName/FieldName/Operator/Values; see filterManagerHint in this file.",
+  "SetSortsForTaskRecorder:FilterManager": "Expected Arguments[0] to be a JSON array with DataSourceName/FieldName, and a trailing human-readable direction; see filterManagerHint in this file.",
+  "ApplyFilters:FilterPane": "Expected Arguments[2] to be a JSON array of per-field filter objects; see filterManagerHint in this file."
+};
+var ISO_DATE = /^(\d{4})-(\d{2})-(\d{2})$/;
+function formatDateForControl(value) {
+  const match = ISO_DATE.exec(value);
+  if (!match) return value;
+  const [, year, month, day] = match;
+  return `${Number(month)}/${Number(day)}/${Number(year)}`;
+}
+function propertyHint(step) {
+  if (step.node.kind !== "PropertyUserAction") return null;
+  const { ControlName, ControlType, Value, ListContext, UserActionType } = step.node;
+  const formattedValue = ControlType === "Date" && Value ? formatDateForControl(Value) : Value;
+  if (ListContext && UserActionType !== "Input") {
+    return {
+      tool: "form_filter_grid",
+      confidence: "medium",
+      params: { gridName: ListContext, gridColumnName: ControlName, gridColumnValue: formattedValue },
+      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: liveControlName, value: formattedValue }] },
+    followUp: [
+      {
+        tool: "form_save_form",
+        note: "Confirmed live: the form reports 'has been modified and needs to be saved' after form_set_control_values. Edits are not persisted until form_save_form is called."
+      }
+    ]
+  };
+}
+function mapStep(step) {
+  return skipHint(step) ?? menuItemHint(step) ?? commandHint(step) ?? propertyHint(step);
+}
+
+// src/bpm.ts
+import JSZip2 from "jszip";
+import { XMLParser as XMLParser2 } from "fast-xml-parser";
+function asArray(v) {
+  if (v === void 0) return [];
+  return Array.isArray(v) ? v : [v];
+}
+function parseProcessStepXml(xml) {
+  const parser = new XMLParser2({ ignoreAttributes: false, attributeNamePrefix: "" });
+  const doc = parser.parse(xml);
+  const tasks = asArray(doc.Activities?.Task);
+  return {
+    tasks: tasks.map((t) => ({
+      id: String(t.Id ?? ""),
+      aotName: String(t.AOTName ?? ""),
+      objectType: String(t.ObjectType ?? ""),
+      configurationKey: String(t.ConfigurationKey ?? ""),
+      layer: String(t.Layer ?? ""),
+      model: String(t.Model ?? ""),
+      sequence: Number(t.Sequence ?? 0),
+      security: asArray(t.Permissions?.Security).map((s) => ({
+        roleName: String(s.RoleName ?? ""),
+        roleDisplayName: String(s.RoleDisplayName ?? ""),
+        dutyName: String(s.DutyName ?? ""),
+        dutyDisplayName: String(s.DutyDisplayName ?? ""),
+        privilegeName: String(s.PrivilegeName ?? ""),
+        privilegeDisplayName: String(s.PrivilegeDisplayName ?? ""),
+        accessLevel: String(s.AccessLevel ?? ""),
+        isValidRole: String(s.IsValidRole ?? "").toLowerCase() === "true"
+      })),
+      connectsTo: asArray(t.Connections?.Connection).map((c) => String(c.Target ?? ""))
+    }))
+  };
+}
+async function parseBpmPackage(bytes) {
+  if (!bytes) return null;
+  const zip = await JSZip2.loadAsync(bytes);
+  const entry = zip.file("Recording/ProcessStep.xml") ?? zip.file("Recording\\ProcessStep.xml") ?? null;
+  if (!entry) return null;
+  const xml = await entry.async("string");
+  return parseProcessStepXml(xml);
+}
+function distinctPrivileges(pkg) {
+  const set = /* @__PURE__ */ new Set();
+  for (const task of pkg.tasks) {
+    for (const sec of task.security) {
+      if (sec.privilegeName) set.add(sec.privilegeName);
+    }
+  }
+  return [...set];
+}
+
+// src/build-test-script.ts
+async function loadTestScript(axtrPath) {
+  const bytes = await readFile(axtrPath);
+  const extracted = await extractAxtr(bytes);
+  const recording = parseRecordingXml(extracted.recordingXml);
+  return normalizeRecording(recording);
+}
+async function buildTestScript(axtrPath) {
+  const bytes = await readFile(axtrPath);
+  const extracted = await extractAxtr(bytes);
+  const recording = parseRecordingXml(extracted.recordingXml);
+  const script = normalizeRecording(recording);
+  const bpm = await parseBpmPackage(extracted.bpmPackageBytes);
+  return {
+    name: script.name,
+    canonicalId: script.canonicalId,
+    description: script.description,
+    steps: script.steps.map((step) => ({
+      sequence: step.sequence,
+      description: step.description,
+      formName: step.formName,
+      nodeType: step.node.kind,
+      node: step.node,
+      hint: mapStep(step)
+    })),
+    security: bpm ? {
+      requiredPrivileges: distinctPrivileges(bpm),
+      formsVisited: bpm.tasks.map((t) => ({ aotName: t.aotName, objectType: t.objectType }))
+    } : null
+  };
+}
+
+// src/suggest-inputs.ts
+function uniqueName(base, seen) {
+  if (!seen.has(base)) {
+    seen.add(base);
+    return base;
+  }
+  let n = 2;
+  while (seen.has(`${base}_${n}`)) n++;
+  const name = `${base}_${n}`;
+  seen.add(name);
+  return name;
+}
+function draftFromPropertyStep(step, seen) {
+  if (step.node.kind !== "PropertyUserAction") return null;
+  const controlName = step.node.ControlName || `step${step.sequence}`;
+  const name = uniqueName(controlName, seen);
+  return {
+    name,
+    // ControlLabel is the human-readable label D365FO itself shows next to the field (e.g.
+    // "Quantity"), as opposed to `name`/controlName which is the internal control identifier
+    // (e.g. "PurchLine_PurchQtyGrid") -- useful for UIs that want to show a form-goer-friendly
+    // label instead of the raw control name.
+    controlLabel: step.node.ControlLabel || void 0,
+    description: step.description || `Value for ${controlName}`,
+    example: step.node.Value,
+    required: true,
+    bindTo: { kind: "control", stepSequence: step.sequence, controlName }
+  };
+}
+function draftFromGridFilterStep(step, seen) {
+  const hint = mapStep(step);
+  if (!hint || hint.tool !== "form_filter_grid") return null;
+  const recordedValue = typeof hint.params.gridColumnValue === "string" ? hint.params.gridColumnValue : void 0;
+  const name = uniqueName(`record_${step.sequence}`, seen);
+  return {
+    name,
+    description: `Needs a business key to identify the record for: "${step.description}". ` + (recordedValue ? `The recording filtered by "${recordedValue}", one specific record from that session -- ` : "The source recording only captured a row position, which is not portable across environments/data -- ") + "supply the actual value (e.g. an account number, order id) for this environment/data here.",
+    required: true,
+    example: recordedValue,
+    bindTo: { kind: "grid-row-selector", stepSequence: step.sequence, note: step.description }
+  };
+}
+function suggestInputs(script) {
+  const seen = /* @__PURE__ */ new Set();
+  const candidates = [];
+  for (const step of script.steps) {
+    const fromProperty = draftFromPropertyStep(step, seen);
+    if (fromProperty) {
+      candidates.push(fromProperty);
+      continue;
+    }
+    const fromGridFilter = draftFromGridFilterStep(step, seen);
+    if (fromGridFilter) candidates.push(fromGridFilter);
+  }
+  return { testScriptName: script.name, candidates };
+}
+
+// studio/server/paths.ts
+import path from "node:path";
+var WORKING_FOLDER = process.cwd();
+var RECORDINGS_DIR = path.join(WORKING_FOLDER, "recordings");
+var TESTCASES_DIR = path.join(WORKING_FOLDER, "testcases");
+var TESTDATA_DIR = path.join(WORKING_FOLDER, "testdata");
+var TESTSCRIPTS_DIR = path.join(WORKING_FOLDER, "testscripts");
+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];
+}
+function setWorkingFolder(folder) {
+  WORKING_FOLDER = folder;
+  RECORDINGS_DIR = path.join(WORKING_FOLDER, "recordings");
+  TESTCASES_DIR = path.join(WORKING_FOLDER, "testcases");
+  TESTDATA_DIR = path.join(WORKING_FOLDER, "testdata");
+  TESTSCRIPTS_DIR = path.join(WORKING_FOLDER, "testscripts");
+  TESTRUNS_DIR = path.join(WORKING_FOLDER, "testruns");
+  SUITES_DIR = path.join(WORKING_FOLDER, "suites");
+  PLANS_DIR = path.join(WORKING_FOLDER, "plans");
+  RUNS_DIR = path.join(WORKING_FOLDER, "runs");
+}
+function safeFileName(name) {
+  const base = path.basename(name);
+  if (!base || base === "." || base === "..") throw new Error(`Invalid file name: "${name}"`);
+  return base;
+}
+function safeRecordingPath(relativePath) {
+  const normalized = relativePath.replace(/\\/g, "/");
+  const resolved = path.resolve(RECORDINGS_DIR, normalized);
+  if (resolved !== RECORDINGS_DIR && !resolved.startsWith(RECORDINGS_DIR + path.sep)) {
+    throw new Error(`Invalid recording path: "${relativePath}"`);
+  }
+  return resolved;
+}
+function safeTestScriptPath(testScriptPath) {
+  const normalized = testScriptPath.replace(/\\/g, "/");
+  const resolved = path.resolve(TESTCASES_DIR, normalized);
+  if (resolved !== TESTSCRIPTS_DIR && !resolved.startsWith(TESTSCRIPTS_DIR + path.sep)) {
+    throw new Error(`Invalid testScriptPath: "${testScriptPath}"`);
+  }
+  return resolved;
+}
+function safeSuitePathFromPlan(suitePath) {
+  const normalized = suitePath.replace(/\\/g, "/");
+  const resolved = path.resolve(PLANS_DIR, normalized);
+  if (resolved !== SUITES_DIR && !resolved.startsWith(SUITES_DIR + path.sep)) {
+    throw new Error(`Invalid suitePath: "${suitePath}"`);
+  }
+  return resolved;
+}
+
+// studio/server/routes/recordings.ts
+var recordingsRouter = Router();
+async function listAxtrFilesRecursive(dir) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  const results = [];
+  for (const entry of entries) {
+    const fullPath = path2.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...await listAxtrFilesRecursive(fullPath));
+    } else if (entry.isFile() && entry.name.toLowerCase().endsWith(".axtr")) {
+      results.push(path2.relative(RECORDINGS_DIR, fullPath).replace(/\\/g, "/"));
+    }
+  }
+  return results;
+}
+recordingsRouter.get("/", async (_req, res) => {
+  const files = await listAxtrFilesRecursive(RECORDINGS_DIR);
+  res.json({ files: files.sort() });
+});
+function recordingFileFromBody(req) {
+  const body = req.body;
+  if (typeof body.file !== "string" || body.file.length === 0) {
+    throw new Error('"file" is required');
+  }
+  return body.file;
+}
+recordingsRouter.post("/parse", async (req, res) => {
+  const axtrPath = safeRecordingPath(recordingFileFromBody(req));
+  res.json(await buildTestScript(axtrPath));
+});
+recordingsRouter.post("/suggest-inputs", async (req, res) => {
+  const axtrPath = safeRecordingPath(recordingFileFromBody(req));
+  const script = await loadTestScript(axtrPath);
+  res.json(suggestInputs(script));
+});
+
+// studio/server/routes/testcases.ts
+import { Router as Router2 } from "express";
+import { readdir as readdir2, readFile as readFile2, writeFile, unlink, mkdir, stat } from "node:fs/promises";
+import path3 from "node:path";
+
+// src/testcase-schema.ts
+function fail(field, reason) {
+  throw new Error(`Invalid TestCase: ${field} ${reason}`);
+}
+function assertString(value, field) {
+  if (typeof value !== "string" || value.length === 0) fail(field, "must be a non-empty string");
+}
+function assertBindTarget(value, field) {
+  if (typeof value !== "object" || value === null) fail(field, "must be an object");
+  const v = value;
+  if (typeof v.stepSequence !== "number") fail(`${field}.stepSequence`, "must be a number");
+  if (v.kind === "control") {
+    assertString(v.controlName, `${field}.controlName`);
+  } else if (v.kind === "grid-row-selector") {
+    assertString(v.note, `${field}.note`);
+  } else {
+    fail(`${field}.kind`, 'must be "control" or "grid-row-selector"');
+  }
+}
+function validateInputParamSpec(value, index) {
+  if (typeof value !== "object" || value === null) fail(`inputs[${index}]`, "must be an object");
+  const v = value;
+  assertString(v.name, `inputs[${index}].name`);
+  assertString(v.description, `inputs[${index}].description`);
+  if (typeof v.required !== "boolean") fail(`inputs[${index}].required`, "must be a boolean");
+  assertBindTarget(v.bindTo, `inputs[${index}].bindTo`);
+  if (v.example !== void 0) assertString(v.example, `inputs[${index}].example`);
+  if (v.controlLabel !== void 0) assertString(v.controlLabel, `inputs[${index}].controlLabel`);
+  return v;
+}
+function validateOutputCaptureSpec(value, index) {
+  if (typeof value !== "object" || value === null) fail(`outputs[${index}]`, "must be an object");
+  const v = value;
+  assertString(v.name, `outputs[${index}].name`);
+  if (v.kind === "odata") {
+    assertString(v.entitySet, `outputs[${index}].entitySet`);
+    assertString(v.filter, `outputs[${index}].filter`);
+    assertString(v.field, `outputs[${index}].field`);
+  } else if (v.kind === "uiField") {
+    if (typeof v.afterStepSequence !== "number") {
+      fail(`outputs[${index}].afterStepSequence`, "must be a number");
+    }
+    if (v.controlName !== void 0 && typeof v.controlName !== "string") {
+      fail(`outputs[${index}].controlName`, "must be a string");
+    }
+    if (v.hint !== void 0 && typeof v.hint !== "string") {
+      fail(`outputs[${index}].hint`, "must be a string");
+    }
+    if (!v.controlName && !v.hint) {
+      fail(`outputs[${index}]`, "must have a non-empty controlName or hint");
+    }
+  } else {
+    fail(`outputs[${index}].kind`, 'must be "odata" or "uiField"');
+  }
+  return v;
+}
+function validateExpectation(value, index) {
+  if (typeof value !== "object" || value === null) {
+    fail(`expectations[${index}]`, "must be an object");
+  }
+  const v = value;
+  assertString(v.description, `expectations[${index}].description`);
+  if (typeof v.checkAfterStepSequence !== "number") {
+    fail(`expectations[${index}].checkAfterStepSequence`, "must be a number");
+  }
+  if (v.kind === "odata") {
+    assertString(v.entitySet, `expectations[${index}].entitySet`);
+    assertString(v.filter, `expectations[${index}].filter`);
+    assertString(v.expectedField, `expectations[${index}].expectedField`);
+    assertString(v.expectedValue, `expectations[${index}].expectedValue`);
+    assertString(v.comparator, `expectations[${index}].comparator`);
+  } else if (v.kind === "uiMessage") {
+    assertString(v.severity, `expectations[${index}].severity`);
+    if (typeof v.pattern !== "string") fail(`expectations[${index}].pattern`, "must be a string");
+    if (typeof v.shouldExist !== "boolean") {
+      fail(`expectations[${index}].shouldExist`, "must be a boolean");
+    }
+  } else {
+    fail(`expectations[${index}].kind`, 'must be "odata" or "uiMessage"');
+  }
+  return v;
+}
+function validateTestCase(value) {
+  if (typeof value !== "object" || value === null) fail("testcase", "must be an object");
+  const v = value;
+  assertString(v.id, "id");
+  assertString(v.name, "name");
+  assertString(v.description, "description");
+  assertString(v.testScriptPath, "testScriptPath");
+  if (v.sourceRecordingFolder !== void 0) assertString(v.sourceRecordingFolder, "sourceRecordingFolder");
+  if (!Array.isArray(v.inputs)) fail("inputs", "must be an array");
+  if (!Array.isArray(v.outputs)) fail("outputs", "must be an array");
+  if (!Array.isArray(v.expectations)) fail("expectations", "must be an array");
+  return {
+    id: v.id,
+    name: v.name,
+    description: v.description,
+    testScriptPath: v.testScriptPath,
+    ...v.sourceRecordingFolder !== void 0 ? { sourceRecordingFolder: v.sourceRecordingFolder } : {},
+    inputs: v.inputs.map(validateInputParamSpec),
+    outputs: v.outputs.map(validateOutputCaptureSpec),
+    expectations: v.expectations.map(validateExpectation)
+  };
+}
+
+// studio/server/routes/testcases.ts
+var testCasesRouter = Router2();
+testCasesRouter.get("/", async (_req, res) => {
+  const files = (await readdir2(TESTCASES_DIR)).filter((f) => f.endsWith(".json"));
+  const summaries = [];
+  for (const file of files) {
+    try {
+      const raw = JSON.parse(await readFile2(path3.join(TESTCASES_DIR, file), "utf-8"));
+      const testCase = validateTestCase(raw);
+      summaries.push({
+        id: testCase.id,
+        name: testCase.name,
+        description: testCase.description,
+        inputCount: testCase.inputs.length,
+        outputCount: testCase.outputs.length,
+        inputs: testCase.inputs,
+        sourceRecordingFolder: testCase.sourceRecordingFolder
+      });
+    } catch (err) {
+      summaries.push({
+        id: file.replace(/\.json$/, ""),
+        name: file,
+        description: `Invalid test case file: ${err instanceof Error ? err.message : String(err)}`,
+        inputCount: 0,
+        outputCount: 0,
+        inputs: [],
+        invalid: true
+      });
+    }
+  }
+  res.json({ testCases: summaries });
+});
+testCasesRouter.get("/:id", async (req, res) => {
+  const id = safeFileName(req.params.id);
+  const raw = JSON.parse(await readFile2(path3.join(TESTCASES_DIR, `${id}.json`), "utf-8"));
+  res.json(validateTestCase(raw));
+});
+testCasesRouter.get("/:id/script", async (req, res) => {
+  const id = safeFileName(req.params.id);
+  const raw = JSON.parse(await readFile2(path3.join(TESTCASES_DIR, `${id}.json`), "utf-8"));
+  const testCase = validateTestCase(raw);
+  const scriptPath = safeTestScriptPath(testCase.testScriptPath);
+  res.json(JSON.parse(await readFile2(scriptPath, "utf-8")));
+});
+async function fileExists(filePath) {
+  try {
+    await stat(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+testCasesRouter.post("/", async (req, res) => {
+  const body = req.body;
+  if (typeof body.id !== "string" || body.id.length === 0) {
+    res.status(400).json({ error: '"id" is required' });
+    return;
+  }
+  if (typeof body.sourceRecording !== "string" || body.sourceRecording.length === 0) {
+    res.status(400).json({ error: '"sourceRecording" is required' });
+    return;
+  }
+  const id = safeFileName(body.id);
+  const testCasePath = path3.join(TESTCASES_DIR, `${id}.json`);
+  if (await fileExists(testCasePath)) {
+    res.status(409).json({ error: `Test case file "${id}.json" already exists` });
+    return;
+  }
+  const axtrPath = safeRecordingPath(body.sourceRecording);
+  const testScript = await buildTestScript(axtrPath);
+  await mkdir(TESTSCRIPTS_DIR, { recursive: true });
+  const testScriptFileName = `${id}.testscript.json`;
+  await writeFile(
+    path3.join(TESTSCRIPTS_DIR, testScriptFileName),
+    JSON.stringify(testScript, null, 2) + "\n",
+    "utf-8"
+  );
+  const recordingParts = body.sourceRecording.split("/");
+  const sourceRecordingFolder = recordingParts.length > 1 ? recordingParts.slice(0, -1).join("/") : void 0;
+  const trimmedDescription = typeof body.description === "string" ? body.description.trim() : "";
+  const testCase = validateTestCase({
+    id,
+    name: body.name,
+    description: trimmedDescription.length > 0 ? trimmedDescription : `Created via TRXA Studio from ${body.sourceRecording}.`,
+    testScriptPath: `../testscripts/${testScriptFileName}`,
+    ...sourceRecordingFolder ? { sourceRecordingFolder } : {},
+    inputs: body.inputs ?? [],
+    outputs: [],
+    expectations: []
+  });
+  await writeFile(testCasePath, JSON.stringify(testCase, null, 2) + "\n", "utf-8");
+  res.status(201).json(testCase);
+});
+testCasesRouter.put("/:id", async (req, res) => {
+  const id = safeFileName(req.params.id);
+  const testCasePath = path3.join(TESTCASES_DIR, `${id}.json`);
+  if (!await fileExists(testCasePath)) {
+    res.status(404).json({ error: `Test case file "${id}.json" does not exist` });
+    return;
+  }
+  const existing = validateTestCase(JSON.parse(await readFile2(testCasePath, "utf-8")));
+  const testCase = validateTestCase({ ...req.body, id: existing.id, testScriptPath: existing.testScriptPath });
+  await writeFile(testCasePath, JSON.stringify(testCase, null, 2) + "\n", "utf-8");
+  res.json(testCase);
+});
+testCasesRouter.delete("/:id", async (req, res) => {
+  const id = safeFileName(req.params.id);
+  await unlink(path3.join(TESTCASES_DIR, `${id}.json`));
+  res.status(204).end();
+});
+
+// studio/server/routes/fixtures.ts
+import { Router as Router3 } from "express";
+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");
+  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");
+  }
+  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,
+    entries: v.entries.map(validateTestSuiteEntry)
+  };
+}
+
+// studio/server/routes/fixtures.ts
+var fixturesRouter = Router3();
+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;
+  }
+  return false;
+}
+async function readSuites() {
+  const files = (await readdir4(SUITES_DIR)).filter((f) => f.endsWith(".json"));
+  const suites = [];
+  for (const file of files) {
+    try {
+      suites.push({ file: file.replace(/\.json$/, ""), suite: validateTestSuite(JSON.parse(await readFile4(path5.join(SUITES_DIR, file), "utf-8"))) });
+    } catch {
+    }
+  }
+  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.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 (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 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;
+  }
+  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("/: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;
+  }
+  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("/: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 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 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 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) {
+    fail5(`results.${testCaseId}`, "must be an object");
+  }
+  const v = value;
+  if (!VALID_STATUSES.includes(v.status)) {
+    fail5(`results.${testCaseId}.status`, `must be one of ${VALID_STATUSES.join(", ")}`);
+  }
+  if (typeof v.outputs !== "object" || v.outputs === null || Array.isArray(v.outputs)) {
+    fail5(`results.${testCaseId}.outputs`, "must be an object");
+  }
+  if (!Array.isArray(v.assertionResults)) {
+    fail5(`results.${testCaseId}.assertionResults`, "must be an array");
+  }
+  if (v.sequence !== void 0 && typeof v.sequence !== "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))) {
+    fail5(`results.${testCaseId}.inputs`, "must be an object");
+  }
+  if (v.startedAt !== void 0 && typeof v.startedAt !== "string") {
+    fail5(`results.${testCaseId}.startedAt`, "must be a string");
+  }
+  if (v.durationMs !== void 0 && typeof v.durationMs !== "number") {
+    fail5(`results.${testCaseId}.durationMs`, "must be a number");
+  }
+  if (v.tokensUsed !== void 0 && typeof v.tokensUsed !== "number") {
+    fail5(`results.${testCaseId}.tokensUsed`, "must be a number");
+  }
+  if (v.costUsd !== void 0 && typeof v.costUsd !== "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"))) {
+    fail5(`results.${testCaseId}.messages`, "must be an array of strings");
+  }
+  return {
+    status: v.status,
+    outputs: v.outputs,
+    assertionResults: v.assertionResults,
+    ...v.sequence !== void 0 ? { sequence: v.sequence } : {},
+    ...v.inputs !== void 0 ? { inputs: v.inputs } : {},
+    ...v.startedAt !== void 0 ? { startedAt: v.startedAt } : {},
+    ...v.durationMs !== void 0 ? { durationMs: v.durationMs } : {},
+    ...v.tokensUsed !== void 0 ? { tokensUsed: v.tokensUsed } : {},
+    ...v.costUsd !== void 0 ? { costUsd: v.costUsd } : {},
+    ...v.messages !== void 0 ? { messages: v.messages } : {}
+  };
+}
+function validateTestRun(value) {
+  if (typeof value !== "object" || value === null) fail5("testRun", "must be an object");
+  const v = value;
+  assertString5(v.suiteId, "suiteId");
+  assertString5(v.startedAt, "startedAt");
+  if (typeof v.results !== "object" || v.results === null || Array.isArray(v.results)) {
+    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);
+  }
+  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 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 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,
+        ...testRun.scope ? { scope: testRun.scope } : {},
+        ...testRun.agentRunId ? { agentRunId: testRun.agentRunId } : {}
+      });
+    } catch (err) {
+      summaries.push({
+        file: slug,
+        suiteId: "",
+        startedAt: "",
+        counts: {},
+        invalid: true,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  summaries.sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+  res.json({ testRuns: summaries });
+});
+testRunsRouter.get("/:file", async (req, res) => {
+  const slug = safeFileName(req.params.file);
+  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 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 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) {
+  const ids = new Set(suite.entries.map((e) => e.testCaseId));
+  for (const entry of suite.entries) {
+    for (const dep of entry.dependsOn) {
+      if (!ids.has(dep)) {
+        throw new Error(
+          `Suite "${suite.id}": entry "${entry.testCaseId}" depends on unknown testCaseId "${dep}"`
+        );
+      }
+    }
+    if (entry.runIf && !entry.dependsOn.includes(entry.runIf.testCaseId)) {
+      throw new Error(
+        `Suite "${suite.id}": entry "${entry.testCaseId}"'s runIf references "${entry.runIf.testCaseId}", which must be one of its own dependsOn`
+      );
+    }
+  }
+  const inDegree = /* @__PURE__ */ new Map();
+  for (const entry of suite.entries) inDegree.set(entry.testCaseId, entry.dependsOn.length);
+  const dependents = /* @__PURE__ */ new Map();
+  for (const entry of suite.entries) {
+    for (const dep of entry.dependsOn) {
+      dependents.set(dep, [...dependents.get(dep) ?? [], entry.testCaseId]);
+    }
+  }
+  const queue = suite.entries.filter((e) => e.dependsOn.length === 0).map((e) => e.testCaseId);
+  const order = [];
+  while (queue.length > 0) {
+    const id = queue.shift();
+    order.push(id);
+    for (const dependent of dependents.get(id) ?? []) {
+      const remaining = inDegree.get(dependent) - 1;
+      inDegree.set(dependent, remaining);
+      if (remaining === 0) queue.push(dependent);
+    }
+  }
+  if (order.length !== suite.entries.length) {
+    const stuck = suite.entries.map((e) => e.testCaseId).filter((id) => !order.includes(id));
+    throw new Error(`Suite "${suite.id}" has a dependency cycle involving: ${stuck.join(", ")}`);
+  }
+  return order;
+}
+
+// studio/server/routes/suites.ts
+var suitesRouter = Router5();
+async function fileExists2(filePath) {
+  try {
+    await stat2(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function validateAndCheckDag(value) {
+  const suite = validateTestSuite(value);
+  topologicalOrder(suite);
+  return suite;
+}
+suitesRouter.get("/", async (_req, res) => {
+  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 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) {
+      summaries.push({
+        file: slug,
+        id: "",
+        name: file,
+        description: "",
+        entryCount: 0,
+        invalid: true,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  res.json({ suites: summaries });
+});
+suitesRouter.get("/:file", async (req, res) => {
+  const slug = safeFileName(req.params.file);
+  const raw = JSON.parse(await readFile6(path7.join(SUITES_DIR, `${slug}.json`), "utf-8"));
+  res.json(validateTestSuite(raw));
+});
+suitesRouter.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' });
+    return;
+  }
+  const slug = safeFileName(body.file);
+  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 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 = 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 readFile6(filePath, "utf-8")));
+  const body = req.body;
+  const suite = validateAndCheckDag({ ...body, id: existing.id });
+  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 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 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 fail6(field, reason) {
+  throw new Error(`Invalid TestPlan: ${field} ${reason}`);
+}
+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) fail6(`suites[${index}]`, "must be an object");
+  const v = value;
+  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) fail6("plan", "must be an object");
+  const v = value;
+  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,
+    description: v.description,
+    suites: v.suites.map(validateTestPlanEntry)
+  };
+}
+
+// src/plan-runner.ts
+function summarizeSuiteRun(suiteId, suiteName, testRun) {
+  if (!testRun) return { suiteId, suiteName, status: "missing", testRun: null };
+  const statuses = Object.values(testRun.results).map((r) => r.status);
+  const allTerminal = statuses.every((s) => TERMINAL_STATUSES.has(s));
+  if (!allTerminal) return { suiteId, suiteName, status: "incomplete", testRun };
+  const hasFailure = statuses.some((s) => s === "failed" || s === "blocked");
+  return { suiteId, suiteName, status: hasFailure ? "failed" : "passed", testRun };
+}
+function aggregatePlanStatus(run, testRuns) {
+  const suites = run.suiteIds.map(
+    (suiteId) => summarizeSuiteRun(suiteId, run.suiteNames[suiteId] ?? suiteId, testRuns.get(suiteId) ?? null)
+  );
+  let overall;
+  if (suites.some((s) => s.status === "failed")) {
+    overall = "has-failures";
+  } else if (suites.some((s) => s.status === "incomplete")) {
+    overall = "incomplete";
+  } else if (suites.some((s) => s.status === "missing")) {
+    overall = "missing-runs";
+  } else {
+    overall = "all-passed";
+  }
+  return { planId: run.planId, runId: run.id, suites, overall };
+}
+
+// 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 readFile7(filePath, "utf-8");
+  return validatePlanRun(JSON.parse(raw));
+}
+async function listPlanRuns(dir, planId) {
+  let files;
+  try {
+    files = (await readdir7(dir)).filter((f) => f.endsWith(".json"));
+  } catch {
+    return [];
+  }
+  const runs = [];
+  for (const file of files) {
+    try {
+      const run = await readPlanRun(path8.join(dir, file));
+      if (!planId || run.planId === planId) runs.push(run);
+    } catch {
+    }
+  }
+  runs.sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+  return runs;
+}
+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 writeFile5(filePath, JSON.stringify(planRun, null, 2), "utf-8");
+  return { planRun, filePath };
+}
+
+// studio/server/routes/plans.ts
+var plansRouter = Router6();
+async function fileExists3(filePath) {
+  try {
+    await stat3(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function entryFromSuiteFile(suiteFile) {
+  const slug = safeFileName(suiteFile);
+  const suitePath = path9.join(SUITES_DIR, `${slug}.json`);
+  const raw = JSON.parse(await readFile8(suitePath, "utf-8"));
+  const suite = validateTestSuite(raw);
+  const relative = path9.relative(PLANS_DIR, suitePath).replace(/\\/g, "/");
+  return { suiteId: suite.id, suitePath: relative };
+}
+plansRouter.get("/", async (_req, res) => {
+  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 readFile8(path9.join(PLANS_DIR, file), "utf-8"));
+      const plan = validateTestPlan(raw);
+      summaries.push({
+        file: slug,
+        id: plan.id,
+        name: plan.name,
+        description: plan.description,
+        suiteCount: plan.suites.length
+      });
+    } catch (err) {
+      summaries.push({
+        file: slug,
+        id: "",
+        name: file,
+        description: "",
+        suiteCount: 0,
+        invalid: true,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  res.json({ plans: summaries });
+});
+plansRouter.get("/:file", async (req, res) => {
+  const slug = safeFileName(req.params.file);
+  const raw = JSON.parse(await readFile8(path9.join(PLANS_DIR, `${slug}.json`), "utf-8"));
+  res.json(validateTestPlan(raw));
+});
+plansRouter.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' });
+    return;
+  }
+  if (!Array.isArray(body.suiteFiles)) {
+    res.status(400).json({ error: '"suiteFiles" must be an array of suite file slugs' });
+    return;
+  }
+  const slug = safeFileName(body.file);
+  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 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 = 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 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' });
+    return;
+  }
+  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 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 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 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 readFile8(path9.join(PLANS_DIR, `${slug}.json`), "utf-8")));
+  const suites = await Promise.all(
+    plan.suites.map(async (entry) => {
+      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, req.body?.name);
+  res.status(201).json(planRun);
+});
+plansRouter.delete("/:file/runs/:runId", async (req, res) => {
+  const runId = safeFileName(req.params.runId);
+  await unlink6(path9.join(RUNS_DIR, `${runId}.json`));
+  res.status(204).end();
+});
+plansRouter.get("/:file/status", async (req, res) => {
+  const slug = safeFileName(req.params.file);
+  const runId = req.query.runId;
+  if (typeof runId !== "string" || runId.length === 0) {
+    res.status(400).json({ error: '"runId" query parameter is required' });
+    return;
+  }
+  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 = path9.join(TESTRUNS_DIR, `${suiteId}-${run.id}.json`);
+    try {
+      testRuns.set(suiteId, validateTestRun(JSON.parse(await readFile8(testRunPath, "utf-8"))));
+    } catch {
+      testRuns.set(suiteId, null);
+    }
+  }
+  res.json({ ...aggregatePlanStatus(run, testRuns), startedAt: run.startedAt });
+});
+
+// studio/server/routes/library.ts
+import { Router as Router7 } from "express";
+import express from "express";
+
+// src/library-archive.ts
+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 fileExists4(p) {
+  try {
+    await stat4(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function addDirToZip(zip, dirAbsPath, zipPrefix) {
+  let entries;
+  try {
+    entries = await readdir9(dirAbsPath, { withFileTypes: true });
+  } catch {
+    return 0;
+  }
+  let count = 0;
+  for (const entry of entries) {
+    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 readFile9(abs));
+      count++;
+    }
+  }
+  return count;
+}
+async function buildLibraryZip(baseDir) {
+  const zip = new JSZip3();
+  let fileCount = 0;
+  for (const dir of LIBRARY_DIRS) {
+    fileCount += await addDirToZip(zip, path10.join(baseDir, dir), dir);
+  }
+  const buffer = await zip.generateAsync({ type: "nodebuffer", compression: "DEFLATE" });
+  return { buffer, fileCount, dirs: LIBRARY_DIRS };
+}
+async function extractLibraryZip(bytes, baseDir, force) {
+  const zip = await JSZip3.loadAsync(bytes);
+  const entries = Object.values(zip.files).filter((f) => !f.dir);
+  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 = 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 });
+  }
+  if (!force) {
+    const collisions = [];
+    for (const { entry, targetPath } of targets) {
+      if (await fileExists4(targetPath)) collisions.push(entry.name);
+    }
+    if (collisions.length > 0) {
+      return { fileCount: 0, collisions };
+    }
+  }
+  for (const { entry, targetPath } of targets) {
+    await mkdir3(path10.dirname(targetPath), { recursive: true });
+    await writeFile7(targetPath, await entry.async("nodebuffer"));
+  }
+  return { fileCount: targets.length, collisions: [] };
+}
+
+// studio/server/routes/library.ts
+var libraryRouter = Router7();
+libraryRouter.get("/export", async (_req, res) => {
+  const { buffer } = await buildLibraryZip(WORKING_FOLDER);
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace(/[:T]/g, "-");
+  res.setHeader("Content-Type", "application/zip");
+  res.setHeader("Content-Disposition", `attachment; filename="trxa-tool-library-backup-${stamp}.zip"`);
+  res.send(buffer);
+});
+libraryRouter.post("/import", express.raw({ type: "application/zip", limit: "200mb" }), async (req, res) => {
+  const force = req.query.force === "true";
+  const bytes = req.body;
+  if (!Buffer.isBuffer(bytes) || bytes.length === 0) {
+    throw new Error("Request body must be a non-empty .zip file");
+  }
+  const result = await extractLibraryZip(bytes, WORKING_FOLDER, force);
+  if (!force && result.collisions.length > 0) {
+    res.status(409).json(result);
+    return;
+  }
+  res.json(result);
+});
+
+// studio/server/routes/settings.ts
+import { Router as Router8 } from "express";
+import { stat as stat5 } from "node:fs/promises";
+
+// studio/server/settings.ts
+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 = 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 })));
+}
+async function loadSettings() {
+  if (cached) return cached;
+  try {
+    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);
+      await ensureWorkingFolderDirs();
+      return cached;
+    }
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  return saveSettings({ workingFolder: process.env.STUDIO_DEFAULT_WORKING_FOLDER || process.cwd() });
+}
+async function saveSettings(next) {
+  await mkdir4(CONFIG_DIR, { recursive: true });
+  await writeFile8(CONFIG_FILE, JSON.stringify(next, null, 2) + "\n", "utf-8");
+  cached = next;
+  setWorkingFolder(next.workingFolder);
+  await ensureWorkingFolderDirs();
+  return cached;
+}
+
+// studio/server/routes/settings.ts
+var settingsRouter = Router8();
+settingsRouter.get("/", async (_req, res, next) => {
+  try {
+    res.json(await loadSettings());
+  } catch (err) {
+    next(err);
+  }
+});
+settingsRouter.put("/", async (req, res, next) => {
+  try {
+    const workingFolder = req.body?.workingFolder;
+    if (typeof workingFolder !== "string" || !workingFolder.trim()) {
+      throw new Error("workingFolder must be a non-empty string");
+    }
+    const info = await stat5(workingFolder).catch(() => null);
+    if (!info || !info.isDirectory()) {
+      throw new Error(`Not a directory: "${workingFolder}"`);
+    }
+    res.json(await saveSettings({ workingFolder }));
+  } catch (err) {
+    next(err);
+  }
+});
+
+// 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();
+app.use(express2.json());
+app.use("/api/recordings", recordingsRouter);
+app.use("/api/testcases", testCasesRouter);
+app.use("/api/fixtures", fixturesRouter);
+app.use("/api/testruns", testRunsRouter);
+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 = [
+  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));
+}
+var errorHandler = (err, _req, res, _next) => {
+  console.error(err);
+  const status = err?.code === "ENOENT" ? 404 : 400;
+  res.status(status).json({ error: err instanceof Error ? err.message : String(err) });
+};
+app.use(errorHandler);
+var settings = await loadSettings();
+app.listen(PORT, "127.0.0.1", () => {
+  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}`);
+});