Skip to content
Python
32.1 KB
Raw Blame
// The staffing gate (agent teams, UX-030; worker-connector-grants spec §2, §6): a lead
// proposes its worker roster. Visible layer = the decisions (who — by callname — on what
// model, why), plus per worker the connectors it may use. A worker's declared connectors
// are its DEFAULT set: the lead's suggestion there arrives ticked, with its reason.
// Beyond the default set sits a second group — shown when the lead proposed something
// there (quoting the human's own words) or when the human adds one from everything else
// connected on the machine. The human's final ticks are what the worker gets.
// Approvals FOLLOW THE LEAD: the card states the lead's real mode (live from the
// composer inline; from the gate payload in the Inbox) and has no control of its own.
// Approving grants the lead create/assign/steer for this board — standing, revocable —
// and PRE-SPAWNS the worker sessions. The chat checkbox is the USER's call (default OFF,
// ⓘ per mock); no in-card reply surface: editing happens by replying.
// Models: when the server lists what can run on this machine (`runnable_models`), each
// worker's model is a quiet picker on line one — recommended models first, the rest
// after. A worker whose persona recommends nothing runnable arrives on the fallback with
// a warning glyph; the human's final pick per worker rides the approval. An older
// server sends no list, and the model stays plain text.
// Large teams (owner-ruled 2026-09-17): workers that share a role collapse into ONE line —
// a count, one model and one set of connector ticks for the whole role. "Show workers"
// opens the ordinary per-worker rows for a human who wants to split the role (progressive
// disclosure). A role whose workers differ says so on its line ("Mixed", "11 of 12")
// rather than opening by itself. State and the answer stay per worker: grouping is a view.
import { useRef, useState, type ReactNode } from "react";
import { Trans, useTranslation } from "react-i18next";
import type { TeamMemberDecision } from "../api";
import type { Item } from "../types";
import { modeLabel } from "./Composer";
import { connectorLabel } from "./ConnectorRequestCard";
import { Icon } from "./Icon";
import { modelHover, modelName } from "../modelNames";
import { ProposalActions } from "./ProposalParts";

// Past this length the lead's note clamps to two lines with More/Less — the roster and
// the connector decisions are the card's subject, not the note.
const NOTE_CLAMP_CHARS = 140;

const MIXED = "__mixed__";

const WarnGlyph = () => (
  <svg viewBox="0 0 16 16" width="13" height="13" aria-hidden="true">
    <path
      d="M8 2.2 14.2 13H1.8Z"
      fill="var(--warn-soft)"
      stroke="currentColor"
      strokeWidth="1.4"
      strokeLinejoin="round"
    />
    <path
      d="M8 6.3v3.4"
      stroke="currentColor"
      strokeWidth="1.5"
      strokeLinecap="round"
    />
    <circle cx="8" cy="11.4" r="0.85" fill="currentColor" />
  </svg>
);

