@saadnvd1/agent-os 0.3.851 → 0.3.859

package/lib/leads/home.ts

@@ -0,0 +1,196 @@
+/**
+ * A workspace's leads: durable chat sessions run like its orchestrator, each
+ * heading one department. The orchestrator is the Tech lead in place (same
+ * row, same data); the others are rows with the lead role, made by "Add leads"
+ * or adopted from an existing chat (./adopt).
+ */
+
+import fs from "fs";
+import { randomBytes, randomUUID, timingSafeEqual } from "crypto";
+import { db, type Session } from "../db";
+import { agentosHome } from "../agentos-home";
+import { refuseRealStateUnderTest } from "../test-home-guard";
+import { getWorkspace } from "../workspaces";
+import { resolveRoleOrDefault } from "../models/resolve";
+import {
+  ensureOrchestrator,
+  getOrchestrator,
+  orchestratorDir,
+} from "../orchestrator/home";
+import { isLeadKind, leadKindOf, sqlLead, sqlStanding } from "./roles";
+import { TECH, type LeadKind } from "./types";
+import { markLeadsEnabled } from "./settings";
+import { getCharter, leadAreas, putCharter } from "./charters";
+import { charterTemplate } from "./templates";
+
+// Tech first, then the shipped kinds, then custom ones by name.
+const ORDER = [TECH, "marketing", "product"];
+const rank = (kind: string) => {
+  const i = ORDER.indexOf(kind);
+  return i < 0 ? ORDER.length : i;
+};
+export const byLeadOrder = (a: string, b: string) =>
+  rank(a) - rank(b) || a.localeCompare(b);
+
+// Where a lead starts and may write freely: the Tech lead keeps the
+// orchestrator's folder.
+export const leadDir = (workspaceId: string, kind: LeadKind) =>
+  kind === TECH
+    ? orchestratorDir(workspaceId)
+    : refuseRealStateUnderTest(agentosHome("leads", workspaceId, kind));
+
+// A standing session's own folder, whatever its role.
+export const standingDir = (
+  s: Pick<Session, "role" | "lead_kind" | "workspace_id">
+) => leadDir(s.workspace_id ?? "", leadKindOf(s) ?? "chief");
+
+export function getLead(workspaceId: string, kind: LeadKind): Session | null {
+  if (kind === TECH) return getOrchestrator(workspaceId);
+  return (
+    (db
+      .prepare(
+        `SELECT * FROM session_rows WHERE ${sqlLead()} AND workspace_id = ? AND lead_kind = ?`
+      )
+      .get(workspaceId, kind) as Session | undefined) ?? null
+  );
+}
+
+// The workspace's heads: its orchestrator (Tech) and its other leads.
+export function listLeads(workspaceId: string): Session[] {
+  const rows = db
+    .prepare(
+      `SELECT * FROM session_rows
+       WHERE workspace_id = ? AND ${sqlLead()}`
+    )
+    .all(workspaceId) as Session[];
+  return rows.sort((a, b) =>
+    byLeadOrder(leadKindOf(a) ?? "", leadKindOf(b) ?? "")
+  );
+}
+
+export function leadTitle(workspaceId: string, kind: LeadKind): string {
+  return getCharter(workspaceId, kind)?.title || charterTemplate(kind).title;
+}
+
+// A lead starts from the generic charter for its kind; one already written
+// (by the person, in their own database) is never overwritten.
+export function seedCharter(workspaceId: string, kind: LeadKind): void {
+  if (getCharter(workspaceId, kind)) return;
+  const t = charterTemplate(kind);
+  putCharter({ workspaceId, leadKind: kind, ...t });
+}
+
+// Marks the orchestrator as the Tech lead, once.
+function claimTech(workspaceId: string): Session {
+  const tech = ensureOrchestrator(workspaceId);
+  db.prepare(
+    `UPDATE sessions SET lead_kind = 'tech', lead_since = COALESCE(lead_since, datetime('now'))
+     WHERE id = ?`
+  ).run(tech.id);
+  seedCharter(workspaceId, TECH);
+  return getOrchestrator(workspaceId)!;
+}
+
+function createLead(workspaceId: string, kind: LeadKind): Session {
+  const existing = getLead(workspaceId, kind);
+  if (existing) return existing;
+  const workspace = getWorkspace(workspaceId)!;
+  seedCharter(workspaceId, kind);
+  const dir = leadDir(workspaceId, kind);
+  fs.mkdirSync(dir, { recursive: true });
+  const id = randomUUID();
+  // Two at once still make one: the unique (workspace, kind) index decides.
+  db.prepare(
+    `INSERT OR IGNORE INTO sessions (id, name, tmux_name, working_directory, model,
+       group_path, agent_type, auto_approve, project_id, host_id, view, chat_access,
+       role, lead_kind, lead_since, workspace_id, pinned)
+     VALUES (?, ?, ?, ?, ?, 'sessions', 'claude', 0, NULL, 'local', 'chat', 'ask',
+       'lead', ?, datetime('now'), ?, 1)`
+  ).run(
+    id,
+    `${workspace.name} ${leadTitle(workspaceId, kind)}`,
+    `claude-${id}`,
+    dir,
+    resolveRoleOrDefault("orchestrator", { workspaceId }).model,
+    kind,
+    workspaceId
+  );
+  return getLead(workspaceId, kind)!;
+}
+
+export function checkKinds(kinds: unknown): LeadKind[] {
+  if (!Array.isArray(kinds) || !kinds.every(isLeadKind))
+    throw new Error(
+      "Each lead is a short lowercase name: letters, digits and dashes"
+    );
+  return [...new Set(kinds)].filter((k) => k !== TECH);
+}
+
+// "Add leads": the workspace gets its Tech lead (its orchestrator, made if
+// it has none) and the leads picked. Safe to run again; nothing made twice.
+export function addLeads(workspaceId: string, kinds: LeadKind[]): Session[] {
+  if (!getWorkspace(workspaceId)) throw new Error("Unknown workspace");
+  const picked = checkKinds(kinds);
+  markLeadsEnabled(workspaceId);
+  claimTech(workspaceId);
+  for (const kind of picked) createLead(workspaceId, kind);
+  return listLeads(workspaceId);
+}
+
+// The secret a standing session's worker sends with each tool call, so no
+// other local process can act as it. The orchestrator's is the one it
+// always had.
+export function standingToken(sessionId: string): string {
+  db.prepare(
+    `UPDATE sessions SET orch_token = COALESCE(orch_token, ?) WHERE id = ?`
+  ).run(randomBytes(32).toString("hex"), sessionId);
+  const row = db
+    .prepare(`SELECT orch_token FROM sessions WHERE id = ?`)
+    .get(sessionId) as { orch_token: string | null } | undefined;
+  if (!row?.orch_token) throw new Error("No such session");
+  return row.orch_token;
+}
+
+// Which of the workspace's standing sessions holds this token, if any.
+export function standingByToken(
+  workspaceId: string,
+  token: string | null
+): Session | null {
+  if (!token) return null;
+  const b = Buffer.from(token);
+  const rows = db
+    .prepare(
+      `SELECT * FROM session_rows
+       WHERE workspace_id = ? AND ${sqlStanding()} AND orch_token IS NOT NULL`
+    )
+    .all(workspaceId) as Session[];
+  let found: Session | null = null;
+  for (const s of rows) {
+    const a = Buffer.from(s.orch_token!);
+    if (a.length === b.length && timingSafeEqual(a, b)) found = s;
+  }
+  return found;
+}
+
+export interface LeadView {
+  kind: LeadKind;
+  title: string;
+  sessionId: string;
+  name: string;
+  since: string | null;
+  areas: { kind: string; value: string }[];
+}
+
+export function leadViews(workspaceId: string): LeadView[] {
+  return listLeads(workspaceId).map((s) => {
+    const kind = leadKindOf(s) ?? TECH;
+    return {
+      kind,
+      title: leadTitle(workspaceId, kind),
+      sessionId: s.id,
+      name: s.name,
+      since: s.lead_since ?? null,
+      areas: leadAreas(workspaceId, kind),
+    };
+  });
+}

