@foldspace_npm/harness 0.1.26 → 0.1.28

package/recipes/create-a-record/agent/views/fields.ts

@@ -0,0 +1,252 @@
+// Editable fields for an approval card. The input type follows the API, not convenience:
+// free text in the API -> a text box; a limited set (often read from the app) -> a dropdown;
+// a single possible value -> drawn as that value, read-only, and still sent;
+// a choice that decides what comes next -> option cards, each with a caption.
+// Every field starts pre-filled with what the user already said (the action's parameters),
+// or the action's default. textContent / value only - never innerHTML.
+
+import { brand } from "./brand";
+import { rankBy } from "../utils";
+
+export type Option = {
+  value: string;
+  label: string;
+  /** One line under the label, on option cards only: what choosing it means. */
+  caption?: string;
+};
+
+type Base = {
+  key: string;
+  label: string;
+  hint?: string;
+  /** Hidden (and not sent) unless this returns true for the current values. */
+  showWhen?: (values: Values) => boolean;
+};
+
+export type Field =
+  | (Base & {
+      kind: "text";
+      value: string;
+      multiline?: boolean;
+      maxLength?: number;
+      required?: boolean;
+      /** An error to show beside the field, or null when the value is acceptable. */
+      check?: (value: string) => string | null;
+    })
+  | (Base & { kind: "checkbox"; value: boolean })
+  /** A required dropdown with exactly one option is drawn as that value, read-only. */
+  | (Base & { kind: "select"; value: string; options: Option[]; required?: boolean; placeholder?: string })
+  /** Option cards: a short choice where each option needs a caption to be understood. */
+  | (Base & { kind: "choice"; value: string; options: Option[]; required?: boolean });
+
+export type Values = Record<string, string | boolean>;
+
+/**
+ * The option the user's own words point at, so a dropdown opens on what they asked for.
+ * Returns the option's value, or "" when the words match no option or more than one.
+ */
+export function matchOption(wanted: string, options: Option[]): string {
+  const norm = (value: string) => value.toLowerCase().replace(/\s+/g, " ").trim();
+  const target = norm(wanted);
+  if (!target) return "";
+  // Exact first, then "contains" - and only a single hit counts: when unsure, the user picks
+  // from the list rather than approving a guess they may not notice.
+  const exact = options.filter((o) => norm(o.label) === target || norm(o.value) === target);
+  if (exact.length) return exact.length === 1 ? exact[0].value : "";
+  const partial = options.filter((o) => norm(o.label).includes(target));
+  if (partial.length) return partial.length === 1 ? partial[0].value : "";
+  // Nothing contains the words: a typo. rankBy's fuzzy pass (the SDK's searchInList) keeps
+  // only plausible hits; one of them is a pick, several are a choice for the user.
+  const fuzzy = rankBy(options, wanted, { searchKeys: ["label"], idOf: (o) => o.value });
+  return fuzzy.length === 1 ? fuzzy[0].value : "";
+}
+
+const CSS = `
+.fs-form{display:grid;gap:10px;padding:12px 14px;border-bottom:1px solid ${brand.border}}
+.fs-form-row{display:grid;gap:4px}
+.fs-form-label{font-size:12px;color:${brand.muted};font-weight:500}
+.fs-form-input{font-family:${brand.font};font-size:13px;color:${brand.text};background:#FFFFFF;border:1px solid ${brand.border};
+  border-radius:6px;padding:6px 8px;width:100%;box-sizing:border-box}
+.fs-form-input:focus{outline:none;border-color:${brand.accent}}
+textarea.fs-form-input{min-height:64px;resize:vertical}
+.fs-form-check{display:flex;align-items:center;gap:8px;font-size:13px;color:${brand.text}}
+.fs-form-hint{font-size:11px;color:${brand.muted}}
+.fs-form-error{font-size:11px;color:#B91C1C}
+.fs-form-fixed{font-size:13px;color:${brand.text};font-weight:500}
+.fs-form-choices{display:grid;gap:8px}
+.fs-form-choice{display:flex;align-items:flex-start;gap:10px;padding:10px 12px;border:1px solid ${brand.border};border-radius:8px;
+  background:${brand.surface};cursor:pointer}
+.fs-form-choice.active{border-color:${brand.accent};background:${brand.surface2}}
+.fs-form-choice input{margin:2px 0 0;flex:none}
+.fs-form-choice-text{display:grid;gap:2px}
+.fs-form-choice-label{font-size:13px;font-weight:600;color:${brand.text}}
+.fs-form-choice-caption{font-size:12px;color:${brand.muted};line-height:1.4}
+`;
+
+function el(tag: string, className: string, text?: string): HTMLElement {
+  const node = document.createElement(tag);
+  node.className = className;
+  if (text !== undefined) node.textContent = text;
+  return node;
+}
+
+export type Form = {
+  node: HTMLElement;
+  style: HTMLElement;
+  /** Current values of the fields that are shown. */
+  values: () => Values;
+  /** Keys whose value differs from what the field started with. */
+  edited: () => string[];
+  /** True when every shown field passes its check. */
+  valid: () => boolean;
+  onChange: (listener: () => void) => void;
+};
+
+export function buildForm(fields: Field[]): Form {
+  const style = el("style", "");
+  style.textContent = CSS;
+  const node = el("div", "fs-form");
+  const listeners: Array<() => void> = [];
+  const changed = () => listeners.forEach((listener) => listener());
+  const rows = new Map<string, { row: HTMLElement; read: () => string | boolean; error: HTMLElement | null; field: Field }>();
+  /** What each field started with: edited() compares against this. */
+  const initial = new Map<string, string | boolean>();
+
+  for (const field of fields) {
+    const row = el("div", "fs-form-row");
+    let read: () => string | boolean;
+    let error: HTMLElement | null = null;
+    if (field.kind === "checkbox") {
+      const label = el("label", "fs-form-check");
+      const box = document.createElement("input") as HTMLInputElement;
+      box.type = "checkbox";
+      box.checked = field.value;
+      box.addEventListener("change", changed);
+      label.append(box, document.createTextNode(field.label));
+      row.append(label);
+      read = () => box.checked;
+    } else if (field.kind === "select" && field.required && field.options.length === 1) {
+      // Only one possible value: nothing to choose, so it is shown, not asked.
+      const only = field.options[0];
+      row.append(el("label", "fs-form-label", field.label), el("div", "fs-form-fixed", only.label));
+      read = () => only.value;
+    } else if (field.kind === "choice") {
+      if (field.label) row.append(el("label", "fs-form-label", field.label));
+      const group = el("div", "fs-form-choices");
+      // A unique group name: other cards in the same conversation have radios too.
+      const name = `fs-choice-${field.key}-${Math.random().toString(36).slice(2, 8)}`;
+      const cards: Array<{ card: HTMLElement; radio: HTMLInputElement }> = [];
+      const paint = () => cards.forEach(({ card, radio }) => (card.className = radio.checked ? "fs-form-choice active" : "fs-form-choice"));
+      for (const option of field.options) {
+        const card = el("label", "fs-form-choice");
+        const radio = document.createElement("input") as HTMLInputElement;
+        radio.type = "radio";
+        radio.name = name;
+        radio.value = option.value;
+        radio.checked = option.value === field.value;
+        radio.addEventListener("change", () => {
+          paint();
+          changed();
+        });
+        const words = el("span", "fs-form-choice-text");
+        words.append(el("span", "fs-form-choice-label", option.label));
+        if (option.caption) words.append(el("span", "fs-form-choice-caption", option.caption));
+        card.append(radio, words);
+        group.append(card);
+        cards.push({ card, radio });
+      }
+      paint();
+      row.append(group);
+      read = () => cards.find(({ radio }) => radio.checked)?.radio.value ?? "";
+    } else {
+      row.append(el("label", "fs-form-label", field.label));
+      let input: HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement;
+      if (field.kind === "select") {
+        const select = document.createElement("select") as HTMLSelectElement;
+        if (!field.value) {
+          const none = document.createElement("option") as HTMLOptionElement;
+          none.value = "";
+          none.textContent = field.placeholder ?? "Choose one";
+          none.disabled = true;
+          select.append(none);
+        }
+        for (const option of field.options) {
+          const item = document.createElement("option") as HTMLOptionElement;
+          item.value = option.value;
+          item.textContent = option.label;
+          select.append(item);
+        }
+        select.value = field.value;
+        input = select;
+      } else if (field.multiline) {
+        input = document.createElement("textarea") as HTMLTextAreaElement;
+      } else {
+        // Not `instanceof HTMLInputElement`: the card's elements belong to the panel's frame.
+        const text = document.createElement("input") as HTMLInputElement;
+        text.type = "text";
+        input = text;
+      }
+      if (field.kind === "text") {
+        if (field.maxLength) (input as HTMLInputElement).maxLength = field.maxLength;
+        input.value = field.value;
+      }
+      input.className = "fs-form-input";
+      input.addEventListener("input", changed);
+      input.addEventListener("change", changed);
+      row.append(input);
+      read = () => input.value;
+      error = el("div", "fs-form-error");
+      error.style.display = "none";
+      row.append(error);
+    }
+    if (field.hint) row.append(el("div", "fs-form-hint", field.hint));
+    node.append(row);
+    rows.set(field.key, { row, read, error, field });
+    initial.set(field.key, read());
+  }
+
+  const all = (): Values => Object.fromEntries(Array.from(rows, ([key, r]) => [key, r.read()]));
+  const shown = (key: string, values: Values) => rows.get(key)?.field.showWhen?.(values) ?? true;
+
+  function problem(field: Field, value: string | boolean): string | null {
+    if (field.kind === "checkbox") return null;
+    const text = String(value).trim();
+    if (field.kind === "choice") return field.required && !text ? "Choose one." : null;
+    // The dropdown's own placeholder ("Choose an owner"), so the article is never wrong.
+    if (field.required && !text) return field.kind === "select" ? `${field.placeholder ?? "Choose one"}.` : `${field.label} is required.`;
+    if (field.kind === "text" && text && field.check) return field.check(text);
+    return null;
+  }
+
+  function refresh(): void {
+    const values = all();
+    for (const [key, r] of rows) {
+      r.row.style.display = shown(key, values) ? "" : "none";
+      if (r.error) {
+        const message = shown(key, values) ? problem(r.field, values[key]) : null;
+        r.error.textContent = message ?? "";
+        r.error.style.display = message ? "" : "none";
+      }
+    }
+  }
+  listeners.push(refresh);
+  refresh();
+
+  return {
+    node,
+    style,
+    values: () => {
+      const values = all();
+      return Object.fromEntries(Object.entries(values).filter(([key]) => shown(key, values)));
+    },
+    edited: () => {
+      const values = all();
+      return fields.filter((f) => shown(f.key, values) && values[f.key] !== initial.get(f.key)).map((f) => f.key);
+    },
+    valid: () => {
+      const values = all();
+      return fields.every((f) => !shown(f.key, values) || problem(f, values[f.key]) === null);
+    },
+    onChange: (listener) => listeners.push(listener),
+  };
+}

