Prune files not in the deploy set (stale build context)

api/pages_sales.py

@@ -1,276 +0,0 @@
-"""pages_sales.py — the Sales page builder (W2-2). The FIRST Y1 builder, and the template.
-
-It reuses `royalimports_os/modules/sales.py` VERBATIM — the reconciled, validated data layer the
-Streamlit page already reads — so there is exactly one definition of every number and the API is a
-projection, not a second implementation. Nothing here computes revenue.
-
-WHAT A BUILDER IS, in three functions:
-    metrics(team_id, granularity)   the SCOPE-shaped data. Cached by `pages._cached_metrics`.
-                                    ⛔ It cannot see the session, by design — that is what makes
-                                    "nothing user-shaped is cached" a structural property rather
-                                    than a rule somebody has to remember.
-    blocks(metrics, team_id, …)     the ordered Y1 blocks, built with `pages`' constructors.
-    controls(granularity)           the page's own toolbar (the BU picker is added by `pages`).
-
-⛔ THE ONE LEAK THIS FILE HAD TO CLOSE. `sales.headline(team_id=…)` returns a `by_team` map that
-**always covers BOTH business units** — its own docstring says "by_team always shows both" — so a
-Royal-only request's headline carries Fisch revenue. `metrics()` therefore STRIPS `by_team` when a
-BU is pinned, at the source, before it is cached: the other BU's numbers never enter the cache entry
-for a scoped user, so a later edit that emits the block unconditionally renders nothing instead of
-leaking. Fail-closed by construction, not by review. Asserted in `verify_api.py`.
-
-⚠ `by_rep` IS NOT THE STREAMLIT PAGE'S "By agent". `sales.by_rep` groups by Odoo `user_id` (the
-salesperson on the order); the Streamlit page shows `customers.by_dimension('agent')` (the
-CUSTOMER's assigned agent — a different number, see [[invoice-line-agent-commission]]). The split
-doc's brief names `by_rep`, so `by_rep` is what ships; the divergence is flagged in the S1 mailbox
-for the owner rather than resolved in code.
-"""
-import sys as _sys
-import time
-
-import core.odoo as O
-import core.periods as P
-import modules.sales as sales
-
-import pages
-
-MODULE = "sales"                 # the REGISTRY key — what the grant wall gates on
-TITLE = "Sales"
-
-_GRANULARITIES = (("monthly", "Monthly"), ("weekly", "Weekly"))
-
-
-def resolve_granularity(period):
-    """`?period=` → the trend granularity.
-
-    An unrecognised value is COERCED to the default rather than refused, and that asymmetry with
-    `bu` is deliberate: `bu` is a SCOPE question, where a coerced parameter would silently show the
-    wrong book, so it 403s. `period` is a DISPLAY question, and the envelope echoes the resolved
-    value back in `controls[].value`, so a coerced parameter cannot look accepted.
-    """
-    return "weekly" if str(period or "").strip().lower() in ("weekly", "week") else "monthly"
-
-
-def controls(granularity):
-    return [pages.choice_control("period", "Granularity", granularity, _GRANULARITIES)]
-
-
-def subtitle(team_id):
-    return ("Confirmed orders only (Odoo state sale/done), house accounts excluded. Floral "
-            "wholesale is seasonal, so every comparison is against the SAME period last year.")
-
-
-# ── the scope-shaped half ────────────────────────────────────────────────────────────────────────
-def metrics(team_id=None, granularity="monthly"):
-    """Everything the blocks need, for ONE scope. Pure data — no session, no user, no formatting."""
-    # Pin the recognition basis explicitly. It is thread-local and defaults to 'order', but a
-    # worker thread reused from a container that once served 'invoice' would otherwise inherit a
-    # different definition of revenue mid-page, and nothing in the payload would say so.
-    O.set_doc_mode("order")
-    t = P.today()
-
-    head = sales.headline(t=t, team_id=team_id)
-    if team_id is not None:
-        # ⛔ See the module docstring: `by_team` always covers both BUs. Strip it BEFORE caching.
-        head = dict(head, by_team={})
-
-    if granularity == "weekly":
-        trend = sales.weekly_trend(n_weeks=pages.MAX_BUCKETS, t=t, team_id=team_id)
-    else:
-        trend = sales.monthly_trend(n=pages.MAX_BUCKETS, t=t, team_id=team_id)
-
-    return {
-        "pulled_at": time.time(),
-        "today": P._d(t),
-        "scorecard": sales.period_scorecard(t=t, team_id=team_id),
-        "headline": head,
-        "trend": trend,
-        # limit=1e9 so the TOTAL is knowable: the module slices after aggregating, so asking for
-        # everything costs the same read and lets the block report "showing 25 of 812" instead of
-        # capping silently. A bare `[:N]` with no total is the defect [[no-unverifiable-aggregates]]
-        # exists to name.
-        "by_rep": sales.by_rep(t=t, limit=10 ** 9, team_id=team_id),
-        "top_customers": sales.top_customers(t=t, limit=10 ** 9, team_id=team_id),
-        "validation": sales.validate(t=t, team_id=team_id),
-    }
-
-
-# ── the blocks ───────────────────────────────────────────────────────────────────────────────────
-_LIST_LIMIT = 25
-
-
-def _delta_dir(v):
-    if v is None:
-        return None
-    return "up" if v > 0 else "down" if v < 0 else "flat"
-
-
-def _scorecard_kpis(scorecard):
-    """One card per period, every one of them drillable to its exact window."""
-    items = []
-    for r in scorecard:
-        drill = pages.decomp_drill(r, "period", None, f"Sales · {r['label']}")
-        if not r["revenue"]:
-            # No orders yet in this window. Sending a −100% here is the alarming lie
-            # `app.py:2846` guards against; send no number at all.
-            items.append(pages.kpi(r["key"], r["label"], 0.0, "money",
-                                   delta_label="no orders yet", delta_dir="off", drill=drill))
-            continue
-        items.append(pages.kpi(r["key"], r["label"], r["revenue"], "money",
-                               delta=r["yoy_pct"], delta_fmt="pct",
-                               delta_label="vs LY" if r["yoy_pct"] is not None else None,
-                               delta_dir=_delta_dir(r["yoy_pct"]), drill=drill))
-    return pages.kpis("scorecard", items)
-
-
-def _ytd_context_kpis(scorecard, head):
-    """The three YTD numbers the Streamlit page puts in a caption (`app.py:2858`). As KPI cards
-    rather than prose, so each one carries the drill the caption could not."""
-    ytd = next((r for r in scorecard if r["key"] == "ytd"), scorecard[-1] if scorecard else {})
-    drill = pages.decomp_drill(ytd, "period", None, "Sales · Year to date")
-    return pages.kpis("ytd_context", [
-        pages.kpi("ytd_orders", "Orders (YTD)", head.get("ytd_orders") or 0, "int", drill=drill),
-        pages.kpi("ytd_aov", "Average order value", head.get("aov") or 0.0, "money", drill=drill),
-        pages.kpi("ytd_customers", "Active customers (YTD)", head.get("ytd_customers") or 0,
-                  "int", drill=drill),
-    ])
-
-
-def _trend_block(trend, granularity, today):
-    """The YoY trend: ONE x, TWO series, chronology declared by the server.
-
-    See `pages.chart` for why this is `series[]` + `x_order[]` rather than `ChartSpec.splitBy` and
-    a date-typed axis. `spec.y` is set to the FIRST series so a naive single-series
-    `chartData(spec, …)` call still draws the primary bars instead of a "choose a number field"
-    problem card.
-    """
-    label_key = "week" if granularity == "weekly" else "month"
-    rows, x_order = [], []
-    for r in trend:
-        label = str(r.get(label_key) or "")
-        revenue = r.get("revenue") or 0.0
-        revenue_ly = r.get("revenue_ly") or 0.0
-        # The in-progress period compares a PARTIAL window against a full one, so the client
-        # fades it and drops its YoY (`app.py:2867-2875`). One rule for both granularities:
-        # the window that CONTAINS today. ISO strings, so string order is date order.
-        partial = bool(r.get("start") and r.get("end")
-                       and str(r["start"]) <= today <= str(r["end"]))
-        rows.append({
-            "period": label,
-            "revenue": revenue,
-            "revenue_ly": revenue_ly,
-            "partial": partial,
-            # The printed YoY % (the Streamlit chart's on-bar labels, `chart_group_yoy`). None for
-            # the partial period — a partial-vs-full ratio is the number the rule exists to avoid.
-            "yoy_pct": None if partial else P.yoy_pct(revenue, revenue_ly),
-            "_drill": pages.decomp_drill(r, "period", None, f"Sales · {label}"),
-        })
-        x_order.append(label)
-    unit = "Week of" if granularity == "weekly" else "Month"
-    spec = {"id": "sales-trend", "kind": "bar", "x": "period", "y": "revenue", "agg": "sum",
-            "title": "Revenue trend", "palette": "brand",
-            "axis": {"x": {"label": unit}, "y": {"format": "currency"}}}
-    fields = [{"key": "period", "label": unit, "type": "text", "source": "odoo"},
-              {"key": "revenue", "label": "Revenue", "type": "currency", "source": "odoo"},
-              {"key": "revenue_ly", "label": "Revenue LY", "type": "currency", "source": "odoo"}]
-    series = [{"y": "revenue", "label": "This year"},
-              {"y": "revenue_ly", "label": "Last year"}]
-    return pages.chart("trend", spec, series, fields, rows, x_order=x_order,
-                       drill=pages.row_drill(), delta_key="yoy_pct")
-
-
-def _by_bu_block(head, scorecard):
-    """YTD per Business Unit — CONSOLIDATED VIEWS ONLY.
-
-    Omitted entirely when a BU is pinned, matching `app.py:2898`'s `if tid is None`. `metrics()` has
-    already emptied `by_team` in that case, so this cannot accidentally render the other BU even if
-    the guard here were removed — belt and braces on the one number that must never cross.
-    """
-    by_team = head.get("by_team") or {}
-    if not by_team:
-        return None
-    ytd = next((r for r in scorecard if r["key"] == "ytd"), scorecard[-1] if scorecard else {})
-    rows = []
-    for tid in O.TEAM_IDS:
-        name = O.TEAM_NAMES.get(tid)
-        e = by_team.get(name)
-        if not e:
-            continue
-        rows.append({
-            "bu": name, "team_id": tid,
-            "revenue": e.get("ytd") or 0.0, "revenue_ly": e.get("ytd_ly") or 0.0,
-            "yoy_pct": P.yoy_pct(e.get("ytd") or 0.0, e.get("ytd_ly") or 0.0),
-            "_drill": pages.decomp_drill(ytd, "brand", tid, f"Sales · {name} (YTD)"),
-        })
-    return pages.table(
-        "by_bu",
-        [pages.column("bu", "Business Unit"),
-         pages.column("revenue", "YTD $", "money"),
-         pages.column("revenue_ly", "LY $", "money"),
-         pages.column("yoy_pct", "YoY", "pct")],
-        rows, drill=pages.row_drill(), download={"filename": "sales_by_business_unit"},
-        empty="No confirmed orders in either Business Unit this year.")
-
-
-def _by_rep_block(by_rep):
-    rows, total = pages.truncate(by_rep, _LIST_LIMIT)
-    return pages.table(
-        "by_rep",
-        [pages.column("rep", "Salesperson"),
-         pages.column("revenue", "YTD $", "money"),
-         pages.column("orders", "Orders", "int")],
-        rows, total=total, drill=pages.entity_drill("rep", "uid", "rep"),
-        download={"filename": "sales_by_rep"},
-        empty="No confirmed orders are attributed to a salesperson in this scope.")
-
-
-def _top_customers_block(top_customers):
-    rows, total = pages.truncate(top_customers, _LIST_LIMIT)
-    return pages.table(
-        "top_customers",
-        [pages.column("customer", "Customer"),
-         pages.column("revenue", "YTD $", "money"),
-         pages.column("orders", "Orders", "int")],
-        rows, total=total, drill=pages.entity_drill("customer", "pid", "customer"),
-        download={"filename": "top_customers"},
-        empty="No confirmed orders in this scope yet.")
-
-
-def blocks(metrics, team_id=None, granularity="monthly"):
-    """The ORDERED blocks, mirroring `app.py:2833-2961`'s reading order.
-
-    ⚠ The BU table is present only on a consolidated view, so the client must not assume a fixed
-    block count or index — it renders `blocks` in order and skips a type it does not know.
-    """
-    sc = metrics["scorecard"]
-    head = metrics["headline"]
-    out = [
-        _scorecard_kpis(sc),
-        _ytd_context_kpis(sc, head),
-        pages.section("trend_h", "Revenue trend",
-                      "This period versus the same period last year. Click any bar to decompose "
-                      "that period by customer and SKU. The in-progress period is marked partial "
-                      "and carries no YoY."),
-        _trend_block(metrics["trend"], granularity, metrics["today"]),
-    ]
-    bu = _by_bu_block(head, sc)
-    if bu is not None:
-        out.append(pages.section("by_bu_h", "By Business Unit",
-                                 "YTD revenue per Business Unit versus last year."))
-        out.append(bu)
-    out.append(pages.section("by_rep_h", "By salesperson",
-                             "YTD revenue per Odoo salesperson on the order."))
-    out.append(_by_rep_block(metrics["by_rep"]))
-    out.append(pages.section("top_customers_h", "Top customers",
-                             "Largest customers by YTD revenue."))
-    out.append(_top_customers_block(metrics["top_customers"]))
-    out.append(pages.validation(
-        metrics["validation"],
-        "Every headline number reconciles to an independent Odoo aggregate, and every "
-        "decomposition sums back to it."))
-    return out
-
-
-#: Self-registers on import, so adding a page is one file plus one import — `pages.builder_for`
-#: does the import and never needs a per-page branch.
-pages.register("sales", _sys.modules[__name__])