package/lib/leads/index.ts

@@ -0,0 +1,8 @@
+export * from "./types";
+export * from "./roles";
+export * from "./settings";
+export * from "./charters";
+export * from "./direction";
+export * from "./memos";
+export * from "./messages";
+export * from "./usage";

package/lib/leads/memos.ts

@@ -0,0 +1,70 @@
+import { db } from "@/lib/db";
+import type { LeadKind, LeadMemo } from "./types";
+
+// About 1.5k tokens: what a lead carries across a fresh start, with its
+// pinned direction.
+export const MEMO_CAP = 6000;
+
+interface Row {
+  id: number;
+  workspace_id: string;
+  lead_kind: string;
+  text: string;
+  created_at: string;
+}
+
+const view = (r: Row): LeadMemo => ({
+  id: r.id,
+  workspaceId: r.workspace_id,
+  leadKind: r.lead_kind,
+  text: r.text,
+  createdAt: r.created_at,
+});
+
+// Every version is kept; the newest is the memo.
+export function writeMemo(
+  workspaceId: string,
+  leadKind: LeadKind,
+  text: string
+): LeadMemo {
+  const body = text.trim().slice(0, MEMO_CAP);
+  if (!body) throw new Error("The memo is empty");
+  const { lastInsertRowid } = db
+    .prepare(
+      `INSERT INTO lead_memos (workspace_id, lead_kind, text) VALUES (?, ?, ?)`
+    )
+    .run(workspaceId, leadKind, body);
+  return view(
+    db
+      .prepare(`SELECT * FROM lead_memos WHERE id = ?`)
+      .get(Number(lastInsertRowid)) as Row
+  );
+}
+
+export function latestMemo(
+  workspaceId: string,
+  leadKind: LeadKind
+): LeadMemo | null {
+  const r = db
+    .prepare(
+      `SELECT * FROM lead_memos WHERE workspace_id = ? AND lead_kind = ?
+       ORDER BY id DESC LIMIT 1`
+    )
+    .get(workspaceId, leadKind) as Row | undefined;
+  return r ? view(r) : null;
+}
+
+export function memoHistory(
+  workspaceId: string,
+  leadKind: LeadKind,
+  limit = 20
+): LeadMemo[] {
+  return (
+    db
+      .prepare(
+        `SELECT * FROM lead_memos WHERE workspace_id = ? AND lead_kind = ?
+         ORDER BY id DESC LIMIT ?`
+      )
+      .all(workspaceId, leadKind, limit) as Row[]
+  ).map(view);
+}