package/recipes/create-a-record/agent/views/project-card.ts

@@ -0,0 +1,253 @@
+// The review card every way of creating a project ends on: the editable fields,
+// then the write on Create project, then the outcome - and callback, exactly once,
+// on every path. Both versions of the action draw it; they differ only in what they
+// ask first.
+// What goes back says what happened, never what to do next.
+
+import { createProject, type ProjectDraft } from "../api/projects";
+import { STATUSES, draftFrom, projectFields, type Proposal } from "../projects";
+import { renderFailure, type ApiFailure, type FailureReason } from "../utils";
+import { mountApproval, mountOutcome } from "./approval";
+import type { Field, Option, Values } from "./fields";
+
+export type Callback = (value: unknown, disableOnSubmit?: boolean) => void;
+
+export type Answer = {
+  success: boolean;
+  message: string;
+  /** The card's own words for a refusal. Never the runtime's sentence ("Your session has expired."): `reason` says why. */
+  error?: string;
+  reason?: FailureReason | "rejected" | "render";
+  data: {
+    /** `unconfirmed`: the app answered without an id, or no answer came back from it (a timeout, a gateway's 504, a call that got no response, or one that threw) - so it is not known whether the project exists. */
+    status: "created" | "not_created" | "unconfirmed" | "cancelled";
+    /** Left out when it is not known (`unconfirmed`). */
+    created?: boolean;
+    /** The new project's id, for a navigation route to its page. */
+    id?: string;
+    /** What was written - the card may have changed what the agent asked for. */
+    name?: string;
+    key?: string;
+    owner?: string;
+    project_status?: string;
+    private?: boolean;
+    kind?: string;
+    client?: string;
+    /** Fields the user changed on the card before approving. */
+    edited?: string[];
+  };
+};
+
+export const KICKER = "New project";
+
+export function footerOf(proposal: Proposal): string {
+  return `Projects · ${proposal.workspace || "Workspace"}`;
+}
+
+function summary(
+  status: "created" | "not_created" | "unconfirmed",
+  draft: ProjectDraft,
+  owners: Option[],
+  edited: string[],
+  id?: string,
+): Answer["data"] {
+  return {
+    status,
+    created: status === "unconfirmed" ? undefined : status === "created",
+    id,
+    name: draft.name,
+    key: draft.key,
+    owner: owners.find((option) => option.value === draft.ownerId)?.label,
+    project_status: STATUSES.find((option) => option.value === draft.status)?.label,
+    private: draft.private,
+    kind: draft.kind,
+    client: draft.clientName ?? undefined,
+    edited: edited.length ? edited : undefined,
+  };
+}
+
+/**
+ * Draws, then answers - in `finally`, so a card that throws while drawing still
+ * answers the agent, which is otherwise left waiting. `fallback` is the plain line
+ * shown instead.
+ */
+function answerAfter(host: HTMLElement, callback: Callback, answer: Answer, fallback: string, draw: () => void): void {
+  try {
+    draw();
+  } catch (error) {
+    console.warn("[create_project] render", error);
+    host.textContent = fallback;
+  } finally {
+    callback(answer, true);
+  }
+}
+
+/** The owners could not be loaded: nothing to propose. */
+export function mountLoadFailure(host: HTMLElement, proposal: Proposal | undefined, callback: Callback): void {
+  const reason = proposal?.reason ?? "server";
+  const error = proposal?.error ?? "The project form could not be loaded.";
+  const answer: Answer = {
+    success: false,
+    message: "The project form could not be loaded.",
+    reason,
+    data: { status: "not_created", created: false },
+  };
+  answerAfter(host, callback, answer, error, () => renderFailure(host, { ok: false, status: 0, error, reason }));
+}
+
+export function mountCancelled(host: HTMLElement, header: HTMLElement, proposal: Proposal, callback: Callback): void {
+  const answer: Answer = {
+    success: true,
+    message: "The user cancelled. Nothing was created.",
+    data: { status: "cancelled", created: false },
+  };
+  answerAfter(host, callback, answer, "Cancelled. Nothing was created.", () =>
+    mountOutcome(host, header, {
+      tone: "danger",
+      status: "Cancelled",
+      kicker: KICKER,
+      headline: proposal.name || "Untitled project",
+      facts: [],
+      note: "Nothing was created.",
+      footer: footerOf(proposal),
+    }),
+  );
+}
+
+/** Drawing failed. Nothing was written, and the agent is still told. */
+export function drawFailed(host: HTMLElement, callback: Callback, error: unknown): void {
+  console.warn("[create_project] render", error);
+  host.textContent = "The project card could not be shown. Nothing was created.";
+  const answer: Answer = {
+    success: false,
+    message: "The project card could not be shown. Nothing was created.",
+    reason: "render",
+    data: { status: "not_created", created: false },
+  };
+  callback(answer, true);
+}
+
+export type CardExtras = {
+  /** "Client project" - what was chosen before this card, if anything. */
+  kicker?: string;
+  /** Fields only this kind of project has, placed after the owner. */
+  fields?: Field[];
+  /** Read-only lines: values with only one possibility, or a choice already made. */
+  facts?: Array<[string, string]>;
+  /** The extra fields' values for the create call. */
+  draft?: (values: Values) => Partial<ProjectDraft>;
+  /** Fields the user already changed before this card (on earlier steps). */
+  edited?: string[];
+};
+
+export function mountProjectCard(
+  host: HTMLElement,
+  header: HTMLElement,
+  proposal: Proposal,
+  callback: Callback,
+  extras: CardExtras = {},
+): void {
+  const owners = proposal.owner_options ?? [];
+  const footer = footerOf(proposal);
+  const kicker = extras.kicker ?? KICKER;
+
+  // One of three: an id came back (created), the app answered with an error or the call
+  // was never made (failure), or neither - then nobody knows whether the project exists,
+  // and `unknown` says why.
+  const finish = (draft: ProjectDraft, edited: string[], result: { id?: string; failure?: ApiFailure; unknown?: string }) => {
+    const { id, failure } = result;
+    // The record may exist now, so whatever happens while drawing, the agent hears it.
+    if (id) {
+      const data = summary("created", draft, owners, edited, id);
+      const answer: Answer = { success: true, message: `Created project ${draft.name}.`, data };
+      answerAfter(host, callback, answer, `Project created: ${draft.name}.`, () =>
+        mountOutcome(host, header, {
+          tone: "success",
+          status: "Project created",
+          kicker,
+          headline: draft.name,
+          facts: [
+            ["Key", draft.key],
+            ["Owner", data.owner ?? ""],
+            ["Client", draft.clientName ?? ""],
+            ["Status", data.project_status ?? ""],
+            ["Visibility", draft.private ? "Private" : "Everyone in the workspace"],
+          ],
+          footer,
+        }),
+      );
+      return;
+    }
+    if (!failure) {
+      const unknown = result.unknown ?? "The app answered without a project id, so it is not known whether the project was created.";
+      // `unknown` says why, for the agent. The card says only what the user needs to know.
+      const note = "It is not known whether the project was created. Check the projects list before you create it again.";
+      const answer: Answer = { success: false, message: unknown, data: summary("unconfirmed", draft, owners, edited) };
+      answerAfter(host, callback, answer, note, () =>
+        mountOutcome(host, header, { tone: "warning", status: "Not confirmed", kicker, headline: draft.name, facts: [], note, footer }),
+      );
+      return;
+    }
+    // 400 and 422 are the app refusing these values. Its own words stay in the console:
+    // `detail` is never drawn and never returned. Any other failure draws the runtime's
+    // sentence on the card and hands the agent only its `reason`.
+    const rejected = failure.status === 400 || failure.status === 422;
+    if (failure.detail) console.warn("[create_project] create", failure.status, failure.detail);
+    const error = rejected ? "The app did not accept these values." : failure.error;
+    const answer: Answer = {
+      success: false,
+      message: "The project was not created.",
+      ...(rejected ? { error } : {}),
+      reason: rejected ? "rejected" : (failure.reason ?? "server"),
+      data: summary("not_created", draft, owners, edited),
+    };
+    answerAfter(host, callback, answer, `Not created. ${error}`, () =>
+      mountOutcome(host, header, { tone: "danger", status: "Not created", kicker, headline: draft.name, facts: [], note: error, footer }),
+    );
+  };
+
+  mountApproval(
+    host,
+    header,
+    {
+      tone: "warning",
+      status: "", // no pill: the buttons are the ask
+      kicker,
+      headline: proposal.name || "Untitled project",
+      // One possible value, so a fact, not a field.
+      facts: [...(extras.facts ?? []), ["Workspace", proposal.workspace || "Workspace"]],
+      footer,
+    },
+    { approve: "Create project", working: "Creating the project..." },
+    projectFields(proposal, extras.fields),
+    {
+      onApprove: (values, changedHere) => {
+        const edited = [...new Set([...(extras.edited ?? []), ...changedHere])];
+        const draft: ProjectDraft = { ...draftFrom(values), ...(extras.draft?.(values) ?? {}) };
+        void createProject(draft).then(
+          (res) => {
+            // A timeout gave up waiting, and a 504 is a gateway giving up. Neither is the app
+            // saying no: the project may exist.
+            if (!res.ok && (res.reason === "timeout" || res.status === 504)) {
+              return finish(draft, edited, { unknown: "The app did not answer in time, so it is not known whether the project was created." });
+            }
+            // `unreachable` is a call that got no answer at all. The connection can fail after
+            // the app received the request, so this is not the app saying no either.
+            if (!res.ok && res.reason === "unreachable") {
+              return finish(draft, edited, { unknown: "No answer came back from the app, so it is not known whether the project was created." });
+            }
+            if (!res.ok) return finish(draft, edited, { failure: res });
+            finish(draft, edited, { id: res.data?.id ? String(res.data.id) : undefined });
+          },
+          (error) => {
+            // The call threw: it may or may not have reached the app.
+            console.warn("[create_project] create", error);
+            finish(draft, edited, { unknown: "No answer came back from the app, so it is not known whether the project was created." });
+          },
+        );
+      },
+      onCancel: () => mountCancelled(host, header, proposal, callback),
+    },
+    "name",
+  );
+}