export function TeamRequestCard({
  item,
  leadMode,
  modelLabels,
  onRespond,
}: {
  item: Extract<Item, { kind: "teamreq" }>;
  // The lead session's CURRENT approval mode (App state) — rendered, never edited here.
  leadMode?: string;
  // Curated display names from /v1/settings (when the caller has them).
  modelLabels?: Record<string, string>;
  onRespond: (
    approved: boolean,
    feedback?: string,
    enableChat?: boolean,
    members?: TeamMemberDecision[],
  ) => void;
}) {
  const { t } = useTranslation();
  const [chat, setChat] = useState(!!item.enable_chat);
  const [noteOpen, setNoteOpen] = useState(false);
  const [advanced, setAdvanced] = useState(false);
  const [guidance, setGuidance] = useState(() => item.members.map(m => m.approval_guidance ?? ""));
  const rosterRef = useRef<HTMLDivElement>(null);
  const [names, setNames] = useState(() =>
    item.members.map((m) => m.name || ""),
  );
  const normalizedNames = names.map((name) => name.trim().toLowerCase());
  const invalidNames =
    !!item.groups?.length &&
    (normalizedNames.some(
      (name) =>
        !/^[a-z0-9][a-z0-9._-]{0,23}$/.test(name) ||
        ["lead", "user", "board"].includes(name),
    ) ||
      new Set(normalizedNames).size !== names.length);
  const [adding, setAdding] = useState<Record<number, boolean>>({});
  const other = item.other_connected ?? [];
  const offerFor = (persona: string) => item.offer?.[persona] ?? [];
  // What a worker may end up holding: its default set, or anything else connected here.
  const allowedFor = (persona: string) => {
    const offer = offerFor(persona);
    return [...offer, ...other.filter((c) => !offer.includes(c))];
  };
  // The lead's suggestions start ticked — minus anything not connected on this machine.
  const [ticked, setTicked] = useState<Record<number, string[]>>(() =>
    Object.fromEntries(
      item.members.map((m, i) => {
        const allowed = allowedFor(m.persona);
        return [
          i,
          [...new Set(m.connectors ?? [])].filter((c) => allowed.includes(c)),
        ];
      }),
    ),
  );
  // The "beyond" group per worker: the lead's out-of-default suggestions, then the
  // human's additions. An entry stays listed once shown, so unticking never hides it.
  const [beyond, setBeyond] = useState<Record<number, string[]>>(() =>
    Object.fromEntries(
      item.members.map((m, i) => {
        const offer = offerFor(m.persona);
        return [
          i,
          [...new Set(m.connectors ?? [])].filter(
            (c) => !offer.includes(c) && other.includes(c),
          ),
        ];
      }),
    ),
  );
  const toggle = (i: number, c: string) =>
    setTicked((cur) => {
      const have = cur[i] ?? [];
      return {
        ...cur,
        [i]: have.includes(c) ? have.filter((x) => x !== c) : [...have, c],
      };
    });
  const addBeyond = (i: number, c: string) => {
    setBeyond((cur) => ({ ...cur, [i]: [...(cur[i] ?? []), c] }));
    setTicked((cur) => ({
      ...cur,
      [i]: [...(cur[i] ?? []).filter((x) => x !== c), c],
    }));
  };
  // Set one connector for several workers at once (a role line). Turning on a connector
  // outside a worker's usual set lists it in that worker's "beyond" group too.
  const setForWorkers = (idxs: number[], c: string, on: boolean) => {
    setTicked((cur) => {
      const next = { ...cur };
      for (const i of idxs) {
        const have = (next[i] ?? []).filter((x) => x !== c);
        next[i] = on ? [...have, c] : have;
      }
      return next;
    });
    if (on)
      setBeyond((cur) => {
        const next = { ...cur };
        for (const i of idxs)
          if (
            !offerFor(item.members[i].persona).includes(c) &&
            !(next[i] ?? []).includes(c)
          )
            next[i] = [...(next[i] ?? []), c];
        return next;
      });
  };
  // Roles in order of first appearance, each with the roster indexes of its workers.
  const groups: { persona: string; idxs: number[] }[] = [];
  item.members.forEach((m, i) => {
    const g = groups.find((x) => x.persona === m.persona);
    if (g) g.idxs.push(i);
    else groups.push({ persona: m.persona, idxs: [i] });
  });
  const [open, setOpen] = useState<Record<string, boolean>>({});
  const [groupAdding, setGroupAdding] = useState<Record<string, boolean>>({});
  const runnable = Array.isArray(item.runnable_models)
    ? item.runnable_models
    : null;
  const recommendedFor = (persona: string) => {
    const rec = item.model_options?.[persona];
    return Array.isArray(rec) ? rec : [];
  };
  // The model's NAME only; provider and raw id go in the hover text.
  const serverLabels = Object.fromEntries(
    (runnable ?? []).map((r) => [r.id, r.label]),
  );
  const labels = { ...serverLabels, ...(modelLabels ?? {}) };
  const modelLabelOf = (id: string) => modelName(id, labels);
  // Each worker's current model pick — starts on what the server resolved for it.
  const [picked, setPicked] = useState<Record<number, string>>(() =>
    Object.fromEntries(
      item.members.map((m, i) => [
        i,
        m.resolved_model || m.model || item.lead_model || "",
      ]),
    ),
  );
  const decisions = (): TeamMemberDecision[] =>
    item.members.map((m, i) => {
      const allowed = allowedFor(m.persona);
      return {
        persona: m.persona,
        ...(names[i] ? { name: names[i].trim() } : {}),
        connectors: (ticked[i] ?? []).filter((c) => allowed.includes(c)),
        ...(guidance[i] || m.approval_guidance !== undefined ? { approval_guidance: guidance[i] } : {}),
        ...(runnable && picked[i] ? { model: picked[i] } : {}),
      };
    });
  const mode = leadMode ?? item.lead_mode;
  const note = item.note || "";
  const noteLong = note.length > NOTE_CLAMP_CHARS;
  const connectorBox = (i: number, c: string, reason?: string) => (
    <label key={c} className="teamreq-connector">
      <input
        type="checkbox"
        data-testid={`teamreq-connector-${i}-${c}`}
        checked={(ticked[i] ?? []).includes(c)}
        onChange={() => toggle(i, c)}
      />
      <span>{connectorLabel(c)}</span>
      {reason && <span className="teamreq-connector-reason">{reason}</span>}
    </label>
  );
  const modelOptions = (persona: string, current: string) => {
    const recommended = runnable ? recommendedFor(persona) : [];
    const others = (runnable ?? [])
      .map((r) => r.id)
      .filter((id) => !recommended.includes(id));
    return (
      <>
        {current !== MIXED &&
          !recommended.includes(current) &&
          !others.includes(current) && (
            <option value={current}>
              {current ? modelLabelOf(current) : t("team.default_model")}
            </option>
          )}
        {recommended.length > 0 && (
          <optgroup label={t("team.models_recommended")}>
            {recommended.map((id) => (
              <option key={id} value={id}>
                {modelLabelOf(id)}
              </option>
            ))}
          </optgroup>
        )}
        {others.length > 0 && (
          <optgroup label={t("team.models_on_machine")}>
            {others.map((id) => (
              <option key={id} value={id}>
                {modelLabelOf(id)}
              </option>
            ))}
          </optgroup>
        )}
      </>
    );
  };
  const warningOf = (i: number) => {
    const m = item.members[i];
    return runnable &&
      m.model_warning &&
      (picked[i] ?? "") === (m.resolved_model ?? "")
      ? m.model_warning
      : "";
  };
  const memberRow = (i: number): ReactNode => {
    const m = item.members[i];
    const offer = offerFor(m.persona);
    const extra = beyond[i] ?? [];
    const addable = other.filter(
      (c) => !offer.includes(c) && !extra.includes(c),
    );
    const reasons = m.connector_reasons ?? {};
    const current = picked[i] ?? "";
    const recommended = runnable ? recommendedFor(m.persona) : [];
    const warn = warningOf(i);
    const offList =
      !!runnable && recommended.length > 0 && !recommended.includes(current);
    return (
      <div className="teamreq-row" key={i} data-testid={`teamreq-row-${i}`}>
        <span className="teamreq-diamond">◆</span>
        <span className="teamreq-body">
          <span className="teamreq-who">
            {m.name && <b className="teamreq-name">{m.name}</b>}
            {m.name ? " — " : ""}
            <code>{m.persona}</code>
            {runnable ? (
              <>
                <span className="teamreq-model"> · </span>
                <span className="teamreq-model-pick">
                  <select
                    className="teamreq-model-select"
                    data-testid={`teamreq-model-${i}`}
                    aria-label={t("team.model_for", {
                      who: m.name || m.persona,
                    })}
                    title={modelHover(current, labels)}
                    value={current}
                    onChange={(e) =>
                      setPicked((cur) => ({ ...cur, [i]: e.target.value }))
                    }
                  >
                    {modelOptions(m.persona, current)}
                  </select>
                </span>
                {warn && (
                  <span
                    className="teamreq-model-warn"
                    data-testid={`teamreq-model-warn-${i}`}
                    role="img"
                    aria-label={warn}
                    title={warn}
                  >
                    <WarnGlyph />
                  </span>
                )}
              </>
            ) : (
              m.model && (
                <span
                  className="teamreq-model"
                  title={modelHover(m.model, labels)}
                >
                  {" "}
                  · {modelLabelOf(m.model)}
                </span>
              )
            )}
          </span>
          {offList && (
            <span
              className="teamreq-model-note"
              data-testid={`teamreq-model-note-${i}`}
            >
              {t("team.model_off_list_worker")}
            </span>
          )}
          {m.reason && <span className="teamreq-reason">{m.reason}</span>}
          {!!item.groups?.length && (
            <label className="proposal-name">
              {t("proposal.worker_name")}
              <input
                value={names[i]}
                onChange={(e) =>
                  setNames((cur) =>
                    cur.map((name, index) =>
                      index === i ? e.target.value : name,
                    ),
                  )
                }
              />
            </label>
          )}
          {!!m.item_ids?.length && (
            <span className="proposal-responsibilities">
              <span className="proposal-label">
                {t("proposal.planned_responsibilities")}
              </span>
              {m.item_ids.map((id) => (
                <span key={id}>
                  {item.planned_items?.find((task) => task.id === id)?.title ||
                    `#${id}`}
                </span>
              ))}
            </span>
          )}
          <span className="teamreq-dials">
            {offer.length > 0 ? (
              <span className="teamreq-connectors">
                <span className="teamreq-dial-label">
                  {t("persona.connectors")}
                </span>
                {offer.map((c) => connectorBox(i, c, reasons[c]))}
              </span>
            ) : extra.length === 0 && other.length === 0 ? (
              <span className="teamreq-connectors">
                <span className="teamreq-dial-label">
                  {t("persona.connectors")}
                </span>
                <span className="teamreq-none">{t("team.none_available")}</span>
              </span>
            ) : null}
            {extra.length > 0 && (
              <span
                className="teamreq-connectors teamreq-beyond"
                data-testid={`teamreq-beyond-${i}`}
              >
                <span className="teamreq-dial-label">
                  {t("team.beyond_worker")}
                </span>
                {extra.map((c) => connectorBox(i, c, reasons[c]))}
              </span>
            )}
            {addable.length > 0 && (
              <button
                className="teamreq-add"
                data-testid={`teamreq-add-${i}`}
                aria-expanded={!!adding[i]}
                onClick={() => setAdding((s) => ({ ...s, [i]: !s[i] }))}
              >
                {t("team.add_connector")}
              </button>
            )}
            {adding[i] && addable.length > 0 && (
              <span
                className="teamreq-connectors"
                data-testid={`teamreq-addlist-${i}`}
              >
                {addable.map((c) => (
                  <label key={c} className="teamreq-connector">
                    <input
                      type="checkbox"
                      data-testid={`teamreq-connector-${i}-${c}`}
                      checked={false}
                      onChange={() => addBeyond(i, c)}
                    />
                    <span>{connectorLabel(c)}</span>
                  </label>
                ))}
              </span>
            )}
          </span>
        </span>
      </div>
    );
  };
  // One line for a whole role. Its controls set every worker of the role at once.
  const groupRow = (g: { persona: string; idxs: number[] }): ReactNode => {
    const { persona, idxs } = g;
    const n = idxs.length;
    const offer = offerFor(persona);
    const isOpen = !!open[persona];
    const names = idxs.map((i) => item.members[i].name || "").filter(Boolean);
    const reasonsSet = new Set(idxs.map((i) => item.members[i].reason || ""));
    const sharedReason = reasonsSet.size === 1 ? [...reasonsSet][0] : "";
    // Model: one value when the role agrees, otherwise a count per model.
    const models = idxs.map((i) => picked[i] ?? "");
    const uniform = models.every((x) => x === models[0]);
    const tally = [...new Set(models)].map((id) => {
      const count = models.filter((x) => x === id).length;
      const model = modelLabelOf(id);
      return model
        ? t("team.tally_model", { n: count, model })
        : t("team.tally_default", { n: count });
    });
    const tallyText = tally.join(t("team.list_separator"));
    const recommended = runnable ? recommendedFor(persona) : [];
    const offList =
      !!runnable &&
      uniform &&
      recommended.length > 0 &&
      !recommended.includes(models[0]);
    const warned = idxs.filter((i) => warningOf(i));
    const warn = warned.length
      ? warned.length < n
        ? t("team.warning_partial", {
            warning: warningOf(warned[0]),
            have: warned.length,
            n,
          })
        : warningOf(warned[0])
      : "";
    // Connectors: the role's usual set, then anything beyond it that any worker holds.
    const extra = [...new Set(idxs.flatMap((i) => beyond[i] ?? []))];
    const addable = other.filter(
      (c) => !offer.includes(c) && !extra.includes(c),
    );
    const holders = (c: string) =>
      idxs.filter((i) => (ticked[i] ?? []).includes(c));
    const sharedConnectorReason = (c: string) => {
      const rs = new Set(
        holders(c).map((i) => item.members[i].connector_reasons?.[c] || ""),
      );
      return rs.size === 1 ? [...rs][0] : "";
    };
    const groupBox = (c: string) => {
      const have = holders(c).length;
      const reason = sharedConnectorReason(c);
      return (
        <label key={c} className="teamreq-connector">
          <input
            type="checkbox"
            data-testid={`teamreq-group-connector-${persona}-${c}`}
            checked={have === n}
            ref={(el) => {
              if (el) el.indeterminate = have > 0 && have < n;
            }}
            onChange={() => setForWorkers(idxs, c, have !== n)}
          />
          <span>{connectorLabel(c)}</span>
          {have > 0 && have < n && (
            <span
              className="teamreq-partial"
              data-testid={`teamreq-group-partial-${persona}-${c}`}
            >
              {t("team.partial", { have, n })}
            </span>
          )}
          {reason && <span className="teamreq-connector-reason">{reason}</span>}
        </label>
      );
    };
    // Sits at the end of the last connectors line, so a role stays three lines tall.
    const addButton = addable.length > 0 && (
      <button
        className="teamreq-add teamreq-add-inline"
        data-testid={`teamreq-group-add-${persona}`}
        aria-expanded={!!groupAdding[persona]}
        onClick={() =>
          setGroupAdding((cur) => ({ ...cur, [persona]: !cur[persona] }))
        }
      >
        {t("team.add_another")}
      </button>
    );
    return (
      <div
        className="teamreq-group"
        key={persona}
        data-testid={`teamreq-group-${persona}`}
      >
        <div className="teamreq-row teamreq-group-row">
          <span className="teamreq-diamond">◆</span>
          <span className="teamreq-body">
            <span className="teamreq-who">
              <code>{persona}</code>
              <b className="teamreq-count">× {n}</b>
              {runnable ? (
                <>
                  <span className="teamreq-model">·</span>
                  <span className="teamreq-model-pick">
                    <select
                      className="teamreq-model-select"
                      data-testid={`teamreq-group-model-${persona}`}
                      aria-label={t("team.model_for_role", { n, persona })}
                      title={
                        uniform ? modelHover(models[0], labels) : tallyText
                      }
                      value={uniform ? models[0] : MIXED}
                      onChange={(e) => {
                        const v = e.target.value;
                        if (v !== MIXED)
                          setPicked((cur) => ({
                            ...cur,
                            ...Object.fromEntries(idxs.map((i) => [i, v])),
                          }));
                      }}
                    >
                      {!uniform && (
                        <option value={MIXED} disabled>
                          {t("team.mixed_models", { n: tally.length })}
                        </option>
                      )}
                      {modelOptions(persona, uniform ? models[0] : MIXED)}
                    </select>
                  </span>
                  {warn && (
                    <span
                      className="teamreq-model-warn"
                      data-testid={`teamreq-group-warn-${persona}`}
                      role="img"
                      aria-label={warn}
                      title={warn}
                    >
                      <WarnGlyph />
                    </span>
                  )}
                </>
              ) : null}
              <span className="spacer" />
              <button
                className="teamreq-add teamreq-group-toggle"
                data-testid={`teamreq-group-toggle-${persona}`}
                aria-expanded={isOpen}
                onClick={() =>
                  setOpen((cur) => ({ ...cur, [persona]: !cur[persona] }))
                }
              >
                {isOpen ? t("team.hide_workers") : t("team.show_workers")}
              </button>
            </span>
            {offList && (
              <span className="teamreq-model-note">
                {t("team.model_off_list_role")}
              </span>
            )}
            {!uniform && (
              <span
                className="teamreq-model-note"
                data-testid={`teamreq-group-tally-${persona}`}
              >
                {tallyText}
              </span>
            )}
            <span className="teamreq-reason">
              {sharedReason ||
                (names.length > 3
                  ? t("team.names_and_more", {
                      names: names.slice(0, 3).join(t("team.list_separator")),
                      n: names.length - 3,
                    })
                  : names.join(t("team.list_separator")))}
            </span>
            <span className="teamreq-dials">
              {offer.length > 0 ? (
                <span className="teamreq-connectors">
                  <span className="teamreq-dial-label">
                    {t("team.connectors_for_all", { n })}
                  </span>
                  {offer.map(groupBox)}
                  {extra.length === 0 && addButton}
                </span>
              ) : extra.length === 0 && other.length === 0 ? (
                <span className="teamreq-connectors">
                  <span className="teamreq-dial-label">
                    {t("persona.connectors")}
                  </span>
                  <span className="teamreq-none">
                    {t("team.none_available")}
                  </span>
                </span>
              ) : null}
              {extra.length > 0 && (
                <span className="teamreq-connectors teamreq-beyond">
                  <span className="teamreq-dial-label">
                    {t("team.beyond_role")}
                  </span>
                  {extra.map(groupBox)}
                  {addButton}
                </span>
              )}
              {offer.length === 0 && extra.length === 0 && addButton}
              {groupAdding[persona] && addable.length > 0 && (
                <span className="teamreq-connectors">
                  {addable.map((c) => (
                    <label key={c} className="teamreq-connector">
                      <input
                        type="checkbox"
                        data-testid={`teamreq-group-connector-${persona}-${c}`}
                        checked={false}
                        onChange={() => setForWorkers(idxs, c, true)}
                      />
                      <span>{connectorLabel(c)}</span>
                    </label>
                  ))}
                </span>
              )}
            </span>
          </span>
        </div>
        {isOpen && (
          <div
            className="teamreq-group-members"
            data-testid={`teamreq-group-members-${persona}`}
          >
            {idxs.map(memberRow)}
          </div>
        )}
      </div>
    );
  };
  return (
    <div
      className="dirreq-card teamreq-card proposal-card"
      data-testid="teamreq-card"
    >
      <div className="proposal-content">
        <header className="proposal-heading">
          <span className="proposal-mark">
            <Icon name="team" size={20} />
          </span>
          <div>
            <span className="proposal-label">
              {t("proposal.proposed_team")}
            </span>
            <h3>
              {item.title || t("team.creating", { count: item.members.length })}
            </h3>
          </div>
        </header>
        {item.summary && <p className="proposal-summary">{item.summary}</p>}
        <div className="teamreq-head">
          <span className="teamreq-title">
            {/* Roles show only when some role has 2+ workers, so that sentence is always "N workers". */}
            {groups.length < item.members.length
              ? t("team.creating_roles", {
                  workers: item.members.length,
                  count: groups.length,
                })
              : t("team.creating", { count: item.members.length })}
          </span>
        </div>
        {note && (
          <div className="teamreq-note-wrap">
            <div
              className={
                "teamreq-note" + (noteLong && !noteOpen ? " clamped" : "")
              }
            >
              {note}
            </div>
            {noteLong && (
              <button
                className="teamreq-note-toggle"
                data-testid="teamreq-note-toggle"
                onClick={() => setNoteOpen((o) => !o)}
              >
                {noteOpen ? t("team.less") : t("team.more")}
              </button>
            )}
          </div>
        )}
        {/* The roster scrolls inside the card; the header above and the decision below stay
          in view however many workers the lead proposes. */}
        <div className="teamreq-roster" data-testid="teamreq-roster" ref={rosterRef}>
          {item.groups?.length
            ? item.groups.map((group) => {
                const idxs = item.members
                  .map((_, i) => i)
                  .filter((i) => item.members[i].group === group.id);
                return (
                  <details className="proposal-group" key={group.id}>
                    <summary>
                      <Icon name="chevronRight" size={14} />
                      <span className="proposal-group-title">
                        {group.title}
                        <small>{group.summary}</small>
                      </span>
                      <span className="proposal-muted">
                        {t("proposal.workers", { count: idxs.length })}
                      </span>
                    </summary>
                    <div className="proposal-group-content">
                      {idxs.map(memberRow)}
                    </div>
                  </details>
                );
              })
            : groups.map((g) =>
                g.idxs.length === 1 ? memberRow(g.idxs[0]) : groupRow(g),
              )}
        </div>
        {[
          ...new Map(
            (item.planned_items || []).flatMap((task) =>
              task.final_acceptance
                ? [[task.final_acceptance.id, task.final_acceptance] as const]
                : [],
            ),
          ).values(),
        ].map((final) => (
          <div className="proposal-final" key={final.id}>
            <span className="proposal-label">
              {t("proposal.final_acceptance")}
            </span>
            <p>{final.title}</p>
            <p className="proposal-muted">
              {t(
                final.owner === "lead"
                  ? "proposal.owner_lead"
                  : "proposal.owner_assigned_worker",
              )}
            </p>
          </div>
        ))}
        <div
          className="proposal-access"
          data-testid="proposal-connector-summary"
        >
          <div className="proposal-access-heading">
            <span className="proposal-label">{t("proposal.connector_access")}</span>
            <button
              className="teamreq-add"
              data-testid="proposal-manage-connectors"
              onClick={() => {
                rosterRef.current?.querySelectorAll("details").forEach((group) => { group.open = true; });
                setOpen(Object.fromEntries(groups.map((group) => [group.persona, true])));
                setAdding(Object.fromEntries(item.members.map((_, i) => [i, true])));
                rosterRef.current?.scrollIntoView({ block: "nearest", behavior: "smooth" });
              }}
            >
              {t("proposal.manage_connectors")}
            </button>
          </div>
          {[...new Set(Object.values(ticked).flat())].length ? (
            [...new Set(Object.values(ticked).flat())].map((connector) => (
              <span key={connector}>
                {connectorLabel(connector)} ·{" "}
                {t("proposal.workers", {
                  count: Object.values(ticked).filter((list) =>
                    list.includes(connector),
                  ).length,
                })}
              </span>
            ))
          ) : (
            <span>{t("proposal.no_connectors")}</span>
          )}
        </div>
        {mode && (
          <div className="teamreq-approvals" data-testid="teamreq-approvals">
            <Trans
              i18nKey="team.approvals_follow"
              values={{ mode: modeLabel(mode) }}
              components={{ b: <b /> }}
            />
          </div>
        )}
        <div className="teamreq-advanced">
          <button type="button" className="teamreq-add" aria-expanded={advanced} data-testid="teamreq-advanced"
            onClick={() => setAdvanced(value => !value)}>
            <Icon name={advanced ? "chevronDown" : "chevronRight"} size={12} /> {t("team.advanced")}
          </button>
          {advanced && <div className="teamreq-guidance">
            <p className="proposal-muted">{t("team.guidance_help")}</p>
            {item.members.map((m, i) => <label key={i}>
              <span>{t("team.approval_guidance")} · {names[i] || m.persona}</span>
              <textarea rows={3} maxLength={2400} value={guidance[i]}
                onChange={event => setGuidance(current => current.map((text, j) => j === i ? event.target.value : text))} />
            </label>)}
          </div>}
        </div>
        <label className="teamreq-chat">
          <input
            type="checkbox"
            data-testid="teamreq-chat-toggle"
            checked={chat}
            onChange={(e) => setChat(e.target.checked)}
          />
          <span>
            <Trans i18nKey="team.enable_chat" components={{ b: <b /> }} />
          </span>
          <span className="teamreq-info" title={t("team.chat_info")}>
            i
          </span>
        </label>
        <p className="proposal-muted proposal-permission-note">
          {t("proposal.staffing_not_assignment")}
        </p>
        {invalidNames && <p role="alert">{t("proposal.invalid_names")}</p>}
      </div>
      <ProposalActions
        approveLabel={t("team.create_team")}
        testId="teamreq-approve"
        disabled={invalidNames}
        onApprove={() => onRespond(true, undefined, chat, decisions())}
        onReject={(feedback) => onRespond(false, feedback)}
      />
    </div>
  );
}