package/lib/leads/messages.ts

@@ -0,0 +1,112 @@
+import { db } from "@/lib/db";
+import type { LeadKind, LeadMessage } from "./types";
+
+const TEXT_CAP = 4000;
+
+interface Row {
+  id: number;
+  workspace_id: string;
+  from_kind: string;
+  to_kind: string;
+  thread: string;
+  text: string;
+  created_at: string;
+  read_at: string | null;
+}
+
+const view = (r: Row): LeadMessage => ({
+  id: r.id,
+  workspaceId: r.workspace_id,
+  fromKind: r.from_kind,
+  toKind: r.to_kind,
+  thread: r.thread,
+  text: r.text,
+  createdAt: r.created_at,
+  readAt: r.read_at,
+});
+
+// Lead-to-lead and chief-to-lead mail. The chief writes as "chief".
+export function addLeadMessage(m: {
+  workspaceId: string;
+  fromKind: LeadKind;
+  toKind: LeadKind;
+  thread: string;
+  text: string;
+}): LeadMessage {
+  const text = m.text.trim().slice(0, TEXT_CAP);
+  const thread = m.thread.trim().slice(0, 120);
+  if (!text || !thread) throw new Error("A message needs a thread and text");
+  const { lastInsertRowid } = db
+    .prepare(
+      `INSERT INTO lead_messages (workspace_id, from_kind, to_kind, thread, text)
+       VALUES (?, ?, ?, ?, ?)`
+    )
+    .run(m.workspaceId, m.fromKind, m.toKind, thread, text);
+  return view(
+    db
+      .prepare(`SELECT * FROM lead_messages WHERE id = ?`)
+      .get(Number(lastInsertRowid)) as Row
+  );
+}
+
+export function unreadFor(
+  workspaceId: string,
+  toKind: LeadKind
+): LeadMessage[] {
+  return (
+    db
+      .prepare(
+        `SELECT * FROM lead_messages
+         WHERE workspace_id = ? AND to_kind = ? AND read_at IS NULL ORDER BY id`
+      )
+      .all(workspaceId, toKind) as Row[]
+  ).map(view);
+}
+
+export function markRead(
+  workspaceId: string,
+  toKind: LeadKind,
+  upToId: number
+): number {
+  return db
+    .prepare(
+      `UPDATE lead_messages SET read_at = datetime('now')
+       WHERE workspace_id = ? AND to_kind = ? AND id <= ? AND read_at IS NULL`
+    )
+    .run(workspaceId, toKind, upToId).changes;
+}
+
+export function threadMessages(
+  workspaceId: string,
+  thread: string,
+  limit = 50
+): LeadMessage[] {
+  return (
+    db
+      .prepare(
+        `SELECT * FROM (SELECT * FROM lead_messages WHERE workspace_id = ? AND thread = ?
+         ORDER BY id DESC LIMIT ?) ORDER BY id`
+      )
+      .all(workspaceId, thread, limit) as Row[]
+  ).map(view);
+}
+
+// Sent within the window from one lead to another on a thread, for the
+// loop guard.
+export function sentSince(
+  workspaceId: string,
+  fromKind: LeadKind,
+  toKind: LeadKind,
+  thread: string,
+  sinceSqlite: string
+): number {
+  return (
+    db
+      .prepare(
+        `SELECT COUNT(*) AS n FROM lead_messages
+         WHERE workspace_id = ? AND from_kind = ? AND to_kind = ? AND thread = ?
+           AND created_at >= ?`
+      )
+      .get(workspaceId, fromKind, toKind, thread, sinceSqlite) as { n: number }
+  ).n;
+}