package/recipes/create-a-record/agent/views/steps.ts

@@ -0,0 +1,92 @@
+// One question per card. Each field gets its own step, pre-filled with what the user
+// already said, so they confirm or change one thing at a time. A step is skipped only
+// when there is nothing to ask: a field with one possible value (kept, and shown on the
+// review), or one that does not apply to the answers so far (its showWhen). Every step
+// has Cancel. Nothing is written here - the caller ends on a review card. A step that
+// throws while it is drawn after Continue goes to onFailed; a throw on the first step
+// reaches the caller's own catch. Either way the caller can still answer the agent.
+
+import { mountApproval } from "./approval";
+import type { Field, Values } from "./fields";
+
+export type Step = {
+  /** The question, as the card's headline: "Who owns it?" */
+  question: string;
+  field: Field;
+};
+
+/** A required dropdown with one option: nothing to choose, so no step. */
+function onlyValue(field: Field): string | null {
+  return field.kind === "select" && field.required && field.options.length === 1 ? field.options[0].value : null;
+}
+
+/** The field as one step shows it: the latest value, and always shown. */
+function asStep(field: Field, value: string | boolean | undefined): Field {
+  if (field.kind === "checkbox") return { ...field, showWhen: undefined, value: value === undefined ? field.value : value === true };
+  return { ...field, showWhen: undefined, value: value === undefined ? field.value : String(value) };
+}
+
+export function runSteps(
+  host: HTMLElement,
+  header: HTMLElement,
+  options: {
+    /** "Client project" - the step number is added to it. */
+    kicker: string;
+    footer: string;
+    /** The number the first step shows, when earlier steps came before these. */
+    firstNumber?: number;
+    steps: Step[];
+    /** The last step's button. "Review" by default, for the review card that follows. */
+    lastLabel?: string;
+    /** Every field's value once the last step is answered, and the keys the user changed. */
+    onDone: (values: Values, edited: string[]) => void;
+    onCancel: () => void;
+    /** A step threw while it was drawn after Continue. Draw the failed state and answer the agent. */
+    onFailed: (error: unknown) => void;
+  },
+): void {
+  const values: Values = {};
+  const edited = new Set<string>();
+  let number = options.firstNumber ?? 1;
+
+  const asked = (step: Step) => onlyValue(step.field) === null && (step.field.showWhen?.(values) ?? true);
+
+  const show = (index: number): void => {
+    let at = index;
+    // Nothing to ask: keep the one possible value, or leave out a field that does not apply.
+    while (at < options.steps.length && !asked(options.steps[at])) {
+      const { field } = options.steps[at];
+      const only = onlyValue(field);
+      if (only !== null) values[field.key] = only;
+      at++;
+    }
+    if (at >= options.steps.length) return options.onDone({ ...values }, [...edited]);
+
+    const { question, field } = options.steps[at];
+    // A later step that depends on this answer may still come, so it counts until it is skipped.
+    const last = !options.steps.slice(at + 1).some((step) => onlyValue(step.field) === null && (asked(step) || Boolean(step.field.showWhen)));
+    mountApproval(
+      host,
+      header,
+      { tone: "warning", status: "", kicker: `${options.kicker} · Step ${number}`, headline: question, facts: [], footer: options.footer },
+      { approve: last ? (options.lastLabel ?? "Review") : "Continue", working: "" },
+      [asStep(field, values[field.key])],
+      {
+        onApprove: (answer, changed) => {
+          Object.assign(values, answer);
+          changed.forEach((key) => edited.add(key));
+          number++;
+          // Inside a click handler, a throw would reach nobody, and the agent would wait until the user presses stop.
+          try {
+            show(at + 1);
+          } catch (error) {
+            options.onFailed(error);
+          }
+        },
+        onCancel: options.onCancel,
+      },
+    );
+  };
+
+  show(0);
+}