web/src/automation/AutomationEditor.tsx

@@ -1,662 +0,0 @@
-// ---------------------------------------------------------------------------
-// automation/AutomationEditor.tsx — one automation: what it does, when it runs,
-// and what it did last time.
-//
-// THE SHAPE OF THE SCRAPE FLOW IS THE POINT. You cannot map columns you have not
-// seen, so "Read the page" comes BEFORE the field map and the preview is real
-// rows off the real URL — not a schema the user is asked to describe from
-// memory. The server's `/automations/preview` never writes, so the read is free
-// to be taken as many times as it takes to get the mapping right.
-//
-// EVERY COUNT DRILLS TO ROWS. A run that says "412 updated" opens the 412
-// ([[no-unverifiable-aggregates]]) — a number with no way back to its records is
-// exactly what this codebase treats as a defect rather than a summary.
-// ---------------------------------------------------------------------------
-import { useCallback, useEffect, useMemo, useState } from "react";
-
-import type {
-  Automation,
-  AutomationKind,
-  RunEntry,
-  RunRows,
-  SourcePreview,
-  UserTable,
-} from "./automationApi";
-import {
-  AutomationError,
-  COUNT_LABELS,
-  createAutomation,
-  deleteAutomation,
-  fieldKeyFor,
-  listTables,
-  patchAutomation,
-  previewSource,
-  runAutomation,
-  runRows,
-} from "./automationApi";
-
-interface Props {
-  automation: Automation | null;
-  kinds: { key: AutomationKind; label: string }[];
-  cronPresets: { cron: string; label: string }[];
-  onSaved: (id?: string) => void | Promise<void>;
-  onDeleted: () => void | Promise<void>;
-  onCancel: () => void;
-}
-
-interface ColumnPlan {
-  column: string;
-  include: boolean;
-  key: string;
-}
-
-const DEFAULT_CRON = "0 6 * * *";
-
-export default function AutomationEditor({
-  automation,
-  kinds,
-  cronPresets,
-  onSaved,
-  onDeleted,
-  onCancel,
-}: Props) {
-  const isNew = !automation;
-  const cfg = (automation?.config || {}) as Record<string, string | number>;
-
-  const [name, setName] = useState(automation?.name || "");
-  const [kind, setKind] = useState<AutomationKind>(automation?.kind || "scrape_db");
-  const [cron, setCron] = useState(automation?.schedule?.cron || DEFAULT_CRON);
-  const [enabled, setEnabled] = useState(!!automation?.schedule?.enabled);
-  const [message, setMessage] = useState("");
-  const [problem, setProblem] = useState("");
-  const [saving, setSaving] = useState(false);
-
-  // --- scrape_db half
-  const [url, setUrl] = useState(String(cfg.url || ""));
-  const [extract, setExtract] = useState(String(cfg.extract || "table"));
-  const [tableIndex, setTableIndex] = useState(Number(cfg.tableIndex || 0));
-  const [targetLabel, setTargetLabel] = useState(String(cfg.targetLabel || ""));
-  const [preview, setPreview] = useState<SourcePreview | null>(null);
-  const [reading, setReading] = useState(false);
-  const [plan, setPlan] = useState<ColumnPlan[]>(() =>
-    Object.entries((automation?.config as { fieldMap?: Record<string, string> })?.fieldMap || {})
-      .map(([column, key]) => ({ column, include: true, key }))
-  );
-  const [keyField, setKeyField] = useState(String(cfg.keyField || ""));
-
-  // --- field_instagram half
-  const [tables, setTables] = useState<UserTable[]>([]);
-  const [targetTable, setTargetTable] = useState(String(cfg.targetTable || ""));
-  const [fieldKey, setFieldKey] = useState(String(cfg.fieldKey || ""));
-  const [urlField, setUrlField] = useState(String(cfg.urlField || ""));
-  const [maxPosts, setMaxPosts] = useState(Number(cfg.maxPosts || 24));
-
-  // --- run history drill
-  const [drill, setDrill] = useState<RunRows | null>(null);
-  const [drillFor, setDrillFor] = useState("");
-
-  useEffect(() => {
-    const ac = new AbortController();
-    listTables(ac.signal)
-      .then((r) => setTables(r.tables))
-      .catch(() => setTables([]));
-    return () => ac.abort();
-  }, []);
-
-  const table = tables.find((t) => t.key === targetTable) || null;
-
-  const readPage = useCallback(async () => {
-    setReading(true);
-    setProblem("");
-    try {
-      const p = await previewSource(url, extract, tableIndex);
-      setPreview(p);
-      if (!p.ok) {
-        setProblem(p.note || `That page answered ${p.status}.`);
-        return;
-      }
-      // Seed the plan from what the page ACTUALLY offers, keeping any mapping the user
-      // already made for a column that is still there — re-reading a page must not throw
-      // away the work of mapping it.
-      setPlan((prev) => {
-        const had = new Map(prev.map((c) => [c.column, c]));
-        return p.columns.map((column) => {
-          const before = had.get(column);
-          return {
-            column,
-            include: before ? before.include : true,
-            key: before ? before.key : fieldKeyFor(column),
-          };
-        });
-      });
-      setKeyField((k) =>
-        k && p.columns.some((c) => fieldKeyFor(c) === k) ? k : fieldKeyFor(p.columns[0] || "")
-      );
-      if (!targetLabel) setTargetLabel(p.title || "Scraped table");
-      setMessage(
-        `Read ${p.rowCount} rows and ${p.columns.length} columns` +
-          (p.tableCount && p.tableCount > 1 ? ` (of ${p.tableCount} tables on the page)` : "")
-      );
-    } catch (e) {
-      setProblem(
-        e instanceof AutomationError ? e.message : "That page could not be read."
-      );
-    } finally {
-      setReading(false);
-    }
-  }, [url, extract, tableIndex, targetLabel]);
-
-  const buildConfig = (): Record<string, unknown> => {
-    if (kind === "scrape_db") {
-      const fieldMap: Record<string, string> = {};
-      for (const c of plan) if (c.include && c.key) fieldMap[c.column] = c.key;
-      return {
-        url,
-        extract,
-        tableIndex,
-        fieldMap,
-        keyField,
-        targetTable: String(cfg.targetTable || ""),
-        targetLabel,
-      };
-    }
-    return { targetTable, fieldKey, urlField, maxPosts };
-  };
-
-  const save = async () => {
-    setSaving(true);
-    setProblem("");
-    setMessage("");
-    const body = {
-      name,
-      kind,
-      config: buildConfig(),
-      schedule: { cron, enabled },
-    };
-    try {
-      const res = automation
-        ? await patchAutomation(automation.id, body)
-        : await createAutomation(body);
-      setMessage("Saved.");
-      await onSaved(res.automation.id);
-    } catch (e) {
-      setProblem(e instanceof AutomationError ? e.message : "That could not be saved.");
-    } finally {
-      setSaving(false);
-    }
-  };
-
-  const start = async () => {
-    if (!automation) return;
-    setProblem("");
-    try {
-      await runAutomation(automation.id);
-      setMessage("Started. The rail's status dot follows it.");
-      await onSaved(automation.id);
-    } catch (e) {
-      setProblem(e instanceof AutomationError ? e.message : "It did not start.");
-    }
-  };
-
-  const remove = async () => {
-    if (!automation) return;
-    setProblem("");
-    try {
-      await deleteAutomation(automation.id);
-      await onDeleted();
-    } catch (e) {
-      setProblem(e instanceof AutomationError ? e.message : "It was not deleted.");
-    }
-  };
-
-  const openDrill = async (entry: RunEntry) => {
-    if (!automation) return;
-    if (drillFor === entry.ts) {
-      setDrill(null);
-      setDrillFor("");
-      return;
-    }
-    try {
-      const rows = await runRows(automation.id);
-      setDrill(rows);
-      setDrillFor(entry.ts);
-    } catch (e) {
-      setProblem(e instanceof AutomationError ? e.message : "Those rows could not be read.");
-    }
-  };
-
-  const presetMatch = useMemo(
-    () => cronPresets.find((p) => p.cron === cron)?.cron || "",
-    [cronPresets, cron]
-  );
-
-  const canSave =
-    !!name.trim() &&
-    (kind === "scrape_db"
-      ? !!url.trim() && plan.some((c) => c.include && c.key === keyField)
-      : !!targetTable && !!fieldKey);
-
-  return (
-    <div className="auto-editor">
-      <header className="auto-head">
-        <div className="auto-head-title">
-          <input
-            className="auto-name"
-            value={name}
-            placeholder="Name this automation"
-            aria-label="Automation name"
-            onChange={(e) => setName(e.target.value)}
-          />
-          {automation ? (
-            <span className={`auto-chip is-${automation.running ? "running"
-              : automation.status?.state || "idle"}`}>
-              {automation.running ? "Running" : automation.status?.state || "idle"}
-            </span>
-          ) : (
-            <span className="auto-chip is-idle">New</span>
-          )}
-        </div>
-        <div className="auto-head-actions">
-          {automation ? (
-            <button
-              type="button"
-              className="auto-btn"
-              disabled={!!automation.running}
-              onClick={() => void start()}
-            >
-              {automation.running ? "Running…" : "Run now"}
-            </button>
-          ) : null}
-          <button
-            type="button"
-            className="auto-btn is-primary"
-            disabled={!canSave || saving}
-            onClick={() => void save()}
-          >
-            {saving ? "Saving…" : automation ? "Save" : "Create"}
-          </button>
-          {automation ? (
-            <button type="button" className="auto-btn is-danger" onClick={() => void remove()}>
-              Delete
-            </button>
-          ) : (
-            <button type="button" className="auto-btn" onClick={onCancel}>
-              Cancel
-            </button>
-          )}
-        </div>
-      </header>
-
-      {problem ? (
-        <div className="auto-banner is-error" role="alert">
-          {problem}
-        </div>
-      ) : null}
-      {message ? (
-        <div className="auto-banner is-ok" role="status">
-          {message}
-        </div>
-      ) : null}
-
-      <div className="auto-body">
-        <section className="auto-card">
-          <h2>What it does</h2>
-          {isNew ? (
-            <div className="auto-kinds">
-              {kinds.map((k) => (
-                <label key={k.key} className={"auto-kind" + (kind === k.key ? " is-on" : "")}>
-                  <input
-                    type="radio"
-                    name="auto-kind"
-                    checked={kind === k.key}
-                    onChange={() => setKind(k.key)}
-                  />
-                  <span>{k.label}</span>
-                </label>
-              ))}
-            </div>
-          ) : (
-            <p className="auto-note">
-              {kinds.find((k) => k.key === kind)?.label || kind} — the kind is fixed once an
-              automation exists, because its configuration and the database it fills are
-              shaped by it.
-            </p>
-          )}
-
-          {kind === "scrape_db" ? (
-            <>
-              <div className="auto-field">
-                <label htmlFor="auto-url">Page URL</label>
-                <div className="auto-row-inline">
-                  <input
-                    id="auto-url"
-                    className="auto-input"
-                    value={url}
-                    placeholder="https://en.wikipedia.org/wiki/List_of_S%26P_500_companies"
-                    onChange={(e) => setUrl(e.target.value)}
-                  />
-                  <button
-                    type="button"
-                    className="auto-btn"
-                    disabled={!url.trim() || reading}
-                    onClick={() => void readPage()}
-                  >
-                    {reading ? "Reading…" : "Read the page"}
-                  </button>
-                </div>
-                <p className="auto-hint">
-                  Public web pages only. Private, loopback and link-local addresses are
-                  refused — including a public URL that redirects to one.
-                </p>
-              </div>
-
-              <div className="auto-field-row">
-                <div className="auto-field">
-                  <label htmlFor="auto-extract">Read</label>
-                  <select
-                    id="auto-extract"
-                    className="auto-input"
-                    value={extract}
-                    onChange={(e) => setExtract(e.target.value)}
-                  >
-                    <option value="table">An HTML table</option>
-                    <option value="jsonld">Structured data (JSON-LD)</option>
-                  </select>
-                </div>
-                {extract === "table" ? (
-                  <div className="auto-field">
-                    <label htmlFor="auto-tidx">Which table</label>
-                    <input
-                      id="auto-tidx"
-                      className="auto-input"
-                      type="number"
-                      min={0}
-                      value={tableIndex}
-                      onChange={(e) => setTableIndex(Number(e.target.value) || 0)}
-                    />
-                  </div>
-                ) : null}
-                <div className="auto-field">
-                  <label htmlFor="auto-tlabel">Database name</label>
-                  <input
-                    id="auto-tlabel"
-                    className="auto-input"
-                    value={targetLabel}
-                    placeholder="S&P 500 companies"
-                    onChange={(e) => setTargetLabel(e.target.value)}
-                  />
-                </div>
-              </div>
-
-              {plan.length ? (
-                <div className="auto-map">
-                  <h3>Columns</h3>
-                  <p className="auto-hint">
-                    Pick the key — the column that identifies a row. On every re-run, a row
-                    whose key already exists is updated; a new key is inserted; a key that
-                    has stopped appearing is counted and kept.
-                  </p>
-                  <table className="auto-table">
-                    <thead>
-                      <tr>
-                        <th>Use</th>
-                        <th>Source column</th>
-                        <th>Field key</th>
-                        <th>Key</th>
-                        {preview?.sample?.length ? <th>First value</th> : null}
-                      </tr>
-                    </thead>
-                    <tbody>
-                      {plan.map((c, i) => (
-                        <tr key={c.column}>
-                          <td>
-                            <input
-                              type="checkbox"
-                              checked={c.include}
-                              aria-label={`Include ${c.column}`}
-                              onChange={(e) =>
-                                setPlan((p) =>
-                                  p.map((x, j) =>
-                                    j === i ? { ...x, include: e.target.checked } : x
-                                  )
-                                )
-                              }
-                            />
-                          </td>
-                          <td className="auto-cell-name">{c.column}</td>
-                          <td>
-                            <input
-                              className="auto-input is-small"
-                              value={c.key}
-                              aria-label={`Field key for ${c.column}`}
-                              onChange={(e) =>
-                                setPlan((p) =>
-                                  p.map((x, j) =>
-                                    j === i ? { ...x, key: fieldKeyFor(e.target.value) } : x
-                                  )
-                                )
-                              }
-                            />
-                          </td>
-                          <td>
-                            <input
-                              type="radio"
-                              name="auto-keyfield"
-                              checked={keyField === c.key && c.include}
-                              disabled={!c.include}
-                              aria-label={`Use ${c.column} as the key`}
-                              onChange={() => setKeyField(c.key)}
-                            />
-                          </td>
-                          {preview?.sample?.length ? (
-                            <td className="auto-cell-sample">
-                              {String(preview.sample[0]?.[c.column] ?? "")}
-                            </td>
-                          ) : null}
-                        </tr>
-                      ))}
-                    </tbody>
-                  </table>
-                </div>
-              ) : (
-                <p className="auto-note">
-                  Read the page to see what columns it offers.
-                </p>
-              )}
-            </>
-          ) : (
-            <>
-              <div className="auto-field-row">
-                <div className="auto-field">
-                  <label htmlFor="auto-table">Database</label>
-                  <select
-                    id="auto-table"
-                    className="auto-input"
-                    value={targetTable}
-                    onChange={(e) => {
-                      setTargetTable(e.target.value);
-                      setFieldKey("");
-                      setUrlField("");
-                    }}
-                  >
-                    <option value="">Choose a database…</option>
-                    {tables.map((t) => (
-                      <option key={t.key} value={t.key}>
-                        {t.label} ({t.rowCount} {t.rowCount === 1 ? "row" : "rows"})
-                      </option>
-                    ))}
-                  </select>
-                </div>
-                <div className="auto-field">
-                  <label htmlFor="auto-fieldkey">Automation column</label>
-                  <select
-                    id="auto-fieldkey"
-                    className="auto-input"
-                    value={fieldKey}
-                    onChange={(e) => setFieldKey(e.target.value)}
-                  >
-                    <option value="">Choose a column…</option>
-                    {(table?.fields || [])
-                      .filter((f) => f.type === "automation")
-                      .map((f) => (
-                        <option key={f.key} value={f.key}>
-                          {f.label}
-                        </option>
-                      ))}
-                  </select>
-                </div>
-                <div className="auto-field">
-                  <label htmlFor="auto-urlfield">Profile URL column</label>
-                  <select
-                    id="auto-urlfield"
-                    className="auto-input"
-                    value={urlField}
-                    onChange={(e) => setUrlField(e.target.value)}
-                  >
-                    <option value="">The column the field is bound to</option>
-                    {(table?.fields || []).map((f) => (
-                      <option key={f.key} value={f.key}>
-                        {f.label}
-                      </option>
-                    ))}
-                  </select>
-                </div>
-                <div className="auto-field">
-                  <label htmlFor="auto-maxposts">Posts per pull</label>
-                  <input
-                    id="auto-maxposts"
-                    className="auto-input"
-                    type="number"
-                    min={1}
-                    max={200}
-                    value={maxPosts}
-                    onChange={(e) => setMaxPosts(Number(e.target.value) || 24)}
-                  />
-                </div>
-              </div>
-              <p className="auto-hint">
-                Anonymous public endpoints only — no login and no credentials. Instagram
-                blocks datacenter addresses and has closed most of its anonymous surface,
-                so a pull reports what it actually got: <strong>ok</strong> (profile and
-                posts), <strong>partial</strong> (profile only), or <strong>blocked</strong>.
-                It never reports success on nothing.
-              </p>
-              {table && !(table.fields || []).some((f) => f.type === "automation") ? (
-                <p className="auto-note">
-                  That database has no automation column yet. Add one from the grid&rsquo;s
-                  column menu, then choose it here.
-                </p>
-              ) : null}
-            </>
-          )}
-        </section>
-
-        <section className="auto-card">
-          <h2>When it runs</h2>
-          <div className="auto-field-row">
-            <div className="auto-field">
-              <label htmlFor="auto-preset">Schedule</label>
-              <select
-                id="auto-preset"
-                className="auto-input"
-                value={presetMatch}
-                onChange={(e) => e.target.value && setCron(e.target.value)}
-              >
-                <option value="">Custom…</option>
-                {cronPresets.map((p) => (
-                  <option key={p.cron} value={p.cron}>
-                    {p.label}
-                  </option>
-                ))}
-              </select>
-            </div>
-            <div className="auto-field">
-              <label htmlFor="auto-cron">Cron (minute hour day month weekday)</label>
-              <input
-                id="auto-cron"
-                className="auto-input is-mono"
-                value={cron}
-                onChange={(e) => setCron(e.target.value)}
-              />
-            </div>
-            <label className="auto-check">
-              <input
-                type="checkbox"
-                checked={enabled}
-                onChange={(e) => setEnabled(e.target.checked)}
-              />
-              <span>Run on this schedule</span>
-            </label>
-          </div>
-          <p className="auto-hint">
-            {automation?.nextRunAt
-              ? `Next run ${automation.nextRunAt}.`
-              : enabled
-                ? "Saved schedules start from the moment they are enabled — enabling a daily job after today's time does not fire it immediately."
-                : "Disabled. It still runs when you press Run now."}
-          </p>
-        </section>
-
-        <section className="auto-card">
-          <h2>Run history</h2>
-          {!automation?.runs?.length ? (
-            <p className="auto-note">It has not run yet.</p>
-          ) : (
-            <ol className="auto-runs">
-              {automation.runs.map((r) => (
-                <li key={r.ts} className={"auto-run is-" + (r.ok ? "ok" : "error")}>
-                  <button
-                    type="button"
-                    className="auto-run-head"
-                    onClick={() => void openDrill(r)}
-                    aria-expanded={drillFor === r.ts}
-                  >
-                    <span className="auto-run-ts">{r.ts.replace("T", " ")}</span>
-                    <span className="auto-run-summary">{r.summary}</span>
-                  </button>
-                  <div className="auto-counts">
-                    {COUNT_LABELS.filter(([k]) => typeof r.counts?.[k] === "number").map(
-                      ([k, label]) => (
-                        <span key={k} className="auto-count">
-                          <b>{r.counts[k]}</b> {label}
-                        </span>
-                      )
-                    )}
-                  </div>
-                  {drillFor === r.ts && drill ? (
-                    <div className="auto-drill">
-                      <p className="auto-hint">
-                        The rows this run touched in {drill.label}
-                        {drill.truncated ? " (first 200)" : ""}.
-                      </p>
-                      <div className="auto-drill-scroll">
-                        <table className="auto-table">
-                          <thead>
-                            <tr>
-                              {drill.fields.map((f) => (
-                                <th key={f.key}>{f.label}</th>
-                              ))}
-                            </tr>
-                          </thead>
-                          <tbody>
-                            {drill.rows.slice(0, 50).map((row) => (
-                              <tr key={String(row.id)}>
-                                {drill.fields.map((f) => (
-                                  <td key={f.key}>{String(row[f.key] ?? "")}</td>
-                                ))}
-                              </tr>
-                            ))}
-                          </tbody>
-                        </table>
-                      </div>
-                    </div>
-                  ) : null}
-                </li>
-              ))}
-            </ol>
-          )}
-        </section>
-      </div>
-    </div>
-  );
-}