package/lib/leads/profiles.ts

@@ -0,0 +1,83 @@
+// What each kind of lead may do: one profile per kind, applied where the
+// orchestrator's tools are built (orchestrator/worker.ts) and enforced again
+// by the server on every call (./tools.ts). Tool bodies stay where they are.
+
+import type { Session } from "@/lib/db/types";
+import { TOOLS, type ToolName } from "../orchestrator/tool-schemas";
+import { isLeadRole, isTechRole } from "./roles";
+import type { LeadKind } from "./types";
+import { TECH } from "./types";
+
+// A lead's own tools, on top of the orchestrator's (./tools.ts).
+export const LEAD_TOOLS = ["update_memo", "propose_pin", "direction"] as const;
+export type LeadToolName = (typeof LEAD_TOOLS)[number];
+export const isLeadToolName = (t: unknown): t is LeadToolName =>
+  typeof t === "string" && (LEAD_TOOLS as readonly string[]).includes(t);
+
+// Only the Tech lead has these. Landing code is one head's job: reviews,
+// merges, arming, landing stacks and its own quick changes. So are the
+// machine (disk clean-up, moving tasks), the workspace's projects and tiers,
+// other workspaces, its standing rules, reminders and open questions, and
+// starting past the running-task limit.
+export const TECH_ONLY: ReadonlySet<ToolName> = new Set<ToolName>([
+  "review",
+  "sign_off",
+  "arm",
+  "disarm",
+  "land",
+  "done",
+  "quick_change",
+  "quick_pr",
+  "move",
+  "sweep_dry_run",
+  "sweep_arm",
+  "add_project",
+  "project_tier",
+  "orchestrators",
+  "message_orchestrator",
+  "rule_add",
+  "rule_remove",
+  "remind_me",
+  "reminders",
+  "cancel_reminder",
+  "question",
+  "resolve_question",
+  "start_now",
+  "recipe_save",
+  "recipe_update",
+]);
+
+export interface Profile {
+  kind: LeadKind;
+  tools: readonly ToolName[];
+  leadTools: readonly LeadToolName[];
+  // Starts and stops only inside its area (./area.ts).
+  inArea: boolean;
+}
+
+// A standing session's profile, or null for one that has none yet (the
+// chief, piece 7). The orchestrator of a workspace without leads keeps
+// exactly the tools it always had.
+export function profileFor(
+  s: Pick<Session, "role" | "lead_kind">,
+  workspaceHasLeads: boolean
+): Profile | null {
+  if (isTechRole(s.role))
+    return {
+      kind: TECH,
+      tools: TOOLS,
+      leadTools: workspaceHasLeads ? LEAD_TOOLS : [],
+      inArea: false,
+    };
+  if (!isLeadRole(s.role) || !s.lead_kind) return null;
+  return {
+    kind: s.lead_kind,
+    tools: TOOLS.filter((t) => !TECH_ONLY.has(t)),
+    leadTools: LEAD_TOOLS,
+    inArea: true,
+  };
+}
+
+export const profileHas = (p: Profile, tool: string): boolean =>
+  (p.tools as readonly string[]).includes(tool) ||
+  (p.leadTools as readonly string[]).includes(tool);