package/recipes/create-a-record/fixtures/owners.ok.json

@@ -0,0 +1,9 @@
+{
+  "workspace": { "id": "ws_1", "name": "Northwind" },
+  "items": [
+    { "id": "u_1", "name": "Dana Reyes", "email": "dana@example.com" },
+    { "id": "u_2", "name": "Sam Lee", "email": "sam@example.com" },
+    { "id": "u_3", "name": "Sam Lee", "email": "sam.lee@example.com" },
+    { "id": "u_4", "name": "Pat Kim", "email": "pat@example.com" }
+  ]
+}

package/recipes/create-a-record/fixtures/project.created.json

@@ -0,0 +1 @@
+{ "id": "prj_481", "name": "Website relaunch", "key": "WEB" }

package/recipes/create-a-record/fixtures/project.rejected.json

@@ -0,0 +1 @@
+{ "message": "Key WEB is already used by project 77 in tenant 44" }

package/recipes/create-a-record/recipe.json

@@ -0,0 +1,13 @@
+{
+  "title": "Create a record",
+  "level": "L4",
+  "family": "write",
+  "kind": "action",
+  "action": "create_project",
+  "entry": "agent/actions/create_project.ts",
+  "variants": [
+    "variants/actions/create_project.steps.ts"
+  ],
+  "outcome": "An editable card pre-filled from what the user said; the record is created only after they approve",
+  "provenBy": 2
+}