web/src/customer-grid/CohortSidebar.tsx

@@ -1,585 +0,0 @@
-// ---------------------------------------------------------------------------
-// customer-grid / CohortSidebar.tsx
-// The Cohort page's left panel (wave-2 item 2c, 2026-07-27): the COHORT LIST
-// replaces the Views rail. A cohort is a fixed, hand-curated subset — the rail
-// is a switcher over `workspace.lists` (name · member count) plus each row's
-// lifecycle menu: the host page's Manage popover retired with wave 2, so
-// RENAME and DELETE live here (the contract's cohort_rename / cohort_delete
-// events; capability leaves a UI only with a replacement). Creation stays on
-// the Customer page ("Add to cohort"); membership edits happen on the grid
-// itself (the selection bar's "Remove from cohort", the toolbar's "+ Add
-// customers").
-//
-// The member count is the cohort's SERVABLE size — its pids within the
-// caller's pool. When members fall outside the 24-month pool the host says so
-// via `missing`, and the active row DISCLOSES it: a cohort silently smaller
-// than its true membership is a forbidden silent truncation (rule 8b).
-// ---------------------------------------------------------------------------
-
-import { useState } from "react";
-import type { KeyboardEvent as ReactKeyboardEvent } from "react";
-import { AnchoredOverlay } from "./OverlaySurface";
-import { EXPORT_FORMATS, EXPORT_LABELS } from "./export";
-import type { ExportFormat } from "./export";
-import type { GridFolder } from "./types";
-import { groupByFolder } from "./folders";
-
-export interface CohortSidebarProps {
-  lists: { id: string; name: string; pids?: number[]; missing?: number; folderId?: string | null }[];
-  /**
-   * Wave-8 I11c (contract C4) — folders, the cohort rail's half. Same model as the
-   * Views rail (folders.ts is surface-agnostic); all optional, so a caller that
-   * wires none of it renders the pre-wave-8 flat list.
-   *
-   * The bulk "Add to cohort" here is a plain SET UNION of the contained cohorts'
-   * member pids — no engine run, and therefore none of the Views rail's two
-   * refusals: a cohort already IS a fixed pid set, so nothing about it can be
-   * pending or unanswerable.
-   */
-  folders?: GridFolder[];
-  folderIdOf?: (cohortId: string) => string | null;
-  onFolderCreate?: (name: string) => void;
-  onFolderRename?: (folderId: string, name: string) => void;
-  onFolderDelete?: (folderId: string) => void;
-  onFolderDuplicate?: (folderId: string) => void;
-  onItemMove?: (cohortId: string, folderId: string | null) => void;
-  /** Add the UNION of this folder's cohorts to `cohortId` (empty = create `name`). */
-  onFolderAddToList?: (folderId: string, cohortId: string, name: string) => void;
-  /** The tenant's today, seeding a new cohort's name. Never the browser clock. */
-  today?: string;
-  activeCohortId: string | null;
-  onSelect: (id: string) => void;
-  /** Emits `cohort_rename` — the host validates ownership and re-renders with the new name. */
-  onRename: (id: string, name: string) => void;
-  /** Emits `cohort_delete`. Destructive, so the menu arms first (same pattern as field
-   *  delete): first click reads "Delete permanently?", the second fires. */
-  onDelete: (id: string) => void;
-  /** Wave-7 item W2 (contract C2) — export THIS cohort's current matched rows
-   *  (its saved view's filters + sorts over the cohort's fixed membership). */
-  onExport?: (cohortId: string, format: ExportFormat) => void;
-}
-
-export default function CohortSidebar({
-  lists,
-  activeCohortId,
-  onSelect,
-  folders,
-  folderIdOf,
-  onFolderCreate,
-  onFolderRename,
-  onFolderDelete,
-  onFolderDuplicate,
-  onItemMove,
-  onFolderAddToList,
-  today,
-  onRename,
-  onDelete,
-  onExport,
-}: CohortSidebarProps) {
-  const [menu, setMenu] = useState<{
-    cohortId: string;
-    anchor: HTMLButtonElement;
-  } | null>(null);
-  const [renamingId, setRenamingId] = useState<string | null>(null);
-  const [confirmDelete, setConfirmDelete] = useState(false);
-  /** W2 — the Export format pane, anchored where the "…" menu was. */
-  const [exportFor, setExportFor] = useState<{
-    cohortId: string;
-    anchor: HTMLButtonElement;
-  } | null>(null);
-  const exportCohort = exportFor
-    ? lists.find((l) => l.id === exportFor.cohortId)
-    : undefined;
-  const menuCohort = menu ? lists.find((l) => l.id === menu.cohortId) : undefined;
-  // I11c - folder UI state. Collapse is LOCAL (C4), as on the Views rail.
-  const [collapsed, setCollapsed] = useState<Set<string>>(new Set());
-  const [folderMenu, setFolderMenu] = useState<{ id: string; anchor: HTMLElement } | null>(null);
-  const [renamingFolder, setRenamingFolder] = useState<string | null>(null);
-  const [creatingFolder, setCreatingFolder] = useState(false);
-  const [confirmFolderDelete, setConfirmFolderDelete] = useState<string | null>(null);
-  const [addTarget, setAddTarget] = useState<string | null>(null);
-  /** The element the bulk-add pane hangs off. Anchoring to document.body
-   *  put it at the bottom of the DOCUMENT rather than beside the folder —
-   *  painted, and effectively unreachable ([[ui-invisible-to-assertions]]).
-   *  Captured from the folder menu before that menu is dismissed. */
-  const [addAnchor, setAddAnchor] = useState<HTMLElement | null>(null);
-  const [addName, setAddName] = useState("");
-  const [dropTarget, setDropTarget] = useState<string | null>(null);
-  const foldersOn = !!folders && !!folderIdOf && !!onItemMove;
-  const groups = groupByFolder(lists, foldersOn ? (folders as GridFolder[]) : [], (l) =>
-    folderIdOf ? folderIdOf(l.id) : null
-  );
-  const folderMenuF = folderMenu ? folders?.find((f) => f.id === folderMenu.id) : undefined;
-  /** C4 - a cohort folder's union is a plain SET UNION of member pids. No engine
-   *  run, so none of the Views rail's two refusals apply: a cohort already IS a
-   *  fixed pid set, so nothing about it can be pending or unanswerable. */
-  const folderUnion = (folderId: string): number[] => {
-    const pids = new Set<number>();
-    for (const l of lists) {
-      if (!folderIdOf || folderIdOf(l.id) !== folderId) continue;
-      for (const pid of l.pids ?? []) pids.add(pid);
-    }
-    return [...pids];
-  };
-  const addUnion = addTarget ? folderUnion(addTarget) : [];
-  const addCount = addTarget
-    ? lists.filter((l) => folderIdOf && folderIdOf(l.id) === addTarget).length
-    : 0;
-  const dropHandlers = (folderId: string | null) =>
-    foldersOn
-      ? {
-          onDragOver: (e: React.DragEvent) => {
-            e.preventDefault();
-            setDropTarget(folderId ?? "__root__");
-          },
-          onDragLeave: () => setDropTarget(null),
-          onDrop: (e: React.DragEvent) => {
-            e.preventDefault();
-            setDropTarget(null);
-            const id = e.dataTransfer.getData("text/plain");
-            if (id) onItemMove?.(id, folderId);
-          },
-        }
-      : {};
-
-  const closeMenu = () => {
-    setMenu(null);
-    setConfirmDelete(false);
-  };
-
-  const onMenuKeyDown = (event: ReactKeyboardEvent<HTMLElement>) => {
-    if (!["ArrowDown", "ArrowUp", "Home", "End"].includes(event.key)) return;
-    const items = [
-      ...event.currentTarget.querySelectorAll<HTMLButtonElement>('[role="menuitem"]'),
-    ];
-    if (!items.length) return;
-    event.preventDefault();
-    const current = items.indexOf(document.activeElement as HTMLButtonElement);
-    const next =
-      event.key === "Home"
-        ? 0
-        : event.key === "End"
-          ? items.length - 1
-          : event.key === "ArrowDown"
-            ? (current + 1) % items.length
-            : (current - 1 + items.length) % items.length;
-    items[next]?.focus();
-  };
-
-  return (
-    <aside className="cg-views cg-cohorts" aria-label="Cohorts">
-      <div className="cg-views-head">
-        <div>
-          <div className="cg-views-title">Cohorts</div>
-          <div className="cg-views-save">
-            {lists.length === 1 ? "1 cohort" : `${lists.length.toLocaleString()} cohorts`}
-          </div>
-        </div>
-      </div>
-      {foldersOn && onFolderCreate && (
-        <div className="cg-fold-new">
-          {creatingFolder ? (
-            <input
-              className="cg-input"
-              autoFocus
-              placeholder="Folder name"
-              onBlur={(e) => {
-                const v = e.target.value.trim();
-                if (v) onFolderCreate(v);
-                setCreatingFolder(false);
-              }}
-              onKeyDown={(e) => {
-                if (e.key === "Enter") e.currentTarget.blur();
-                if (e.key === "Escape") setCreatingFolder(false);
-              }}
-            />
-          ) : (
-            <button type="button" className="cg-link-btn" onClick={() => setCreatingFolder(true)}>
-              + New folder
-            </button>
-          )}
-        </div>
-      )}
-      <div className="cg-view-list">
-        {groups.map((group) => {
-        const gid = group.folder?.id ?? null;
-        const shut = gid != null && collapsed.has(gid);
-        return (
-        <div
-          key={gid ?? "__root__"}
-          className={
-            (gid === null ? "cg-fold-root" : "cg-fold") +
-            (dropTarget === (gid ?? "__root__") ? " is-drop" : "")
-          }
-          {...dropHandlers(gid)}
-        >
-          {group.folder && (
-            <div className="cg-fold-head">
-              <button
-                type="button"
-                className="cg-fold-toggle"
-                aria-expanded={!shut}
-                onClick={() =>
-                  setCollapsed((prev) => {
-                    const next = new Set(prev);
-                    if (next.has(group.folder!.id)) next.delete(group.folder!.id);
-                    else next.add(group.folder!.id);
-                    return next;
-                  })
-                }
-              >
-                <span className={"cg-fold-chev" + (shut ? " is-shut" : "")} aria-hidden>
-                  ▾
-                </span>
-                {renamingFolder === group.folder.id ? (
-                  <input
-                    className="cg-input cg-fold-rename"
-                    autoFocus
-                    defaultValue={group.folder.name}
-                    onClick={(e) => e.stopPropagation()}
-                    onBlur={(e) => {
-                      const v = e.target.value.trim();
-                      if (v && v !== group.folder!.name) onFolderRename?.(group.folder!.id, v);
-                      setRenamingFolder(null);
-                    }}
-                    onKeyDown={(e) => {
-                      if (e.key === "Enter") e.currentTarget.blur();
-                      if (e.key === "Escape") setRenamingFolder(null);
-                    }}
-                  />
-                ) : (
-                  <span className="cg-fold-name">{group.folder.name}</span>
-                )}
-                <span className="cg-fold-count">{group.items.length}</span>
-              </button>
-              <button
-                type="button"
-                className="cg-view-more"
-                aria-label={`Actions for folder ${group.folder.name}`}
-                aria-haspopup="menu"
-                onClick={(e) =>
-                  setFolderMenu((cur) =>
-                    cur?.id === group.folder!.id
-                      ? null
-                      : { id: group.folder!.id, anchor: e.currentTarget }
-                  )
-                }
-              >
-                ···
-              </button>
-            </div>
-          )}
-          {!shut &&
-        group.items.map((l) => {
-          const active = l.id === activeCohortId;
-          const renaming = renamingId === l.id;
-          return (
-            <div
-              key={l.id}
-              draggable={foldersOn && !renaming}
-              onDragStart={(e) => e.dataTransfer.setData("text/plain", l.id)}
-            >
-              <div className={"cg-view-row" + (active ? " is-active" : "")}>
-                {renaming ? (
-                  <input
-                    className="cg-view-rename cg-input"
-                    autoFocus
-                    defaultValue={l.name}
-                    aria-label={`Rename ${l.name}`}
-                    onBlur={(event) => {
-                      const next = event.target.value.trim();
-                      if (next && next !== l.name) onRename(l.id, next);
-                      setRenamingId(null);
-                    }}
-                    onKeyDown={(event) => {
-                      if (event.key === "Enter") event.currentTarget.blur();
-                      if (event.key === "Escape") setRenamingId(null);
-                    }}
-                  />
-                ) : (
-                  <button
-                    type="button"
-                    className="cg-view-main"
-                    onClick={() => onSelect(l.id)}
-                    title={l.name}
-                    aria-current={active ? "true" : undefined}
-                  >
-                    <span className="cg-view-dot cg-view-dot--list" aria-hidden />
-                    <span className="cg-cohort-name">{l.name}</span>
-                    <span className="cg-cohort-count">
-                      {(l.pids?.length ?? 0).toLocaleString()}
-                    </span>
-                  </button>
-                )}
-                <button
-                  type="button"
-                  className="cg-view-more"
-                  aria-label={`Actions for ${l.name}`}
-                  aria-haspopup="menu"
-                  aria-expanded={menu?.cohortId === l.id}
-                  onClick={(event) => {
-                    const anchor = event.currentTarget;
-                    setConfirmDelete(false);
-                    setMenu((current) =>
-                      current?.cohortId === l.id ? null : { cohortId: l.id, anchor }
-                    );
-                  }}
-                >
-                  ···
-                </button>
-              </div>
-              {/* Rule 8b: the ACTIVE cohort's members outside the caller's 24-month pool are
-                  not in the table — say so where the count is, not nowhere. */}
-              {active && (l.missing ?? 0) > 0 && (
-                <div className="cg-cohort-missing">
-                  {l.missing!.toLocaleString()} not active in the last 24 months, not shown
-                </div>
-              )}
-            </div>
-          );
-        })}
-        {group.folder && !shut && group.items.length === 0 && (
-          <div className="cg-fold-empty">Empty — drag a cohort here.</div>
-        )}
-        </div>
-        );
-        })}
-        {/* Zero cohorts is the HOST page's near-empty state (it says so before the grid);
-            this line is only the in-frame backstop, and admin having none is CORRECT. */}
-        {lists.length === 0 && (
-          <div className="cg-cohort-empty">
-            No cohorts yet. Build one from the Customer page: filter or check customers,
-            then Add to cohort.
-          </div>
-        )}
-      </div>
-
-      {folderMenu && folderMenuF && (
-        <AnchoredOverlay
-          anchor={folderMenu.anchor}
-          className="cg-view-menu"
-          placement="bottom-end"
-          role="menu"
-          ariaLabel={`Actions for folder ${folderMenuF.name}`}
-          onDismiss={() => {
-            setFolderMenu(null);
-            setConfirmFolderDelete(null);
-          }}
-          dataKind="folder-menu"
-        >
-          <button
-            type="button"
-            role="menuitem"
-            className="cg-menu-item"
-            onClick={() => {
-              setRenamingFolder(folderMenuF.id);
-              setFolderMenu(null);
-            }}
-          >
-            Rename
-          </button>
-          {onFolderAddToList && (
-            <button
-              type="button"
-              role="menuitem"
-              className="cg-menu-item"
-              onClick={() => {
-                setAddTarget(folderMenuF.id);
-                setAddAnchor(folderMenu.anchor);
-                setAddName(today ? `${folderMenuF.name} · ${today}` : folderMenuF.name);
-                setFolderMenu(null);
-              }}
-            >
-              Add to cohort…
-            </button>
-          )}
-          {onFolderDuplicate && (
-            <button
-              type="button"
-              role="menuitem"
-              className="cg-menu-item"
-              onClick={() => {
-                onFolderDuplicate(folderMenuF.id);
-                setFolderMenu(null);
-              }}
-            >
-              Duplicate folder and its cohorts
-            </button>
-          )}
-          {onFolderDelete && (
-            <button
-              type="button"
-              role="menuitem"
-              className={
-                "cg-menu-item cg-menu-item--danger" +
-                (confirmFolderDelete === folderMenuF.id ? " is-armed" : "")
-              }
-              onClick={() => {
-                if (confirmFolderDelete !== folderMenuF.id) {
-                  setConfirmFolderDelete(folderMenuF.id);
-                  return;
-                }
-                onFolderDelete(folderMenuF.id);
-                setConfirmFolderDelete(null);
-                setFolderMenu(null);
-              }}
-            >
-              {confirmFolderDelete === folderMenuF.id
-                ? "Delete folder? Its cohorts move to the top level."
-                : "Delete folder"}
-            </button>
-          )}
-        </AnchoredOverlay>
-      )}
-
-      {/* C4 as amended - the folder-level bulk add. A cohort folder's union needs
-          no engine and has no refusals, so the pane states the deduped total and
-          how many cohorts it came from, and nothing is ever silently omitted. */}
-      {addTarget && addAnchor && onFolderAddToList && (
-        <AnchoredOverlay
-          anchor={addAnchor ?? undefined}
-          className="cg-pop cg-fold-addpop"
-          placement="bottom-start"
-          role="dialog"
-          ariaLabel="Add this folder's customers to a cohort"
-          onDismiss={() => setAddTarget(null)}
-          dataKind="folder-add-to-list"
-        >
-          <div className="cg-pop-title">Add to cohort</div>
-          <div className="cg-pop-note">
-            {addUnion.length.toLocaleString()} customer{addUnion.length === 1 ? "" : "s"} from{" "}
-            {addCount.toLocaleString()} cohort{addCount === 1 ? "" : "s"} in this folder, counted
-            once each.
-          </div>
-          {lists
-            .filter((l) => !folderIdOf || folderIdOf(l.id) !== addTarget)
-            .map((l) => (
-              <button
-                type="button"
-                key={l.id}
-                className="cg-pick-row"
-                onClick={() => {
-                  onFolderAddToList(addTarget, l.id, l.name);
-                  setAddTarget(null);
-                }}
-              >
-                {l.name}
-              </button>
-            ))}
-          <div className="cg-view-create">
-            <label htmlFor="cg-cfold-new-list">New cohort</label>
-            <input
-              id="cg-cfold-new-list"
-              className="cg-input"
-              data-overlay-autofocus
-              value={addName}
-              onChange={(e) => setAddName(e.target.value)}
-              onKeyDown={(e) => {
-                if (e.key === "Enter" && addName.trim()) {
-                  onFolderAddToList(addTarget, "", addName.trim());
-                  setAddTarget(null);
-                }
-              }}
-            />
-            <button
-              type="button"
-              className="cg-btn cg-btn--primary"
-              disabled={!addName.trim() || addUnion.length === 0}
-              onClick={() => {
-                onFolderAddToList(addTarget, "", addName.trim());
-                setAddTarget(null);
-              }}
-            >
-              Create and add
-            </button>
-          </div>
-        </AnchoredOverlay>
-      )}
-
-      {menu && menuCohort && (
-        <AnchoredOverlay
-          anchor={menu.anchor}
-          className="cg-view-menu"
-          placement="bottom-end"
-          role="menu"
-          ariaLabel={`Actions for ${menuCohort.name}`}
-          onDismiss={closeMenu}
-          onKeyDown={onMenuKeyDown}
-          dataKind="cohort-menu"
-        >
-          {/* W2 (C2): Export sits ABOVE the rename/delete group, thin divider between. */}
-          {onExport && (
-            <>
-              <button
-                type="button"
-                role="menuitem"
-                onClick={() => {
-                  setExportFor({ cohortId: menuCohort.id, anchor: menu.anchor });
-                  closeMenu();
-                }}
-              >
-                Export
-              </button>
-              <div className="cg-menu-sep" role="separator" aria-hidden />
-            </>
-          )}
-          <button
-            type="button"
-            role="menuitem"
-            onClick={() => {
-              setRenamingId(menuCohort.id);
-              closeMenu();
-            }}
-          >
-            Rename
-          </button>
-          <button
-            type="button"
-            role="menuitem"
-            className="is-danger"
-            onClick={() => {
-              if (!confirmDelete) {
-                setConfirmDelete(true);
-                return;
-              }
-              onDelete(menuCohort.id);
-              closeMenu();
-            }}
-          >
-            {confirmDelete ? "Delete permanently?" : "Delete"}
-          </button>
-        </AnchoredOverlay>
-      )}
-
-      {/* W2 (C2) — the format pane: CSV · Excel · PDF · JSON, keyboard-navigable like
-          the menu it came from. */}
-      {exportFor && exportCohort && onExport && (
-        <AnchoredOverlay
-          anchor={exportFor.anchor}
-          className="cg-view-menu"
-          placement="bottom-end"
-          role="menu"
-          ariaLabel={`Export ${exportCohort.name}`}
-          onDismiss={() => setExportFor(null)}
-          onKeyDown={onMenuKeyDown}
-          dataKind="cohort-export"
-        >
-          <div className="cg-pop-title cg-export-title">Export {exportCohort.name}</div>
-          {EXPORT_FORMATS.map((format) => (
-            <button
-              key={format}
-              type="button"
-              role="menuitem"
-              onClick={() => {
-                onExport(exportCohort.id, format);
-                setExportFor(null);
-              }}
-            >
-              {EXPORT_LABELS[format]}
-            </button>
-          ))}
-        </AnchoredOverlay>
-      )}
-    </aside>
-  );
-}