package/lib/leads/roles.ts

@@ -0,0 +1,114 @@
+import type { SessionRole } from "@/lib/db/types";
+import { TECH, type LeadKind } from "./types";
+
+// Client-safe: no database. Every check of `sessions.role` goes through one of
+// the decisions below (role-sites.test.ts fails on a raw one), and each
+// decision is a table over every role, so a new role can't be added without
+// deciding it everywhere.
+
+type RoleTable<T> = Readonly<Record<SessionRole | "none", T>>;
+
+const decide =
+  (t: RoleTable<boolean>) =>
+  (role: string | null | undefined): boolean =>
+    (t as Record<string, boolean>)[role ?? "none"] ?? false;
+
+// Every value `sessions.role` can hold. A standing session belongs to its
+// workspace and lives until its workspace goes: it is never swept as idle,
+// shown as done, archived, forked, moved or counted as a worker, and it
+// starts fresh rather than compacting.
+export const STANDING_ROLES = [
+  "orchestrator",
+  "lead",
+  "chief",
+] as const satisfies readonly SessionRole[];
+
+const STANDING: RoleTable<boolean> = {
+  none: false,
+  orchestrator: true,
+  lead: true,
+  chief: true,
+};
+
+// The workspace's orchestrator, which is its Tech lead: the one head that
+// lands code (sign-off, arming, merges), owns the workspace's own schedule
+// kind and is what "orchestrator" names on the bus. Also the orchestrator's
+// own machinery (its tools, brief and Needs-you bar) until a lead gets a
+// profile of its own.
+const TECH_ROLE: RoleTable<boolean> = {
+  none: false,
+  orchestrator: true,
+  lead: false,
+  chief: false,
+};
+
+// A department head: the orchestrator (Tech) or another lead.
+const LEAD: RoleTable<boolean> = {
+  none: false,
+  orchestrator: true,
+  lead: true,
+  chief: false,
+};
+
+export const ROLE_DECISIONS = {
+  standing: STANDING,
+  tech: TECH_ROLE,
+  lead: LEAD,
+} as const;
+
+export const isStandingRole = decide(STANDING) as (
+  role: string | null | undefined
+) => role is SessionRole;
+export const isTechRole = decide(TECH_ROLE);
+export const isLeadRole = decide(LEAD);
+
+const NOUN: RoleTable<string> = {
+  none: "session",
+  orchestrator: "orchestrator",
+  lead: "lead",
+  chief: "chief of staff",
+};
+
+// "orchestrator", "lead": for refusals that name what a session is.
+export const roleNoun = (role: string | null | undefined): string =>
+  (NOUN as Record<string, string>)[role ?? "none"] ?? NOUN.none;
+export const roleLabel = (role: string | null | undefined): string => {
+  const n = roleNoun(role);
+  return `${/^[aeiou]/.test(n) ? "an" : "a"} ${n}`;
+};
+export const RoleLabel = (role: string | null | undefined): string => {
+  const l = roleLabel(role);
+  return l[0].toUpperCase() + l.slice(1);
+};
+
+// The same decisions in SQL, for a column holding `sessions.role`. Every
+// role value is standing, so "no role" is the plain worker.
+const SQL_ROLES = STANDING_ROLES.map((r) => `'${r}'`).join(", ");
+export const sqlStanding = (col = "role") => `${col} IN (${SQL_ROLES})`;
+export const sqlNoRole = (col = "role") => `${col} IS NULL`;
+export const sqlTech = (col = "role") => `${col} = 'orchestrator'`;
+const SQL_LEADS = STANDING_ROLES.filter((r) => LEAD[r])
+  .map((r) => `'${r}'`)
+  .join(", ");
+export const sqlLead = (col = "role") => `${col} IN (${SQL_LEADS})`;
+
+// The department a standing session heads: the orchestrator is always Tech,
+// even before its workspace adds leads; the chief heads none.
+export function leadKindOf(s: {
+  role: string | null;
+  lead_kind?: string | null;
+}): LeadKind | null {
+  if (s.role === "orchestrator") return TECH;
+  if (s.role === "lead") return s.lead_kind ?? null;
+  return null;
+}
+
+const SLUG = /^[a-z][a-z0-9-]{0,31}$/;
+
+export const isLeadKind = (v: unknown): v is LeadKind =>
+  typeof v === "string" && SLUG.test(v);
+
+// A linked machine may run a newer AgentOS with roles this one doesn't know:
+// any role it reports is standing there.
+export const isPeerStanding = (role: unknown): boolean =>
+  typeof role === "string" ? role !== "" : role != null;

