@flowriki/agent 0.1.0-beta.42 → 0.1.0-beta.44

package/dist/{chunk-FKD5OAUV.js → chunk-E24RRF2Q.js}

@@ -6,7 +6,7 @@ import os from "os";
 import path from "path";
 import { createRequire } from "module";
 import { spawnSync } from "child_process";
-var AGENT_VERSION = "0.1.0-beta.42";
+var AGENT_VERSION = "0.1.0-beta.44";
 async function prepareBrowsers() {
   if (browsersReady()) {
     return { ok: true, already: true, message: "chromium is already installed" };
@@ -1008,6 +1008,8 @@ import { z as z42 } from "zod";
 import { z as z5 } from "zod";
 import { z as z6 } from "zod";
 import { z as z7 } from "zod";
+import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 var EngineSchema = z4.enum(["chromium", "firefox", "webkit"]);
 var CapabilitySchema = z4.object({
   id: z4.string(),
@@ -1036,18 +1038,44 @@ var ExecutionConfigSchema = z4.object({
     })
   ).default({})
 });
-var FlowOccurrenceSchema = z22.object({
+var BUSINESS_KEYWORDS = ["Given", "When", "Then", "And", "But"];
+var BusinessStepSchema = z22.object({
+  keyword: z22.enum(BUSINESS_KEYWORDS),
+  text: z22.string().min(1).max(2e3)
+}).strict();
+var TestCaseOriginSchema = z22.object({
+  kind: z22.enum(["import", "assistant"]),
+  at: z22.string(),
+  by: z22.string().default(""),
+  /** The file it was imported from, and its row or id there. */
+  file: z22.string().max(300).optional(),
+  row: z22.string().max(200).optional()
+}).strict();
+var KEYWORD = /^\s*(given|when|then|and|but)\b[\s:]*(.*)$/i;
+var keywordOf = (word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+function parseGherkin(text) {
+  const lines = text.split(/\r?\n/).map((l) => l.trim()).filter(Boolean).filter((l) => !/^(scenario|scenario outline|feature|background|examples)\s*:/i.test(l) && !l.startsWith("|"));
+  if (!lines.length) return null;
+  const steps = [];
+  for (const line of lines) {
+    const m = KEYWORD.exec(line);
+    if (!m || !m[2].trim()) return null;
+    steps.push({ keyword: keywordOf(m[1]), text: m[2].trim() });
+  }
+  return steps;
+}
+var FlowOccurrenceSchema = z32.object({
   /** This copy's own identity. Not the source flow's — a flow added twice is
    *  two occurrences, and editing, breakpoints, results and deletion must be
    *  able to tell them apart. */
-  occurrenceId: z22.string().min(1),
-  actorId: z22.string().optional(),
+  occurrenceId: z32.string().min(1),
+  actorId: z32.string().optional(),
   /** Editable, and initially the source flow's name. */
-  name: z22.string().min(1),
+  name: z32.string().min(1),
   /** Where this copy starts, when it is told to navigate before running.
    *  Absent means continue from wherever the previous row left the browser. */
-  startPath: z22.string().optional(),
-  baseUrl: z22.string().url().optional(),
+  startPath: z32.string().optional(),
+  baseUrl: z32.string().url().optional(),
   /** GO SOMEWHERE FIRST, or carry on where the last row ended.
    *
    * SUPERSEDED BY `start`, and still read so that every case written before
@@ -1057,7 +1085,7 @@ var FlowOccurrenceSchema = z22.object({
    * Off by default, because a case is a sequence in one browser: re-entering
    * each flow's original starting URL would sign the tester out between rows
    * and is exactly the behaviour composing flows is meant to avoid. */
-  navigateFirst: z22.boolean().default(false),
+  navigateFirst: z32.boolean().default(false),
   /** WHICH BROWSER THIS ROW RUNS IN.
    *
    * Two answers, because there are two: carry on in the browser this
@@ -1080,7 +1108,7 @@ var FlowOccurrenceSchema = z22.object({
    * A participant's FIRST row is always fresh in effect: there is nothing to
    * continue from. That is not stored, because it is a fact about the order
    * rather than about the row — moving the row changes the answer. */
-  start: z22.enum(["continue", "navigate", "fresh"]).optional(),
+  start: z32.enum(["continue", "navigate", "fresh"]).optional(),
   /** WHETHER THIS COPY DOES ITS OWN SIGNING IN.
    *
    * A flow recorded with "sign in before recording" keeps that sign-in as its
@@ -1099,28 +1127,28 @@ var FlowOccurrenceSchema = z22.object({
    * the two agree on the account and is refused where they do not — so a case
    * written before this keeps its meaning, and a contradiction stays a
    * contradiction until somebody actually resolves it. */
-  ownSignIn: z22.enum(["skip", "run"]).optional(),
-  steps: z22.array(RecordedStepSchema),
+  ownSignIn: z32.enum(["skip", "run"]).optional(),
+  steps: z32.array(RecordedStepSchema),
   environment: ExecutionEnvironmentSchema.optional(),
   /** Where this copy came from, so the editor can say whether the source has
    *  moved on — informational only, never a trigger to rewrite anything. */
-  origin: z22.object({
-    flowId: z22.string(),
+  origin: z32.object({
+    flowId: z32.string(),
     /** The schema the source was written in, which may be older than today's. */
-    schemaVersion: z22.number().int().nonnegative(),
+    schemaVersion: z32.number().int().nonnegative(),
     /** The source's own revision counter at the moment it was copied. */
-    revision: z22.number().int().nonnegative(),
+    revision: z32.number().int().nonnegative(),
     /** The commit the copy was taken from, when one was known. */
-    commit: z22.string().optional(),
-    featureId: z22.string(),
+    commit: z32.string().optional(),
+    featureId: z32.string(),
     /** Names as they were, so an old case still reads correctly after the
      *  source is renamed, moved or deleted. */
-    featureName: z22.string(),
-    flowName: z22.string(),
+    featureName: z32.string(),
+    flowName: z32.string(),
     /** Source step id → the id it was given here. Kept so a later comparison
      *  against the source can line the two up; nothing depends on it to run. */
-    stepIds: z22.record(z22.string(), z22.string()).default({}),
-    copiedAt: z22.string()
+    stepIds: z32.record(z32.string(), z32.string()).default({}),
+    copiedAt: z32.string()
   }),
   /** WHICH OF THIS ROW'S STEPS ARE WHAT RUNS BEFORE ITS FLOW — the flow's
    *  sign-in and the prerequisites copied in with it — so the row can be shown
@@ -1131,24 +1159,24 @@ var FlowOccurrenceSchema = z22.object({
    *  id, so editing or deleting one of them leaves the rest still grouped.
    *  Absent on every row copied before this existed, which simply show flat.
    *  Never sent to a machine — see `withoutFolding`. */
-  before: z22.object({
+  before: z32.object({
     /** The flow's own sign-in, when the copy brought one. */
-    signInStepId: z22.string().optional(),
-    flows: z22.array(z22.object({
-      flowId: z22.string(),
-      name: z22.string(),
-      stepIds: z22.array(z22.string())
+    signInStepId: z32.string().optional(),
+    flows: z32.array(z32.object({
+      flowId: z32.string(),
+      name: z32.string(),
+      stepIds: z32.array(z32.string())
     }).strict()).default([])
   }).strict().optional()
 }).strict();
 var CASE_SCHEMA_VERSION = 1;
-var TestCaseSchema = z22.object({
-  schemaVersion: z22.literal(CASE_SCHEMA_VERSION),
-  id: z22.string().min(1),
-  folderId: z22.string().min(1),
-  slug: z22.string().regex(/^[a-z0-9][a-z0-9-]*$/),
-  name: z22.string().min(1),
-  description: z22.string().default(""),
+var TestCaseSchema = z32.object({
+  schemaVersion: z32.literal(CASE_SCHEMA_VERSION),
+  id: z32.string().min(1),
+  folderId: z32.string().min(1),
+  slug: z32.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+  name: z32.string().min(1),
+  description: z32.string().default(""),
   /** NO LONGER USED, and kept only so that a case written while they were
    *  parses.
    *
@@ -1161,19 +1189,25 @@ var TestCaseSchema = z22.object({
    *
    * Every row now starts where its own flow says, which is the same answer
    * whatever the order. */
-  startPath: z22.string().default("/"),
-  useStartPath: z22.boolean().default(false),
-  baseUrl: z22.string().url().optional(),
+  startPath: z32.string().default("/"),
+  useStartPath: z32.boolean().default(false),
+  baseUrl: z32.string().url().optional(),
   environment: ExecutionEnvironmentSchema.optional(),
-  actors: z22.array(ActorDefinitionSchema).optional(),
-  defaultActorId: z22.string().optional(),
-  occurrences: z22.array(FlowOccurrenceSchema).default([]),
-  createdAt: z22.string(),
-  createdBy: z22.string().default(""),
-  updatedAt: z22.string(),
+  actors: z32.array(ActorDefinitionSchema).optional(),
+  defaultActorId: z32.string().optional(),
+  occurrences: z32.array(FlowOccurrenceSchema).default([]),
+  /** WHAT IT CHECKS, IN WORDS: Given / When / Then. Written for a case that is
+   *  not automated yet — imported, or written by the assistant — and kept when
+   *  it is. Never sent to a machine — see `withoutFolding`. */
+  businessSteps: z32.array(BusinessStepSchema).optional(),
+  /** Where it came from, when not recorded here. */
+  origin: TestCaseOriginSchema.optional(),
+  createdAt: z32.string(),
+  createdBy: z32.string().default(""),
+  updatedAt: z32.string(),
   /** The same optimistic-concurrency counter a flow carries, so an edit made
    *  against a stale copy is refused rather than overwriting. */
-  revision: z22.number().int().nonnegative().default(0)
+  revision: z32.number().int().nonnegative().default(0)
 }).strict().superRefine((testCase, ctx) => {
   const seen = /* @__PURE__ */ new Set();
   testCase.occurrences.forEach((occurrence, i) => {
@@ -1202,47 +1236,47 @@ var TestCaseSchema = z22.object({
   const { defaultActorId: _gone, ...rest } = testCase;
   return rest;
 });
-var CaseFolderSchema = z22.object({
-  schemaVersion: z22.literal(1),
-  id: z22.string().min(1),
-  slug: z22.string().regex(/^[a-z0-9][a-z0-9-]*$/),
-  name: z22.string().min(1),
-  description: z22.string().default(""),
-  order: z22.number().int().default(0),
-  createdAt: z22.string(),
-  createdBy: z22.string().default("")
+var CaseFolderSchema = z32.object({
+  schemaVersion: z32.literal(1),
+  id: z32.string().min(1),
+  slug: z32.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+  name: z32.string().min(1),
+  description: z32.string().default(""),
+  order: z32.number().int().default(0),
+  createdAt: z32.string(),
+  createdBy: z32.string().default("")
 }).strict();
 var SUITE_SCHEMA_VERSION = 1;
-var SuiteEntrySchema = z22.object({
-  entryId: z22.string().min(1),
-  kind: z22.enum(["flow", "testCase"]),
+var SuiteEntrySchema = z32.object({
+  entryId: z32.string().min(1),
+  kind: z32.enum(["flow", "testCase"]),
   /** The document's ID — never its name or path, so renaming or moving what it
    *  points at cannot break the reference. */
-  ref: z22.string().min(1),
-  enabled: z22.boolean().default(true),
-  order: z22.number().int().nonnegative(),
+  ref: z32.string().min(1),
+  enabled: z32.boolean().default(true),
+  order: z32.number().int().nonnegative(),
   /** What it was called when it was added, so a result stays readable after the
    *  source is renamed or deleted. */
-  nameSnapshot: z22.string().default("")
+  nameSnapshot: z32.string().default("")
 }).strict();
-var SuiteSchema = z22.object({
-  schemaVersion: z22.literal(SUITE_SCHEMA_VERSION),
-  id: z22.string().min(1),
-  slug: z22.string().regex(/^[a-z0-9][a-z0-9-]*$/),
-  name: z22.string().min(1),
-  description: z22.string().default(""),
-  entries: z22.array(SuiteEntrySchema).default([]),
-  defaults: z22.object({
-    headless: z22.boolean().optional(),
+var SuiteSchema = z32.object({
+  schemaVersion: z32.literal(SUITE_SCHEMA_VERSION),
+  id: z32.string().min(1),
+  slug: z32.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+  name: z32.string().min(1),
+  description: z32.string().default(""),
+  entries: z32.array(SuiteEntrySchema).default([]),
+  defaults: z32.object({
+    headless: z32.boolean().optional(),
     /** Carry on through the remaining entries, or stop at the first failure.
      *  Continuing is the default: a suite is a list of independent things and
      *  one failure rarely invalidates the rest. */
-    failurePolicy: z22.enum(["continue", "stop"]).default("continue")
+    failurePolicy: z32.enum(["continue", "stop"]).default("continue")
   }).default({ failurePolicy: "continue" }),
-  createdAt: z22.string(),
-  createdBy: z22.string().default(""),
-  updatedAt: z22.string(),
-  revision: z22.number().int().nonnegative().default(0)
+  createdAt: z32.string(),
+  createdBy: z32.string().default(""),
+  updatedAt: z32.string(),
+  revision: z32.number().int().nonnegative().default(0)
 }).strict().superRefine((suite, ctx) => {
   const seen = /* @__PURE__ */ new Set();
   suite.entries.forEach((entry, i) => {
@@ -1433,19 +1467,19 @@ function restoreDebugCase(testCase, owners, steps) {
   }
   return { ...testCase, occurrences };
 }
-var AuthNavigationSchema = z32.discriminatedUnion("kind", [
+var AuthNavigationSchema = z42.discriminatedUnion("kind", [
   /** Act from wherever the browser already is — a "Log in" link in the header.
    *  The only kind that is safe part-way through a journey. */
-  z32.object({ kind: z32.literal("continue") }),
+  z42.object({ kind: z42.literal("continue") }),
   /** Open the procedure's own starting page first. Right when signing in is
    *  the first thing that happens; it abandons a journey in progress. */
-  z32.object({ kind: z32.literal("open"), path: z32.string().min(1) })
+  z42.object({ kind: z42.literal("open"), path: z42.string().min(1) })
 ]);
-var AuthFieldSchema = z32.object({
+var AuthFieldSchema = z42.object({
   /** The step in the recorded procedure this value is typed into. Where a
    *  recording types into the same box more than once, this is the FIRST of
    *  them — the one an account's values are keyed by. */
-  stepId: z32.string().min(1),
+  stepId: z42.string().min(1),
   /** EVERY step that types into this box, when there is more than one.
    *
    * A login typed twice — a first attempt with a typo, a page that re-rendered
@@ -1457,47 +1491,47 @@ var AuthFieldSchema = z32.object({
    *
    * Empty means the one step in `stepId`, so every profile written before this
    * reads correctly without being migrated. */
-  stepIds: z32.array(z32.string().min(1)).default([]),
+  stepIds: z42.array(z42.string().min(1)).default([]),
   /** What it is called where somebody fills it in — the field's own name on
    *  the page, so an account form reads "Username" rather than "st_9f2a". */
-  label: z32.string().min(1),
+  label: z42.string().min(1),
   /** A secret arrives as a reference and is never written into a document. */
-  secret: z32.boolean().default(false),
+  secret: z42.boolean().default(false),
   /** What the recording typed. Empty for a secret, whose value never travels.
    *  Kept so the first account can be made from what was recorded, with
    *  nothing to fill in. */
-  recorded: z32.string().default("")
+  recorded: z42.string().default("")
 }).strict();
 var AUTH_PROFILE_SCHEMA_VERSION = 2;
-var AuthProfileSchema = z32.object({
-  schemaVersion: z32.literal(AUTH_PROFILE_SCHEMA_VERSION),
-  id: z32.string().min(1),
-  slug: z32.string().regex(/^[a-z0-9][a-z0-9-]*$/),
-  name: z32.string().min(1),
-  description: z32.string().default(""),
+var AuthProfileSchema = z42.object({
+  schemaVersion: z42.literal(AUTH_PROFILE_SCHEMA_VERSION),
+  id: z42.string().min(1),
+  slug: z42.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+  name: z42.string().min(1),
+  description: z42.string().default(""),
   /** The recorded sign-in. A flow like any other, so it is edited, debugged
    *  and replayed by everything that already knows how. */
-  flowId: z32.string().min(1),
+  flowId: z42.string().min(1),
   /** Which of the values it types differ per identity. */
-  fields: z32.array(AuthFieldSchema).default([]),
+  fields: z42.array(AuthFieldSchema).default([]),
   /** Optional, and its own procedure with its own proof — most profiles will
    *  not have one at first. The proof is read off that flow, the same way. */
-  signOutFlowId: z32.string().optional(),
+  signOutFlowId: z42.string().optional(),
   /** Descriptive only — "admin", "staff". Never used to decide anything, so
    *  two profiles may share a tag without becoming interchangeable. */
-  tags: z32.array(z32.string()).default([]),
-  createdAt: z32.string(),
-  createdBy: z32.string().default(""),
-  updatedAt: z32.string(),
-  revision: z32.number().int().nonnegative().default(0)
+  tags: z42.array(z42.string()).default([]),
+  createdAt: z42.string(),
+  createdBy: z42.string().default(""),
+  updatedAt: z42.string(),
+  revision: z42.number().int().nonnegative().default(0)
 }).strict();
 var ACCOUNT_BINDING_SCHEMA_VERSION = 3;
-var AccountBindingSchema = z32.object({
-  schemaVersion: z32.literal(ACCOUNT_BINDING_SCHEMA_VERSION),
-  id: z32.string().min(1),
-  slug: z32.string().regex(/^[a-z0-9][a-z0-9-]*$/),
-  name: z32.string().min(1),
-  profileId: z32.string().min(1),
+var AccountBindingSchema = z42.object({
+  schemaVersion: z42.literal(ACCOUNT_BINDING_SCHEMA_VERSION),
+  id: z42.string().min(1),
+  slug: z42.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+  name: z42.string().min(1),
+  profileId: z42.string().min(1),
   /** Which environments of the APPLICATION UNDER TEST these credentials work
    *  in — never Flowriki's own dev or staging.
    *
@@ -1509,47 +1543,47 @@ var AccountBindingSchema = z32.object({
    * duplicate account — same name, same password, same everything — for each
    * deployment the identity existed in, or a blank "works anywhere" that also
    * claimed environments it had never been created in. Neither was true. */
-  environments: z32.array(z32.string().min(1)).default([]),
+  environments: z42.array(z42.string().min(1)).default([]),
   /** Step id → what this identity types there. Ordinary values: a username is
    *  not a credential, and keeping it here is what lets somebody read an
    *  account and know who it is. */
-  values: z32.record(z32.string(), z32.string()).default({}),
+  values: z42.record(z42.string(), z42.string()).default({}),
   /** Step id → secret REFERENCE. The value is sealed in the vault and never
    *  enters the repository, whatever form it was typed into. */
-  secrets: z32.record(z32.string(), z32.string().regex(/^[a-z][a-z0-9_]*$/i)).default({}),
+  secrets: z42.record(z42.string(), z42.string().regex(/^[a-z][a-z0-9_]*$/i)).default({}),
   /** What this identity should look like once signed in — a displayed name, a
    *  tenant. Not secret, and checked so that an already-authenticated browser
    *  holding the WRONG account is reported rather than accepted. */
-  identity: z32.object({
-    label: z32.string().optional(),
-    tenant: z32.string().optional()
+  identity: z42.object({
+    label: z42.string().optional(),
+    tenant: z42.string().optional()
   }).default({}),
-  createdAt: z32.string(),
-  createdBy: z32.string().default(""),
-  updatedAt: z32.string(),
-  revision: z32.number().int().nonnegative().default(0)
+  createdAt: z42.string(),
+  createdBy: z42.string().default(""),
+  updatedAt: z42.string(),
+  revision: z42.number().int().nonnegative().default(0)
 }).strict();
-var AuthReferenceSchema = z32.object({
-  profileId: z32.string().min(1),
+var AuthReferenceSchema = z42.object({
+  profileId: z42.string().min(1),
   /** Where this use of it begins. See the step's own field. */
-  from: z32.enum(["loginPage", "here"]).optional(),
+  from: z42.enum(["loginPage", "here"]).optional(),
   /** Absent means "the only account bound to this profile for the selected
    *  environment", which is resolved before a browser opens and refused when
    *  it is ambiguous — a silent choice between two identities is the failure
    *  this field exists to prevent. */
-  accountId: z32.string().optional()
+  accountId: z42.string().optional()
 }).strict();
 var ActorSchema = ActorDefinitionSchema;
-var DeliveredAuthSchema = z32.object({
-  profileId: z32.string().min(1),
-  accountId: z32.string().min(1),
-  name: z32.string(),
-  accountName: z32.string(),
-  steps: z32.array(RecordedStepSchema),
+var DeliveredAuthSchema = z42.object({
+  profileId: z42.string().min(1),
+  accountId: z42.string().min(1),
+  name: z42.string(),
+  accountName: z42.string(),
+  steps: z42.array(RecordedStepSchema),
   navigation: AuthNavigationSchema,
-  success: z32.array(RecordedAssertionSchema),
-  secretRefs: z32.record(z32.string(), z32.string()),
-  signOut: z32.object({ steps: z32.array(RecordedStepSchema), success: z32.array(RecordedAssertionSchema) }).optional()
+  success: z42.array(RecordedAssertionSchema),
+  secretRefs: z42.record(z42.string(), z42.string()),
+  signOut: z42.object({ steps: z42.array(RecordedStepSchema), success: z42.array(RecordedAssertionSchema) }).optional()
 }).strict();
 function actorPreparations(actors = []) {
   return actors.flatMap((actor) => actor.startSignedIn ? [{
@@ -1666,8 +1700,8 @@ function expandForRun(flow, lookup) {
   return { ...rest, steps: [...signIn ? [signIn] : [], ...steps, ...flow.steps] };
 }
 var HELPER_SCHEMA_VERSION = 1;
-var SecretRef = z42.string().regex(/^[a-z][a-z0-9_]*$/i);
-var PatternSchema = z42.string().max(500).refine((source) => {
+var SecretRef = z5.string().regex(/^[a-z][a-z0-9_]*$/i);
+var PatternSchema = z5.string().max(500).refine((source) => {
   try {
     new RegExp(source);
     return true;
@@ -1675,88 +1709,88 @@ var PatternSchema = z42.string().max(500).refine((source) => {
     return false;
   }
 }, "that is not a valid pattern");
-var MailboxHelperSchema = z42.object({
-  kind: z42.literal("mailbox"),
+var MailboxHelperSchema = z5.object({
+  kind: z5.literal("mailbox"),
   /** IMAP, which every provider offers: Gmail, Outlook, Zoho, Fastmail… */
-  host: z42.string().min(1),
-  port: z42.number().int().positive().default(993),
-  secure: z42.boolean().default(true),
-  username: z42.string().min(1),
+  host: z5.string().min(1),
+  port: z5.number().int().positive().default(993),
+  secure: z5.boolean().default(true),
+  username: z5.string().min(1),
   passwordRef: SecretRef,
-  folder: z42.string().min(1).default("INBOX"),
+  folder: z5.string().min(1).default("INBOX"),
   /** Which email. All optional; the newest that matches every one given. */
-  match: z42.object({
-    to: z42.string().default(""),
-    from: z42.string().default(""),
-    subject: z42.string().default("")
+  match: z5.object({
+    to: z5.string().default(""),
+    from: z5.string().default(""),
+    subject: z5.string().default("")
   }).strict().default({}),
   /** What to take out of it. */
-  extract: z42.object({
-    take: z42.enum(["code", "link", "subject", "body"]).default("code"),
+  extract: z5.object({
+    take: z5.enum(["code", "link", "subject", "body"]).default("code"),
     /** For a code: the pattern, first group if it has one. Default: 4–8 digits.
      *  For a link: only links containing this text. */
-    pattern: z42.string().max(500).default("")
+    pattern: z5.string().max(500).default("")
   }).strict().default({}),
   /** How long to wait for the email to arrive. */
-  waitSeconds: z42.number().int().min(0).max(300).default(60)
+  waitSeconds: z5.number().int().min(0).max(300).default(60)
 }).strict();
-var TotpHelperSchema = z42.object({
-  kind: z42.literal("totp"),
+var TotpHelperSchema = z5.object({
+  kind: z5.literal("totp"),
   /** The authenticator secret (base32, from the QR code's "manual entry"). */
   secretRef: SecretRef,
-  digits: z42.union([z42.literal(6), z42.literal(8)]).default(6),
-  period: z42.number().int().min(10).max(120).default(30),
-  algorithm: z42.enum(["SHA1", "SHA256", "SHA512"]).default("SHA1")
+  digits: z5.union([z5.literal(6), z5.literal(8)]).default(6),
+  period: z5.number().int().min(10).max(120).default(30),
+  algorithm: z5.enum(["SHA1", "SHA256", "SHA512"]).default("SHA1")
 }).strict();
-var SmsHelperSchema = z42.object({
-  kind: z42.literal("sms"),
-  provider: z42.literal("twilio").default("twilio"),
-  accountSid: z42.string().regex(/^AC[0-9a-f]{32}$/i, "a Twilio account SID starts with AC followed by 32 characters"),
+var SmsHelperSchema = z5.object({
+  kind: z5.literal("sms"),
+  provider: z5.literal("twilio").default("twilio"),
+  accountSid: z5.string().regex(/^AC[0-9a-f]{32}$/i, "a Twilio account SID starts with AC followed by 32 characters"),
   authTokenRef: SecretRef,
   /** The Twilio number the application texts. */
-  to: z42.string().min(3),
-  match: z42.object({
-    from: z42.string().default(""),
-    contains: z42.string().default("")
+  to: z5.string().min(3),
+  match: z5.object({
+    from: z5.string().default(""),
+    contains: z5.string().default("")
   }).strict().default({}),
-  extract: z42.object({ pattern: z42.string().max(500).default("") }).strict().default({}),
-  waitSeconds: z42.number().int().min(0).max(300).default(60)
+  extract: z5.object({ pattern: z5.string().max(500).default("") }).strict().default({}),
+  waitSeconds: z5.number().int().min(0).max(300).default(60)
 }).strict();
-var HttpHelperSchema = z42.object({
-  kind: z42.literal("http"),
-  method: z42.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]).default("POST"),
-  url: z42.string().min(1),
+var HttpHelperSchema = z5.object({
+  kind: z5.literal("http"),
+  method: z5.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]).default("POST"),
+  url: z5.string().min(1),
   /** Plain headers, in the repository. */
-  headers: z42.record(z42.string(), z42.string()).default({}),
+  headers: z5.record(z5.string(), z5.string()).default({}),
   /** Header name → vault reference, for tokens and keys. */
-  secretHeaders: z42.record(z42.string(), SecretRef).default({}),
-  body: z42.string().max(2e4).default(""),
+  secretHeaders: z5.record(z5.string(), SecretRef).default({}),
+  body: z5.string().max(2e4).default(""),
   /** Refused unless the response has this status. 0 means any 2xx. */
-  expectStatus: z42.number().int().min(0).max(599).default(0),
-  extract: z42.object({
-    take: z42.enum(["json", "pattern", "status", "nothing"]).default("nothing"),
+  expectStatus: z5.number().int().min(0).max(599).default(0),
+  extract: z5.object({
+    take: z5.enum(["json", "pattern", "status", "nothing"]).default("nothing"),
     /** For json: a dot path — `data.order.id`, `items.0.code`. */
-    path: z42.string().max(300).default(""),
-    pattern: z42.string().max(500).default("")
+    path: z5.string().max(300).default(""),
+    pattern: z5.string().max(500).default("")
   }).strict().default({})
 }).strict();
-var HelperConfigSchema = z42.discriminatedUnion("kind", [
+var HelperConfigSchema = z5.discriminatedUnion("kind", [
   MailboxHelperSchema,
   TotpHelperSchema,
   SmsHelperSchema,
   HttpHelperSchema
 ]);
-var HelperSchema = z42.object({
-  schemaVersion: z42.literal(HELPER_SCHEMA_VERSION),
-  id: z42.string().min(1),
-  slug: z42.string().regex(/^[a-z0-9][a-z0-9-]*$/),
-  name: z42.string().min(1).max(120),
-  description: z42.string().max(1e3).default(""),
+var HelperSchema = z5.object({
+  schemaVersion: z5.literal(HELPER_SCHEMA_VERSION),
+  id: z5.string().min(1),
+  slug: z5.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+  name: z5.string().min(1).max(120),
+  description: z5.string().max(1e3).default(""),
   config: HelperConfigSchema,
-  createdAt: z42.string(),
-  createdBy: z42.string().default(""),
-  updatedAt: z42.string(),
-  revision: z42.number().int().nonnegative().default(0)
+  createdAt: z5.string(),
+  createdBy: z5.string().default(""),
+  updatedAt: z5.string(),
+  revision: z5.number().int().nonnegative().default(0)
 }).strict().superRefine((helper, ctx) => {
   const patterns = [
     helper.config.kind === "mailbox" && helper.config.extract.take === "code" ? helper.config.extract.pattern : "",
@@ -1769,9 +1803,9 @@ var HelperSchema = z42.object({
     }
   }
 });
-var DeliveredHelperSchema = z42.object({
-  id: z42.string().min(1),
-  name: z42.string(),
+var DeliveredHelperSchema = z5.object({
+  id: z5.string().min(1),
+  name: z5.string(),
   config: HelperConfigSchema
 }).strict();
 var LIBRARY_CASE_SCHEMA_VERSION = 1;
@@ -1779,83 +1813,83 @@ var TEST_TYPES = ["functional", "negative", "edge", "regression", "smoke", "acce
 var PRIORITIES = ["P0", "P1", "P2", "P3"];
 var CASE_STATUSES = ["draft", "ready", "deprecated"];
 var AUTOMATION_STATES = ["none", "planned", "automated", "not-automatable"];
-var LibraryStepSchema = z5.object({
-  id: z5.string().min(1),
-  action: z5.string().min(1),
+var LibraryStepSchema = z6.object({
+  id: z6.string().min(1),
+  action: z6.string().min(1),
   /** What to type or choose, when the action needs it. */
-  data: z5.string().optional(),
+  data: z6.string().optional(),
   /** What should happen. Absent for a step that only gets somewhere. */
-  expected: z5.string().optional()
+  expected: z6.string().optional()
 }).strict();
-var AutomationLinkSchema = z5.object({
-  automationId: z5.string().min(1),
-  caseRevision: z5.number().int().nonnegative(),
+var AutomationLinkSchema = z6.object({
+  automationId: z6.string().min(1),
+  caseRevision: z6.number().int().nonnegative(),
   /** The automation's revision when the link was made or last confirmed —
    *  an automation edited since may no longer check what the case says. */
-  automationRevision: z5.number().int().nonnegative().optional(),
-  at: z5.string(),
-  by: z5.string().default("")
+  automationRevision: z6.number().int().nonnegative().optional(),
+  at: z6.string(),
+  by: z6.string().default("")
 }).strict();
-var CaseOriginSchema = z5.discriminatedUnion("kind", [
-  z5.object({ kind: z5.literal("manual") }).strict(),
-  z5.object({
-    kind: z5.literal("import"),
+var CaseOriginSchema = z6.discriminatedUnion("kind", [
+  z6.object({ kind: z6.literal("manual") }).strict(),
+  z6.object({
+    kind: z6.literal("import"),
     /** "csv", "xlsx", "testrail", "zephyr", "xray", "text"… */
-    format: z5.string().min(1),
-    file: z5.string().min(1),
+    format: z6.string().min(1),
+    file: z6.string().min(1),
     /** Row or item in that file, to find it again. */
-    row: z5.string().optional()
+    row: z6.string().optional()
   }).strict(),
-  z5.object({
-    kind: z5.literal("generated"),
-    sourceId: z5.string().min(1),
-    sourceVersion: z5.number().int().positive(),
-    requirementIds: z5.array(z5.string().min(1)).default([])
+  z6.object({
+    kind: z6.literal("generated"),
+    sourceId: z6.string().min(1),
+    sourceVersion: z6.number().int().positive(),
+    requirementIds: z6.array(z6.string().min(1)).default([])
   }).strict()
 ]);
-var TestDataSchema = z5.object({
-  name: z5.string().min(1),
-  value: z5.string().optional(),
-  secretRef: z5.string().regex(/^[a-z][a-z0-9_]*$/i).optional()
+var TestDataSchema = z6.object({
+  name: z6.string().min(1),
+  value: z6.string().optional(),
+  secretRef: z6.string().regex(/^[a-z][a-z0-9_]*$/i).optional()
 }).strict();
-var LibraryCaseSchema = z5.object({
-  schemaVersion: z5.literal(LIBRARY_CASE_SCHEMA_VERSION),
-  id: z5.string().regex(/^tcs_[A-Za-z0-9]+$/),
+var LibraryCaseSchema = z6.object({
+  schemaVersion: z6.literal(LIBRARY_CASE_SCHEMA_VERSION),
+  id: z6.string().regex(/^tcs_[A-Za-z0-9]+$/),
   /** "TC-142": what people say out loud. The id is what links point at. */
-  key: z5.string().regex(/^TC-[1-9][0-9]*$/),
+  key: z6.string().regex(/^TC-[1-9][0-9]*$/),
   /** The same features flows are filed under (`f_<slug>`), so one feature
    *  holds both what to test and what tests it. */
-  featureId: z5.string().min(1),
-  slug: z5.string().regex(/^[a-z0-9][a-z0-9-]*$/),
-  title: z5.string().min(1).max(300),
-  description: z5.string().default(""),
-  type: z5.enum(TEST_TYPES).default("functional"),
-  priority: z5.enum(PRIORITIES).default("P2"),
-  status: z5.enum(CASE_STATUSES).default("draft"),
-  preconditions: z5.array(z5.string().min(1)).default([]),
-  steps: z5.array(LibraryStepSchema).default([]),
-  testData: z5.array(TestDataSchema).default([]),
-  tags: z5.array(z5.string().min(1)).default([]),
+  featureId: z6.string().min(1),
+  slug: z6.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+  title: z6.string().min(1).max(300),
+  description: z6.string().default(""),
+  type: z6.enum(TEST_TYPES).default("functional"),
+  priority: z6.enum(PRIORITIES).default("P2"),
+  status: z6.enum(CASE_STATUSES).default("draft"),
+  preconditions: z6.array(z6.string().min(1)).default([]),
+  steps: z6.array(LibraryStepSchema).default([]),
+  testData: z6.array(TestDataSchema).default([]),
+  tags: z6.array(z6.string().min(1)).default([]),
   /** Requirement ids (Flowriki storage). The text is not copied here. */
-  covers: z5.array(z5.string().min(1)).default([]),
-  automation: z5.object({
-    state: z5.enum(AUTOMATION_STATES).default("none"),
+  covers: z6.array(z6.string().min(1)).default([]),
+  automation: z6.object({
+    state: z6.enum(AUTOMATION_STATES).default("none"),
     /** Why it cannot be automated, when it cannot. */
-    reason: z5.string().optional(),
+    reason: z6.string().optional(),
     /** The plan for automating it: flows to reuse, flows to record, checks to
      *  switch on, accounts and helpers it needs, and what cannot be automated.
      *  Written (usually by the assistant) and approved before anything is
      *  recorded. */
-    plan: z5.string().max(2e4).optional(),
-    planApproved: z5.boolean().optional(),
-    links: z5.array(AutomationLinkSchema).default([])
+    plan: z6.string().max(2e4).optional(),
+    planApproved: z6.boolean().optional(),
+    links: z6.array(AutomationLinkSchema).default([])
   }).strict().default({}),
   origin: CaseOriginSchema.default({ kind: "manual" }),
-  createdAt: z5.string(),
-  createdBy: z5.string().default(""),
-  updatedAt: z5.string(),
-  updatedBy: z5.string().default(""),
-  revision: z5.number().int().nonnegative().default(0)
+  createdAt: z6.string(),
+  createdBy: z6.string().default(""),
+  updatedAt: z6.string(),
+  updatedBy: z6.string().default(""),
+  revision: z6.number().int().nonnegative().default(0)
 }).strict().superRefine((doc, ctx) => {
   const seen = /* @__PURE__ */ new Set();
   doc.steps.forEach((step, i) => {
@@ -1874,144 +1908,167 @@ var LibraryCaseSchema = z5.object({
   }
 });
 var SOURCE_KINDS = ["upload", "jira", "figma", "confluence", "linear", "github-issue", "notion", "url"];
-var SourceVersionSchema = z5.object({
-  v: z5.number().int().positive(),
-  hash: z5.string().min(1),
-  extractedText: z5.string(),
+var SourceVersionSchema = z6.object({
+  v: z6.number().int().positive(),
+  hash: z6.string().min(1),
+  extractedText: z6.string(),
   /** Where an uploaded file WAS kept. Only text is kept since 2026-10-11;
    *  read so older records still parse, and cleared at start-up. */
-  originalKey: z5.string().optional(),
-  mediaType: z5.string().optional(),
-  at: z5.string(),
-  by: z5.string().default("")
+  originalKey: z6.string().optional(),
+  mediaType: z6.string().optional(),
+  at: z6.string(),
+  by: z6.string().default("")
 }).strict();
-var SourceSchema = z5.object({
-  id: z5.string().regex(/^src_[A-Za-z0-9]+$/),
-  projectId: z5.string().min(1),
-  title: z5.string().min(1).max(300),
-  kind: z5.enum(SOURCE_KINDS),
-  versions: z5.array(SourceVersionSchema).min(1),
-  integrationId: z5.string().optional(),
-  externalId: z5.string().optional(),
-  externalUrl: z5.string().url().optional(),
-  createdAt: z5.string(),
-  createdBy: z5.string().default("")
+var SourceSchema = z6.object({
+  id: z6.string().regex(/^src_[A-Za-z0-9]+$/),
+  projectId: z6.string().min(1),
+  title: z6.string().min(1).max(300),
+  kind: z6.enum(SOURCE_KINDS),
+  versions: z6.array(SourceVersionSchema).min(1),
+  integrationId: z6.string().optional(),
+  externalId: z6.string().optional(),
+  externalUrl: z6.string().url().optional(),
+  createdAt: z6.string(),
+  createdBy: z6.string().default("")
 }).strict();
-var RequirementSchema = z5.object({
-  id: z5.string().regex(/^req_[A-Za-z0-9]+$/),
-  projectId: z5.string().min(1),
-  sourceId: z5.string().min(1),
-  sourceVersion: z5.number().int().positive(),
+var RequirementSchema = z6.object({
+  id: z6.string().regex(/^req_[A-Za-z0-9]+$/),
+  projectId: z6.string().min(1),
+  sourceId: z6.string().min(1),
+  sourceVersion: z6.number().int().positive(),
   /** Where in the source: a heading path, a Jira key, a Figma node. */
-  anchor: z5.string().min(1),
-  text: z5.string().min(1),
-  featureId: z5.string().optional(),
+  anchor: z6.string().min(1),
+  text: z6.string().min(1),
+  featureId: z6.string().optional(),
   /** As of the source's latest version: new in it, changed by it, unchanged
    *  ("active"), or gone from it. */
-  state: z5.enum(["new", "active", "changed", "removed"]).default("new"),
-  history: z5.array(z5.object({
-    sourceVersion: z5.number().int().positive(),
-    text: z5.string(),
-    state: z5.enum(["new", "active", "changed", "removed"])
+  state: z6.enum(["new", "active", "changed", "removed"]).default("new"),
+  history: z6.array(z6.object({
+    sourceVersion: z6.number().int().positive(),
+    text: z6.string(),
+    state: z6.enum(["new", "active", "changed", "removed"])
   }).strict()).default([])
 }).strict();
 var MANUAL_OUTCOMES = ["untested", "passed", "failed", "blocked", "skipped"];
-var EvidenceSchema = z6.object({
-  id: z6.string().regex(/^ev_[A-Za-z0-9]+$/),
+var EvidenceSchema = z7.object({
+  id: z7.string().regex(/^ev_[A-Za-z0-9]+$/),
   /** A file kept in Flowriki's evidence storage, or a link to one elsewhere. */
-  kind: z6.enum(["file", "link"]),
-  name: z6.string().min(1).max(200),
-  mediaType: z6.string().optional(),
-  size: z6.number().int().nonnegative().optional(),
-  url: z6.string().url().optional(),
+  kind: z7.enum(["file", "link"]),
+  name: z7.string().min(1).max(200),
+  mediaType: z7.string().optional(),
+  size: z7.number().int().nonnegative().optional(),
+  url: z7.string().url().optional(),
   /** The step it shows, when it belongs to one. */
-  stepId: z6.string().optional(),
-  at: z6.string(),
-  by: z6.string().default("")
+  stepId: z7.string().optional(),
+  at: z7.string(),
+  by: z7.string().default("")
 }).strict();
-var StepOutcomeSchema = z6.object({
-  stepId: z6.string().min(1),
-  outcome: z6.enum(MANUAL_OUTCOMES),
+var StepOutcomeSchema = z7.object({
+  stepId: z7.string().min(1),
+  outcome: z7.enum(MANUAL_OUTCOMES),
   /** What actually happened, when it was not what was expected. */
-  actual: z6.string().max(4e3).optional()
+  actual: z7.string().max(4e3).optional()
 }).strict();
-var ManualResultSchema = z6.object({
-  outcome: z6.enum(MANUAL_OUTCOMES),
-  steps: z6.array(StepOutcomeSchema).default([]),
-  note: z6.string().max(8e3).default(""),
-  evidence: z6.array(EvidenceSchema).default([]),
-  bugIds: z6.array(z6.string().min(1)).default([]),
-  tester: z6.string().default(""),
-  at: z6.string()
+var ManualResultSchema = z7.object({
+  outcome: z7.enum(MANUAL_OUTCOMES),
+  steps: z7.array(StepOutcomeSchema).default([]),
+  note: z7.string().max(8e3).default(""),
+  evidence: z7.array(EvidenceSchema).default([]),
+  bugIds: z7.array(z7.string().min(1)).default([]),
+  tester: z7.string().default(""),
+  at: z7.string()
 }).strict();
-var CycleEntrySchema = z6.object({
-  testCaseId: z6.string().min(1),
-  key: z6.string().min(1),
-  title: z6.string().min(1),
-  featureId: z6.string().min(1),
-  priority: z6.enum(PRIORITIES),
+var CycleEntrySchema = z7.object({
+  testCaseId: z7.string().min(1),
+  key: z7.string().min(1),
+  title: z7.string().min(1),
+  featureId: z7.string().min(1),
+  priority: z7.enum(PRIORITIES),
   /** The case revision snapshot, so "the case changed since" is answerable. */
-  caseRevision: z6.number().int().nonnegative(),
-  preconditions: z6.array(z6.string()).default([]),
-  steps: z6.array(z6.object({ id: z6.string(), action: z6.string(), data: z6.string().optional(), expected: z6.string().optional() }).strict()).default([]),
-  assignee: z6.string().optional(),
+  caseRevision: z7.number().int().nonnegative(),
+  preconditions: z7.array(z7.string()).default([]),
+  steps: z7.array(z7.object({ id: z7.string(), action: z7.string(), data: z7.string().optional(), expected: z7.string().optional() }).strict()).default([]),
+  assignee: z7.string().optional(),
   result: ManualResultSchema.nullable().default(null),
   /** Earlier results for this case in this cycle, newest last — a retest
    *  keeps what the first attempt found. */
-  history: z6.array(ManualResultSchema).default([])
+  history: z7.array(ManualResultSchema).default([])
 }).strict();
-var TestCycleSchema = z6.object({
-  id: z6.string().regex(/^cyc_[A-Za-z0-9]+$/),
-  projectId: z6.string().min(1),
-  name: z6.string().min(1).max(200),
-  description: z6.string().max(4e3).default(""),
-  status: z6.enum(["open", "closed"]).default("open"),
+var TestCycleSchema = z7.object({
+  id: z7.string().regex(/^cyc_[A-Za-z0-9]+$/),
+  projectId: z7.string().min(1),
+  name: z7.string().min(1).max(200),
+  description: z7.string().max(4e3).default(""),
+  status: z7.enum(["open", "closed"]).default("open"),
   /** Which branch the cases were read from; null for the published tests. */
-  changeId: z6.string().nullable().default(null),
-  entries: z6.array(CycleEntrySchema).default([]),
-  createdAt: z6.string(),
-  createdBy: z6.string().default(""),
-  updatedAt: z6.string(),
-  closedAt: z6.string().nullable().default(null)
+  changeId: z7.string().nullable().default(null),
+  entries: z7.array(CycleEntrySchema).default([]),
+  createdAt: z7.string(),
+  createdBy: z7.string().default(""),
+  updatedAt: z7.string(),
+  closedAt: z7.string().nullable().default(null)
 }).strict();
 var BUG_STATUSES = ["open", "in-progress", "fixed", "verified", "closed", "wont-fix"];
 var SEVERITIES = ["critical", "major", "minor", "trivial"];
-var BugSchema = z6.object({
-  id: z6.string().regex(/^bug_[A-Za-z0-9]+$/),
-  key: z6.string().regex(/^BUG-[1-9][0-9]*$/),
-  projectId: z6.string().min(1),
-  title: z6.string().min(1).max(300),
-  description: z6.string().max(2e4).default(""),
-  severity: z6.enum(SEVERITIES).default("major"),
-  status: z6.enum(BUG_STATUSES).default("open"),
-  tracker: z6.enum(["flowriki", "jira", "linear", "github"]).default("flowriki"),
-  externalKey: z6.string().optional(),
-  url: z6.string().url().optional(),
+var BugSchema = z7.object({
+  id: z7.string().regex(/^bug_[A-Za-z0-9]+$/),
+  key: z7.string().regex(/^BUG-[1-9][0-9]*$/),
+  projectId: z7.string().min(1),
+  title: z7.string().min(1).max(300),
+  description: z7.string().max(2e4).default(""),
+  severity: z7.enum(SEVERITIES).default("major"),
+  status: z7.enum(BUG_STATUSES).default("open"),
+  tracker: z7.enum(["flowriki", "jira", "linear", "github"]).default("flowriki"),
+  externalKey: z7.string().optional(),
+  url: z7.string().url().optional(),
   /** Where it was found: a case, the step in it, the cycle that ran it. */
-  testCaseIds: z6.array(z6.string()).default([]),
-  cycleIds: z6.array(z6.string()).default([]),
-  runIds: z6.array(z6.string()).default([]),
-  automationIds: z6.array(z6.string()).default([]),
-  foundAt: z6.object({ cycleId: z6.string(), testCaseId: z6.string(), stepId: z6.string().optional() }).strict().optional(),
-  createdAt: z6.string(),
-  createdBy: z6.string().default(""),
-  updatedAt: z6.string()
+  testCaseIds: z7.array(z7.string()).default([]),
+  cycleIds: z7.array(z7.string()).default([]),
+  runIds: z7.array(z7.string()).default([]),
+  automationIds: z7.array(z7.string()).default([]),
+  foundAt: z7.object({ cycleId: z7.string(), testCaseId: z7.string(), stepId: z7.string().optional() }).strict().optional(),
+  createdAt: z7.string(),
+  createdBy: z7.string().default(""),
+  updatedAt: z7.string()
 }).strict();
 var STOP = new Set("a an the and or of to in on for with by is are be as at it this that from user users can should must shall will when then given".split(" "));
-var ConversationSchema = z7.object({
-  id: z7.string().regex(/^conv_[A-Za-z0-9]+$/),
-  projectId: z7.string().min(1),
+var ConversationSchema = z8.object({
+  id: z8.string().regex(/^conv_[A-Za-z0-9]+$/),
+  projectId: z8.string().min(1),
   /** Whose: conversations are personal. */
-  userId: z7.string().min(1),
-  title: z7.string().min(1).max(200),
-  mode: z7.enum(["ask", "do"]).default("ask"),
+  userId: z8.string().min(1),
+  title: z8.string().min(1).max(200),
+  mode: z8.enum(["ask", "do"]).default("ask"),
   /** The assistant's own session, to continue where it left off. */
-  sessionId: z7.string().optional(),
+  sessionId: z8.string().optional(),
   /** The conversation as the dashboard draws it. Kept as given: the shape
    *  belongs to the screen, and the service only stores and returns it. */
-  lines: z7.array(z7.unknown()).max(2e3).default([]),
-  createdAt: z7.string(),
-  updatedAt: z7.string()
+  lines: z8.array(z8.unknown()).max(2e3).default([]),
+  createdAt: z8.string(),
+  updatedAt: z8.string()
+}).strict();
+var IMPORT_DRAFT_TTL_MS = 24 * 60 * 60 * 1e3;
+var ImportDraftCaseSchema = z9.object({
+  name: z9.string().min(1).max(120),
+  description: z9.string().max(4e3).default(""),
+  businessSteps: z9.array(BusinessStepSchema).max(200),
+  /** Its id or row in the file. */
+  row: z9.string().max(200).default("")
+}).strict();
+var ImportDraftSchema = z9.object({
+  id: z9.string().regex(/^imp_[A-Za-z0-9]+$/),
+  projectId: z9.string().min(1),
+  userId: z9.string().min(1),
+  file: z9.string().max(300),
+  /** Every sheet, every cell as text. */
+  sheets: z9.array(z9.object({ name: z9.string().max(200), rows: z9.array(z9.array(z9.string())) }).strict()).max(200),
+  status: z9.enum(["waiting", "converting", "done", "failed"]).default("waiting"),
+  /** What the assistant made of it: features, each with its cases. */
+  result: z9.array(z9.object({ feature: z9.string().min(1).max(120), cases: z9.array(ImportDraftCaseSchema) }).strict()).default([]),
+  /** The assistant's word on anything it could not convert. */
+  note: z9.string().max(4e3).default(""),
+  createdAt: z9.string(),
+  updatedAt: z9.string()
 }).strict();
 
 // ../engine-playwright/dist/index.js
@@ -6937,8 +6994,8 @@ async function fieldNames(page) {
 }
 
 // ../results/dist/chunk-LYCTVHPR.js
-import { z as z8 } from "zod";
-var RunStatusSchema = z8.enum([
+import { z as z10 } from "zod";
+var RunStatusSchema = z10.enum([
   "queued",
   "running",
   "passed",
@@ -6946,7 +7003,7 @@ var RunStatusSchema = z8.enum([
   "cancelled",
   "errored"
 ]);
-var TaskStatusSchema = z8.enum([
+var TaskStatusSchema = z10.enum([
   "queued",
   "running",
   "passed",
@@ -6955,7 +7012,7 @@ var TaskStatusSchema = z8.enum([
   "cancelled",
   "errored"
 ]);
-var FailureKindSchema = z8.enum([
+var FailureKindSchema = z10.enum([
   "not_found",
   "ambiguous",
   "timeout",
@@ -6964,30 +7021,30 @@ var FailureKindSchema = z8.enum([
   "crash",
   "unknown"
 ]);
-var RunCheckSchema = z8.object({
-  id: z8.string(),
-  assertionId: z8.string().nullable(),
-  kind: z8.string(),
-  expected: z8.string().nullable(),
-  actual: z8.string().nullable(),
-  ok: z8.boolean(),
+var RunCheckSchema = z10.object({
+  id: z10.string(),
+  assertionId: z10.string().nullable(),
+  kind: z10.string(),
+  expected: z10.string().nullable(),
+  actual: z10.string().nullable(),
+  ok: z10.boolean(),
   /** A failed soft check is reported but does not fail its step, so a run can
    *  be green and still carry findings. Stored per check rather than derived,
    *  because the flow it came from can be edited afterwards and history has to
    *  keep saying what actually happened. */
-  soft: z8.boolean().default(false),
-  detail: z8.string().nullable()
+  soft: z10.boolean().default(false),
+  detail: z10.string().nullable()
 });
-var RunStepSchema = z8.object({
-  id: z8.string(),
-  ordinal: z8.number().int().nonnegative(),
+var RunStepSchema = z10.object({
+  id: z10.string(),
+  ordinal: z10.number().int().nonnegative(),
   /** The STABLE document step id — this is what joins runs across time and
    * makes flake-rate a view over existing columns rather than a migration. */
-  stepId: z8.string(),
-  action: z8.string(),
-  targetRole: z8.string().nullable(),
-  targetName: z8.string().nullable(),
-  targetScope: z8.string().nullable(),
+  stepId: z10.string(),
+  action: z10.string(),
+  targetRole: z10.string().nullable(),
+  targetName: z10.string().nullable(),
+  targetScope: z10.string().nullable(),
   /** What the step typed, chose or pressed.
    *
    * A report that says `fill "Password"` and nothing else cannot tell you
@@ -6996,100 +7053,100 @@ var RunStepSchema = z8.object({
    *
    * NEVER set for a secret — see `secret` below. A run report is the thing
    * people paste into a ticket. */
-  value: z8.string().nullable().default(null),
+  value: z10.string().nullable().default(null),
   /** The step typed a secret, so `value` is deliberately absent rather than
    *  merely unknown. Stored, because "no value" and "a value withheld" render
    *  differently and history has to keep saying which it was. */
-  secret: z8.boolean().default(false),
-  status: z8.enum(["passed", "failed", "skipped"]),
+  secret: z10.boolean().default(false),
+  status: z10.enum(["passed", "failed", "skipped"]),
   failureKind: FailureKindSchema.nullable(),
-  detail: z8.string().nullable(),
+  detail: z10.string().nullable(),
   /** WHICH WAY FOUND IT, when the first way did not.
    *
    * A step carries several routes to its element and takes the first that
    * matches. Passing on a later one is not a failure, but it does mean the
    * page has moved under the step — and a suite that repairs itself quietly
    * drifts away from the application it tests. Null is the ordinary case. */
-  foundBy: z8.string().nullable().default(null),
-  durationMs: z8.number().int().nonnegative().nullable(),
+  foundBy: z10.string().nullable().default(null),
+  durationMs: z10.number().int().nonnegative().nullable(),
   /** Where the browser was when this step ran. Recorded on failure, and
    * frequently the whole answer — the element is missing because a step
    * before it navigated somewhere unexpected, not because it was renamed. */
-  pageUrl: z8.string().nullable().default(null),
-  pageTitle: z8.string().nullable().default(null),
-  checks: z8.array(RunCheckSchema).default([])
+  pageUrl: z10.string().nullable().default(null),
+  pageTitle: z10.string().nullable().default(null),
+  checks: z10.array(RunCheckSchema).default([])
 });
-var RunTaskSchema = z8.object({
-  id: z8.string(),
-  ordinal: z8.number().int().nonnegative(),
-  caseName: z8.string(),
-  rowId: z8.string().nullable(),
+var RunTaskSchema = z10.object({
+  id: z10.string(),
+  ordinal: z10.number().int().nonnegative(),
+  caseName: z10.string(),
+  rowId: z10.string().nullable(),
   capability: CapabilitySchema,
-  provider: z8.string(),
-  attempt: z8.number().int().positive().default(1),
-  maxAttempts: z8.number().int().positive().default(1),
+  provider: z10.string(),
+  attempt: z10.number().int().positive().default(1),
+  maxAttempts: z10.number().int().positive().default(1),
   status: TaskStatusSchema,
-  workerId: z8.string().nullable(),
+  workerId: z10.string().nullable(),
   /** Cloud provider's own session, so a failure is one click from their video. */
-  sessionId: z8.string().nullable(),
-  sessionUrl: z8.string().nullable(),
-  detail: z8.string().nullable(),
-  stepsRun: z8.number().int().nonnegative().default(0),
-  stepsTotal: z8.number().int().nonnegative().default(0),
-  durationMs: z8.number().int().nonnegative().nullable(),
-  steps: z8.array(RunStepSchema).default([])
+  sessionId: z10.string().nullable(),
+  sessionUrl: z10.string().nullable(),
+  detail: z10.string().nullable(),
+  stepsRun: z10.number().int().nonnegative().default(0),
+  stepsTotal: z10.number().int().nonnegative().default(0),
+  durationMs: z10.number().int().nonnegative().nullable(),
+  steps: z10.array(RunStepSchema).default([])
 });
-var ArtifactKindSchema = z8.enum(["screenshot", "video", "trace", "console", "har"]);
-var ArtifactSchema = z8.object({
-  id: z8.string(),
-  runId: z8.string(),
-  runStepId: z8.string().nullable(),
+var ArtifactKindSchema = z10.enum(["screenshot", "video", "trace", "console", "har"]);
+var ArtifactSchema = z10.object({
+  id: z10.string(),
+  runId: z10.string(),
+  runStepId: z10.string().nullable(),
   kind: ArtifactKindSchema,
-  relPath: z8.string(),
-  bytes: z8.number().int().nonnegative().nullable(),
-  masked: z8.boolean().default(false),
-  createdAt: z8.string()
+  relPath: z10.string(),
+  bytes: z10.number().int().nonnegative().nullable(),
+  masked: z10.boolean().default(false),
+  createdAt: z10.string()
 });
-var RunSummarySchema = z8.object({
-  id: z8.string(),
-  projectId: z8.string(),
+var RunSummarySchema = z10.object({
+  id: z10.string(),
+  projectId: z10.string(),
   /** What the run was FOR.
    *
    * `flake` is a deliberate repetition of one flow to measure how often it
    * passes. It is kept out of pass-rate statistics: a 98/100 flakiness check is
    * a useful finding, not a failing suite, and counting it as one would make
    * measuring reliability look like losing it. */
-  kind: z8.enum(["smoke", "test", "adhoc", "flake"]),
-  trigger: z8.enum(["ui", "cli", "ci"]),
+  kind: z10.enum(["smoke", "test", "adhoc", "flake"]),
+  trigger: z10.enum(["ui", "cli", "ci"]),
   status: RunStatusSchema,
-  flowId: z8.string().nullable(),
-  flowName: z8.string().nullable(),
-  gitSha: z8.string().nullable(),
-  gitBranch: z8.string().nullable(),
-  gitDirty: z8.boolean().default(false),
-  env: z8.string().nullable(),
-  concurrency: z8.number().int().positive().nullable(),
-  tasksTotal: z8.number().int().nonnegative().default(0),
-  tasksPassed: z8.number().int().nonnegative().default(0),
-  tasksFailed: z8.number().int().nonnegative().default(0),
+  flowId: z10.string().nullable(),
+  flowName: z10.string().nullable(),
+  gitSha: z10.string().nullable(),
+  gitBranch: z10.string().nullable(),
+  gitDirty: z10.boolean().default(false),
+  env: z10.string().nullable(),
+  concurrency: z10.number().int().positive().nullable(),
+  tasksTotal: z10.number().int().nonnegative().default(0),
+  tasksPassed: z10.number().int().nonnegative().default(0),
+  tasksFailed: z10.number().int().nonnegative().default(0),
   /** Rolled up from the run's tasks rather than stored on the run, so they
    * cannot drift from the step rows they describe. "9 of 12" in a list is
    * what tells a reader where a run died; "1 of 1 tasks" tells them nothing
    * until there is more than one browser in play. */
-  stepsRun: z8.number().int().nonnegative().default(0),
-  stepsTotal: z8.number().int().nonnegative().default(0),
-  queuedAt: z8.string(),
-  startedAt: z8.string().nullable(),
-  finishedAt: z8.string().nullable(),
-  durationMs: z8.number().int().nonnegative().nullable()
+  stepsRun: z10.number().int().nonnegative().default(0),
+  stepsTotal: z10.number().int().nonnegative().default(0),
+  queuedAt: z10.string(),
+  startedAt: z10.string().nullable(),
+  finishedAt: z10.string().nullable(),
+  durationMs: z10.number().int().nonnegative().nullable()
 });
 var RunDetailSchema = RunSummarySchema.extend({
-  errorMessage: z8.string().nullable(),
-  artifactsDir: z8.string().nullable(),
-  tasks: z8.array(RunTaskSchema).default([]),
+  errorMessage: z10.string().nullable(),
+  artifactsDir: z10.string().nullable(),
+  tasks: z10.array(RunTaskSchema).default([]),
   /** Screenshots and the like, addressed by `runStepId`. Kept flat rather than
    * nested inside each step: an artifact can belong to the run as a whole. */
-  artifacts: z8.array(ArtifactSchema).default([]),
+  artifacts: z10.array(ArtifactSchema).default([]),
   /** The document as it was executed — a flow, or a test case with the copies
    *  it held that day.
    *
@@ -7098,7 +7155,7 @@ var RunDetailSchema = RunSummarySchema.extend({
    * edited, and without surfacing it the promise was only half kept: the bytes
    * were there and nothing could reach them. Null for runs recorded before a
    * snapshot was taken. */
-  flowSnapshot: z8.unknown().nullable().default(null)
+  flowSnapshot: z10.unknown().nullable().default(null)
 });
 
 // ../results/dist/chunk-IW3PJWP6.js
@@ -11370,6 +11427,7 @@ var ASK_MODE_TOOLS = [
   "project_brief",
   "knowledge_search",
   "knowledge_read",
+  "read_test_cases",
   "list_my_branches"
 ];
 function buildAskArgs(opts) {
@@ -12040,6 +12098,7 @@ export {
   connect,
   RecordedStepSchema,
   mirrorCheckTargets,
+  parseGherkin,
   runtimeValue,
   authenticationResolver,
   checkAssertion,