web/src/customer-grid/cohortRail.ts

@@ -1,92 +0,0 @@
-// ---------------------------------------------------------------------------
-// customer-grid / cohortRail.ts — wave-15 item 5 (contract C-LOCK, owner R10).
-//
-// THE COHORT MODULE IS GONE, AND ITS COHORTS ARE NOT. R10: every cohort
-// auto-projects as a LOCKED VIEW in a "Cohorts" section of the Customer rail,
-// the `#/cohort` route disappears, and all the cohort machinery stays reachable
-// from Customer. This is the projection — cohort list in, rail rows out.
-//
-// Pure, and separate from ViewSidebar, for the reason every projection in this
-// tree is: the rail is a React component no node gate can mount, and the thing
-// that must not regress is WHAT THE ROWS SAY — particularly a set the reader
-// cannot see, which is a permission surface rather than a display convenience.
-// `verify_cohort_lock.py` drives this directly.
-// ---------------------------------------------------------------------------
-
-/** The cohort shape the host already puts on `/workspace?scope=customer`
- *  (`types.ts` WorkspaceWire.lists — verified against the shipped wire, not assumed). */
-export interface CohortWire {
-  id: string;
-  name: string;
-  pids?: number[];
-  missing?: number;
-  folderId?: string | null;
-}
-
-export interface CohortRailRow {
-  /** The cohort's own id. NOT a view id — these rows are projected, never saved. */
-  id: string;
-  name: string;
-  /**
-   * Members this reader can actually see, or `null` when the set was served without
-   * membership. ⚠ `null` is NOT 0: "a list with nobody in it" and "a list I am not allowed to
-   * count" are different sentences, and the engine already treats the second as unanswerable
-   * (it matches NOTHING). A row that printed 0 for both would describe a set it must not
-   * describe.
-   */
-  count: number | null;
-  /** Members the host knows exist but did not send — disclosed, never folded into `count`. */
-  missing: number;
-  /** True while the grid is showing this cohort, so the rail can mark it the way it marks the
-   *  active view. */
-  active: boolean;
-  /** Always true. Present so the row renders through the same `cg-view-lockset` vocabulary a
-   *  saved locked view uses — one lock mark in the product, not two that drift. */
-  locked: true;
-}
-
-/**
- * Project the cohorts onto rail rows.
- *
- * Ordering is BY NAME, deliberately, and not by size: the rail is how somebody finds a list
- * they already have in mind, and a size order re-arranges itself every time the data moves.
- * `localeCompare` so accented names file where a reader expects.
- */
-export function cohortRailRows(
-  lists: readonly CohortWire[] | undefined,
-  activeCohortId: string | null | undefined
-): CohortRailRow[] {
-  return [...(lists ?? [])]
-    .filter((c) => !!c && typeof c.id === "string" && c.id !== "")
-    .sort((a, b) => a.name.localeCompare(b.name))
-    .map((c) => ({
-      id: c.id,
-      name: c.name,
-      // `pids` ABSENT = no membership was served. An empty array is a real, countable empty set.
-      count: Array.isArray(c.pids) ? c.pids.length : null,
-      missing: typeof c.missing === "number" && c.missing > 0 ? c.missing : 0,
-      active: !!activeCohortId && c.id === activeCohortId,
-      locked: true,
-    }));
-}
-
-/**
- * What the TOOLBAR chip says while a cohort lock is in force (item 5c: "the toolbar shows the
- * locked state near Filter/Sort/Group"). Until this wave the lock was stated only INSIDE the
- * filter popover, which meant the one control that explains a narrowed table was invisible
- * until you opened something.
- *
- * Three sentences, because there are three genuinely different states and only one of them is
- * ordinary:
- *   - a set we can see        -> name it, and say how many are in it
- *   - a set we cannot see     -> say THAT, because the table is empty for a reason that is not
- *                               a filter and the reader would otherwise hunt for one
- *   - no lock                 -> no chip at all
- */
-export function cohortLockChipText(row: Pick<CohortRailRow, "name" | "count"> | null): string | null {
-  if (!row) return null;
-  if (row.count == null) return "Locked to a list you cannot see";
-  return `${row.name} · ${row.count.toLocaleString()} ${
-    row.count === 1 ? "customer" : "customers"
-  }`;
-}