package/lib/leads/settings.ts

@@ -0,0 +1,55 @@
+import { db } from "@/lib/db";
+import type { ChiefAutonomy, WorkspaceLeads } from "./types";
+
+interface Row {
+  workspace_id: string;
+  enabled_at: string;
+  chief_autonomy: ChiefAutonomy;
+}
+
+const view = (r: Row): WorkspaceLeads => ({
+  workspaceId: r.workspace_id,
+  enabledAt: r.enabled_at,
+  chiefAutonomy: r.chief_autonomy,
+});
+
+// Whether "Add leads" ran on this workspace. The experiment switch alone
+// creates nothing; a workspace without this row is exactly as before.
+export function workspaceLeads(workspaceId: string): WorkspaceLeads | null {
+  const row = db
+    .prepare(`SELECT * FROM workspace_leads WHERE workspace_id = ?`)
+    .get(workspaceId) as Row | undefined;
+  return row ? view(row) : null;
+}
+
+export const hasLeads = (workspaceId: string | null | undefined): boolean =>
+  !!workspaceId && !!workspaceLeads(workspaceId);
+
+export function workspacesWithLeads(): WorkspaceLeads[] {
+  return (
+    db
+      .prepare(`SELECT * FROM workspace_leads ORDER BY enabled_at`)
+      .all() as Row[]
+  ).map(view);
+}
+
+export function markLeadsEnabled(workspaceId: string): WorkspaceLeads {
+  db.prepare(
+    `INSERT INTO workspace_leads (workspace_id) VALUES (?)
+     ON CONFLICT(workspace_id) DO NOTHING`
+  ).run(workspaceId);
+  return workspaceLeads(workspaceId)!;
+}
+
+export function setChiefAutonomy(
+  workspaceId: string,
+  autonomy: ChiefAutonomy
+): boolean {
+  return (
+    db
+      .prepare(
+        `UPDATE workspace_leads SET chief_autonomy = ? WHERE workspace_id = ?`
+      )
+      .run(autonomy, workspaceId).changes > 0
+  );
+}

package/lib/leads/templates.ts

@@ -0,0 +1,51 @@
+import { TECH, type LeadKind } from "./types";
+
+// The generic charters a new lead starts from. Real charters (a person's
+// own voice, market, house rules) are written into their own database
+// from Settings, never shipped here.
+export interface CharterTemplate {
+  title: string;
+  areaText: string;
+  charterMd: string;
+  goal: string;
+}
+
+const TEMPLATES: Record<string, CharterTemplate> = {
+  [TECH]: {
+    title: "Tech lead",
+    areaText:
+      "Every project in the workspace: tasks, reviews, merges and deploys.",
+    charterMd:
+      "You own how code lands: every task, review, merge and deploy goes through you and the gates. Other leads hand you code work; you decide how it is built and when it merges.",
+    goal: "Ship what the workspace needs, safely, through the gates.",
+  },
+  marketing: {
+    title: "Marketing lead",
+    areaText: "Content, pages, guides and the marketing board.",
+    charterMd:
+      "You own how the product is explained and found: pages, guides, posts and what's new. You draft; anything public waits for the owner's yes. Code changes go to the Tech lead.",
+    goal: "Steady, organic growth through useful content.",
+  },
+  product: {
+    title: "Product lead",
+    areaText: "What gets built next: the roadmap, cards and specs.",
+    charterMd:
+      "You own what gets built and why: you turn feedback and ideas into clear cards and specs, keep the roadmap ordered, and hand build work to the Tech lead. Product calls the owner hasn't made are asks.",
+    goal: "The next thing built is the most useful one.",
+  },
+};
+
+const titleCase = (kind: string) =>
+  kind
+    .split("-")
+    .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+    .join(" ");
+
+// A shipped kind's template, or a blank one titled after a custom kind.
+export const charterTemplate = (kind: LeadKind): CharterTemplate =>
+  TEMPLATES[kind] ?? {
+    title: `${titleCase(kind)} lead`,
+    areaText: "",
+    charterMd: "",
+    goal: "",
+  };