@hanzo/rooms 0.1.0

package/dist/contacts-store.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Unified contacts & social directory store for People, Custom Agents, and Pretrained Agents.
+ *
+ * WhatsApp-style Contacts architecture:
+ * - People (friends, teammates, colleagues)
+ * - Custom Agents (user-created AI personas)
+ * - Pretrained Agents (specialized ready-to-use Hanzo agents)
+ * - Conversation Threads (Group chats, Group calls, Direct messages)
+ *
+ * Critical requirement:
+ * Group chats and calls are created as conversation threads stored in the CHAT system,
+ * NOT inside the contacts roster.
+ */
+export interface ContactPerson {
+    id: string;
+    name: string;
+    email: string;
+    role?: string;
+    status?: string;
+    avatar?: string;
+    online?: boolean;
+    lastSeen?: string;
+}
+export interface ContactAgent {
+    id: string;
+    name: string;
+    model: string;
+    role: string;
+    description: string;
+    emoji?: string;
+    avatar?: string;
+    isPretrained?: boolean;
+    installed?: boolean;
+    capabilities?: string[];
+}
+export interface CustomThread {
+    id: string;
+    title: string;
+    type: 'direct' | 'group' | 'call';
+    participants: {
+        id: string;
+        name: string;
+        isAgent?: boolean;
+        avatar?: string;
+    }[];
+    updatedAt: number;
+    lastMessage?: string;
+    callActive?: boolean;
+}
+export declare const PRETRAINED_AGENTS: ContactAgent[];
+export declare const DEFAULT_PEOPLE: ContactPerson[];
+/** Read stored people, falling back to defaults */
+export declare function getStoredPeople(): ContactPerson[];
+/** Save updated people to storage */
+export declare function saveStoredPeople(people: ContactPerson[]): void;
+/**
+ * Read the agents this browser stored. NOTHING IS SEEDED: this used to write
+ * three invented agents into every new browser and the roster drew them as the
+ * org's own, so an org with no agents looked staffed. The org's agents come
+ * from /v1/agents; this is only what a reader added here.
+ */
+export declare function getStoredAgents(): ContactAgent[];
+/** Save updated custom agents to storage */
+export declare function saveStoredAgents(agents: ContactAgent[]): void;
+/** Read stored custom conversation threads (Group chats, Group calls, etc.) */
+export declare function getCustomThreads(): CustomThread[];
+/** Save updated conversation threads */
+export declare function saveCustomThreads(threads: CustomThread[]): void;
+/**
+ * Creates a new Group Chat thread and stores it in the CHAT system.
+ * Returns the created thread ID.
+ */
+export declare function createGroupChat(params: {
+    title: string;
+    participants: {
+        id: string;
+        name: string;
+        isAgent?: boolean;
+        avatar?: string;
+    }[];
+}): string;
+/**
+ * Creates a new Group Call thread and stores it in the CHAT system.
+ * Returns the created thread ID.
+ */
+export declare function createGroupCall(params: {
+    title: string;
+    participants: {
+        id: string;
+        name: string;
+        isAgent?: boolean;
+        avatar?: string;
+    }[];
+}): string;
+/**
+ * Creates or opens a 1-on-1 direct chat thread.
+ * Returns the thread ID.
+ */
+export declare function createDirectChat(target: {
+    id: string;
+    name: string;
+    isAgent?: boolean;
+    avatar?: string;
+}): string;
+/**
+ * The org's members, from IAM. `/v1/iam/account` names the caller's org and
+ * `/v1/iam/users?owner=<org>` lists who is in it; both answer for any member.
+ * What comes back replaces the stored roster, so the store is a cache of the
+ * platform and never a fixture.
+ */
+export declare function fetchOrgPeople(baseUrl: string, token: string): Promise<ContactPerson[]>;

package/dist/contacts-store.js

@@ -0,0 +1,276 @@
+'use client';
+import { scope } from './lib/session.js';
+// Pretrained Agents catalog
+export const PRETRAINED_AGENTS = [
+    {
+        id: 'pretrained-coder',
+        name: 'Hanzo Coder',
+        model: 'enso',
+        role: 'Full-Stack Software Engineer',
+        description: 'Autonomous code generation, debugging, refactoring, PR reviews, and Git operations.',
+        avatar: '/agents/dev.png',
+        emoji: '💻',
+        isPretrained: true,
+        installed: true,
+        capabilities: ['TypeScript & Next.js', 'Go & Rust', 'Bug Fixing & Testing', 'Architecture Review'],
+    },
+    {
+        id: 'pretrained-researcher',
+        name: 'Hanzo Researcher',
+        model: 'claude-3-5-sonnet',
+        role: 'Deep Intelligence & Research Specialist',
+        description: 'Deep web search, arXiv paper extraction, competitive intelligence, and synthesis.',
+        emoji: '🔬',
+        isPretrained: true,
+        installed: true,
+        capabilities: ['Academic Paper Extraction', 'Market Research', 'Data Synthesis', 'Web Fact-Checking'],
+    },
+    {
+        id: 'pretrained-designer',
+        name: 'Hanzo Designer',
+        model: 'gpt-4o',
+        role: 'UI/UX & Design Systems Architect',
+        description: 'Modern component design, responsive Tailwind/CSS layouts, Figma token synchronization.',
+        avatar: '/agents/des.png',
+        emoji: '🎨',
+        isPretrained: true,
+        installed: true,
+        capabilities: ['Figma to React', 'Design Systems', 'Micro-Interactions', 'Dark Mode Theming'],
+    },
+    {
+        id: 'pretrained-quant',
+        name: 'Hanzo Quant',
+        model: 'deepseek-r1',
+        role: 'Quantitative Finance & Market Analyst',
+        description: 'Market data analysis, predictive financial modeling, risk calculations, and algorithmic strategies.',
+        avatar: '/agents/zach.jpg',
+        emoji: '📈',
+        isPretrained: true,
+        installed: false,
+        capabilities: ['Financial Modeling', 'Risk Assessment', 'Statistical Arbitrage', 'Portfolio Analysis'],
+    },
+    {
+        id: 'pretrained-copywriter',
+        name: 'Hanzo Copywriter',
+        model: 'llama-3.3',
+        role: 'Technical Writer & Content Strategist',
+        description: 'High-impact technical documentation, release notes, developer blogs, and launch copy.',
+        avatar: '/agents/creative.png',
+        emoji: '✍️',
+        isPretrained: true,
+        installed: false,
+        capabilities: ['API Documentation', 'Launch Announcements', 'SEO Optimization', 'Whitepapers'],
+    },
+    {
+        id: 'pretrained-devops',
+        name: 'Hanzo DevOps',
+        model: 'enso',
+        role: 'Cloud Infrastructure & SRE Specialist',
+        description: 'Kubernetes orchestration, Docker build pipelines, CI/CD automation, and incident mitigation.',
+        avatar: '/agents/vi.png',
+        emoji: '⚙️',
+        isPretrained: true,
+        installed: false,
+        capabilities: ['Kubernetes & Helm', 'GitHub Actions', 'GCP & AWS Cloud', 'Docker Containerization'],
+    },
+    {
+        id: 'pretrained-legal',
+        name: 'Hanzo Legal & Compliance',
+        model: 'enso',
+        role: 'Commercial Legal & IP Counsel',
+        description: 'Commercial contract review, NDAs, SaaS service agreements, GDPR compliance, and IP protection.',
+        avatar: '/agents/einstein.png',
+        emoji: '🛡️',
+        isPretrained: true,
+        installed: false,
+        capabilities: ['Contract Review', 'SaaS Master Agreements', 'Privacy & GDPR', 'IP Licensing'],
+    },
+    {
+        id: 'pretrained-assistant',
+        name: 'Hanzo Executive Assistant',
+        model: 'gpt-4o',
+        role: 'Operations & Executive Coordinator',
+        description: 'Daily briefing generation, task prioritization, agenda prep, and team communication sync.',
+        avatar: '/agents/maya.png',
+        emoji: '👔',
+        isPretrained: true,
+        installed: false,
+        capabilities: ['Meeting Agendas', 'Executive Briefings', 'Email Drafts', 'Task Prioritization'],
+    },
+];
+// The roster is the org's own members, read from IAM. Nothing is invented for
+// an org that has none yet: an empty roster reads empty.
+export const DEFAULT_PEOPLE = [];
+const PEOPLE_STORAGE_KEY = 'hanzo_contacts_people_v1';
+const AGENTS_STORAGE_KEY = 'hanzo_contacts_agents_v1';
+const THREADS_STORAGE_KEY = 'hanzo_custom_threads_v1';
+/** Read stored people, falling back to defaults */
+export function getStoredPeople() {
+    if (typeof window === 'undefined')
+        return DEFAULT_PEOPLE;
+    try {
+        const raw = localStorage.getItem(PEOPLE_STORAGE_KEY);
+        if (!raw)
+            return DEFAULT_PEOPLE;
+        return JSON.parse(raw);
+    }
+    catch {
+        return DEFAULT_PEOPLE;
+    }
+}
+/** Save updated people to storage */
+export function saveStoredPeople(people) {
+    if (typeof window === 'undefined')
+        return;
+    try {
+        localStorage.setItem(PEOPLE_STORAGE_KEY, JSON.stringify(people));
+        window.dispatchEvent(new Event('hanzo_contacts_changed'));
+    }
+    catch (err) {
+        console.warn('Failed to save contacts:', err);
+    }
+}
+/**
+ * Read the agents this browser stored. NOTHING IS SEEDED: this used to write
+ * three invented agents into every new browser and the roster drew them as the
+ * org's own, so an org with no agents looked staffed. The org's agents come
+ * from /v1/agents; this is only what a reader added here.
+ */
+export function getStoredAgents() {
+    if (typeof window === 'undefined')
+        return [];
+    try {
+        const raw = localStorage.getItem(AGENTS_STORAGE_KEY);
+        return raw ? JSON.parse(raw) : [];
+    }
+    catch {
+        return [];
+    }
+}
+/** Save updated custom agents to storage */
+export function saveStoredAgents(agents) {
+    if (typeof window === 'undefined')
+        return;
+    try {
+        localStorage.setItem(AGENTS_STORAGE_KEY, JSON.stringify(agents));
+        window.dispatchEvent(new Event('hanzo_agents_changed'));
+    }
+    catch (err) {
+        console.warn('Failed to save agents:', err);
+    }
+}
+/** Read stored custom conversation threads (Group chats, Group calls, etc.) */
+export function getCustomThreads() {
+    if (typeof window === 'undefined')
+        return [];
+    try {
+        const raw = localStorage.getItem(THREADS_STORAGE_KEY);
+        if (!raw)
+            return [];
+        return JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+}
+/** Save updated conversation threads */
+export function saveCustomThreads(threads) {
+    if (typeof window === 'undefined')
+        return;
+    try {
+        localStorage.setItem(THREADS_STORAGE_KEY, JSON.stringify(threads));
+        window.dispatchEvent(new Event('hanzo_threads_changed'));
+    }
+    catch (err) {
+        console.warn('Failed to save threads:', err);
+    }
+}
+/**
+ * Creates a new Group Chat thread and stores it in the CHAT system.
+ * Returns the created thread ID.
+ */
+export function createGroupChat(params) {
+    const threadId = `group_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`;
+    const newThread = {
+        id: threadId,
+        title: params.title || `Group (${params.participants.length})`,
+        type: 'group',
+        participants: params.participants,
+        updatedAt: Date.now(),
+        lastMessage: `Group created with ${params.participants.map((p) => p.name).join(', ')}`,
+    };
+    const existing = getCustomThreads();
+    saveCustomThreads([newThread, ...existing]);
+    return threadId;
+}
+/**
+ * Creates a new Group Call thread and stores it in the CHAT system.
+ * Returns the created thread ID.
+ */
+export function createGroupCall(params) {
+    const threadId = `call_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`;
+    const newThread = {
+        id: threadId,
+        title: params.title ? `Group Call: ${params.title}` : `Group Call (${params.participants.length})`,
+        type: 'call',
+        participants: params.participants,
+        updatedAt: Date.now(),
+        lastMessage: `Started group call with ${params.participants.map((p) => p.name).join(', ')}`,
+        callActive: true,
+    };
+    const existing = getCustomThreads();
+    saveCustomThreads([newThread, ...existing]);
+    return threadId;
+}
+/**
+ * Creates or opens a 1-on-1 direct chat thread.
+ * Returns the thread ID.
+ */
+export function createDirectChat(target) {
+    const existing = getCustomThreads();
+    const found = existing.find((t) => t.type === 'direct' && t.participants.some((p) => p.id === target.id));
+    if (found)
+        return found.id;
+    const threadId = `direct_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`;
+    const newThread = {
+        id: threadId,
+        title: target.name,
+        type: 'direct',
+        participants: [target],
+        updatedAt: Date.now(),
+        lastMessage: `Conversation opened with ${target.name}`,
+    };
+    saveCustomThreads([newThread, ...existing]);
+    return threadId;
+}
+/**
+ * The org's members, from IAM. `/v1/iam/account` names the caller's org and
+ * `/v1/iam/users?owner=<org>` lists who is in it; both answer for any member.
+ * What comes back replaces the stored roster, so the store is a cache of the
+ * platform and never a fixture.
+ */
+export async function fetchOrgPeople(baseUrl, token) {
+    const headers = { ...scope(), Authorization: `Bearer ${token}` };
+    const me = (await (await fetch(`${baseUrl}/v1/iam/account`, { headers })).json());
+    const org = me?.owner;
+    if (!org)
+        return getStoredPeople();
+    const res = await fetch(`${baseUrl}/v1/iam/users?owner=${encodeURIComponent(org)}`, { headers });
+    if (!res.ok)
+        return getStoredPeople();
+    const body = (await res.json());
+    const rows = (Array.isArray(body) ? body : body?.data) ?? [];
+    const people = rows
+        .filter((u) => typeof u.name === 'string')
+        .map((u) => ({
+        id: `${u.owner}/${u.name}`,
+        name: u.displayName || u.name,
+        email: u.email || '',
+        role: u.isAdmin ? 'Admin' : undefined,
+        avatar: u.avatar || undefined,
+        online: Boolean(u.isOnline),
+    }));
+    if (people.length)
+        saveStoredPeople(people);
+    return people;
+}

package/dist/conversations.d.ts

@@ -0,0 +1,54 @@
+import { useInbox } from '@hanzo/ai/react';
+import type { AiClient, Thread } from '@hanzo/ai';
+import type { Member } from './roster.js';
+/** An arrival room, as `@hanzo/ai` groups one. Named so this file can speak of
+ *  it without every caller importing the hook's return type. */
+type Arrival = ReturnType<typeof useInbox>['rooms'][number];
+/** One conversation another network carries. */
+export interface Conversation {
+    key: string;
+    /** What to call it in a list. */
+    title: string;
+    /** The network it arrived on. */
+    channel: string;
+    /** Unix MILLIseconds of the last thing said. The arrival plane stamps
+     *  SECONDS, and this is the one place that is reconciled. */
+    lastAt: number;
+    /** The last thing said, on one line. */
+    preview: string;
+    arrival: Arrival;
+}
+/** The key for an arrival. `useInbox` already keys a room; this qualifies it. */
+export declare const netKey: (arrival: Arrival) => string;
+/**
+ * Every conversation this reader has been sent, newest first.
+ *
+ * The read already runs in this workspace; this shapes it rather than fetching
+ * anything of its own, so the list costs no request that was not already made.
+ */
+export declare function useConversations(): {
+    conversations: Conversation[];
+    loading: boolean;
+    reload: () => void;
+};
+/** The conversation with that key, or null for none open. */
+export declare function conversationOf(all: Conversation[], key: string | null): Conversation | null;
+export declare const opening: (members: Member[]) => string;
+/**
+ * Writes the room and answers its id.
+ *
+ * The agents in it go in AHEAD of the opening line as the roster turn
+ * (cast.tsx `roster`), which is how a conversation keeps who is in it: /chat
+ * seats that room when the thread opens and reads each agent's brief fresh.
+ * One agent, several, people, or a mix: all open by this one call.
+ */
+export declare function start(ai: AiClient, members: Member[]): Promise<string>;
+/**
+ * When a conversation last named them, in unix milliseconds, or 0 for never.
+ *
+ * The title is the only place a member is written down, so this is what
+ * "recently" can honestly mean about a contact. The day a thread carries its
+ * members, this reads them instead.
+ */
+export declare function spokenAt(threads: Thread[], label: string): number;
+export {};

package/dist/conversations.js

@@ -0,0 +1,98 @@
+'use client';
+// WHAT ARRIVED, IN ONE LIST.
+//
+// The messages other networks carry in (`/v1/channels/inbox`, read by
+// `@hanzo/ai`'s `useInbox`), as the Inbox lists them. A room of this platform
+// is not an arrival: it is a place the org talks in, read and answered on
+// /home (`rooms.ts`), and each kind keeps its own reader because a thread you
+// REPLY to and a room you POST into are not the same act.
+//
+// `key` is the ONE id the workspace selects by, and it names its own source:
+// `net:<channel> <roomId>` here, `team:<space>/<id>` for a room. Prefixed
+// rather than hashed, because a key a person can read in a URL is one they can
+// report in a bug, and a lookup that misses is a bug rather than a category.
+import { useMemo } from 'react';
+import { useInbox } from '@hanzo/ai/react';
+import { roster } from './cast.js';
+/** What to call a member in a room. The roster carries one name; this is it. */
+const label = (m) => m.name;
+/** "Ada", "Ada and Mel", "Ada, Mel and Sam". */
+const named = (names) => names.length <= 1
+    ? (names[0] ?? '')
+    : `${names.slice(0, -1).join(', ')} and ${names[names.length - 1]}`;
+/** The key for an arrival. `useInbox` already keys a room; this qualifies it. */
+export const netKey = (arrival) => `net:${arrival.key}`;
+/**
+ * Every conversation this reader has been sent, newest first.
+ *
+ * The read already runs in this workspace; this shapes it rather than fetching
+ * anything of its own, so the list costs no request that was not already made.
+ */
+export function useConversations() {
+    const { rooms: arrivals, loading, reload } = useInbox({ limit: 100 });
+    const conversations = useMemo(() => arrivals
+        .map((arrival) => ({
+        key: netKey(arrival),
+        // The handle we hold, which is the only thing that tells two senders
+        // on one network apart. See Inbox's `speaker`.
+        title: arrival.last.sender ? `@${arrival.last.sender}` : arrival.channel,
+        channel: arrival.channel,
+        lastAt: arrival.lastAt * 1000,
+        preview: arrival.last.text,
+        arrival,
+    }))
+        // Newest first, then by title, so two identical reads order the same.
+        .sort((a, b) => b.lastAt - a.lastAt || a.title.localeCompare(b.title)), [arrivals]);
+    return { conversations, loading, reload };
+}
+/** The conversation with that key, or null for none open. */
+export function conversationOf(all, key) {
+    return key ? (all.find((one) => one.key === key) ?? null) : null;
+}
+// ── Starting one, and when one last named someone ──────────────────────────
+//
+// These came across the rewrite of how rooms are READ, because they are not
+// about reading: `start` opens a conversation with people the directory picked,
+// and `spokenAt` says when one last named a person, which is how the directory
+// sorts. `Member` belongs to the roster now, so they take it from there.
+export const opening = (members) => `With ${named(members.map(label))}`;
+/**
+ * Writes the room and answers its id.
+ *
+ * The agents in it go in AHEAD of the opening line as the roster turn
+ * (cast.tsx `roster`), which is how a conversation keeps who is in it: /chat
+ * seats that room when the thread opens and reads each agent's brief fresh.
+ * One agent, several, people, or a mix: all open by this one call.
+ */
+export async function start(ai, members) {
+    if (members.length === 0)
+        throw new Error('A conversation needs somebody in it.');
+    const agents = members.filter((one) => one.agent).map((one) => one.name);
+    const id = await ai.threads.record([
+        ...(agents.length ? [{ role: 'system', content: roster(agents) }] : []),
+        { role: 'user', content: opening(members) },
+    ]);
+    // `record` answers "" where the body carried no id, which is a write that did
+    // not happen — never a room to open.
+    if (!id)
+        throw new Error('The conversation store answered without an id.');
+    return id;
+}
+/**
+ * When a conversation last named them, in unix milliseconds, or 0 for never.
+ *
+ * The title is the only place a member is written down, so this is what
+ * "recently" can honestly mean about a contact. The day a thread carries its
+ * members, this reads them instead.
+ */
+export function spokenAt(threads, label) {
+    let last = 0;
+    for (const one of threads) {
+        if (!one.title?.includes(label))
+            continue;
+        const at = one.updatedAt ? new Date(one.updatedAt).getTime() : 0;
+        if (at > last)
+            last = at;
+    }
+    return last;
+}

package/dist/copy.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Take something away with you.
+ *
+ * It copies the TEXT IT IS GIVEN, which for a message is the source rather than
+ * what is on screen: an answer is markdown — fences, lists, a table — and the
+ * rendered text has thrown all of that away, so pasting it into an editor gives
+ * you the words with the shape stripped off. The bytes the model wrote are the
+ * ones worth having.
+ *
+ * ALWAYS PRESENT, not hover-only. A control that exists only under a pointer is
+ * one a keyboard and a thumb cannot reach; this one rests dim and comes up on
+ * hover or focus, so it is quiet without being conditional. Given a `label` it
+ * stops resting — a word in a row of controls is not decoration and is read at
+ * full weight.
+ */
+export declare function Take({ text, says, label, }: {
+    /** What lands on the clipboard. */
+    text: string;
+    /** What it is, for the reader who hears the control rather than sees it. */
+    says?: string;
+    /** A word beside the glyph, where the control sits among named ones. */
+    label?: string;
+}): import("react").JSX.Element;

package/dist/copy.js

@@ -0,0 +1,39 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// Copying something out of the app, in one control.
+//
+// Two places want it and they want the same thing: an answer you are taking
+// into an editor, and the address of a site you are sending to somebody. So the
+// glyph, the tick, and how long the tick stays are decided here rather than
+// twice — a control that confirms for 1400ms in one pane and 800ms in another
+// reads as two different controls doing two different things.
+import { useEffect, useState } from 'react';
+import { Check, Copy } from 'lucide-react';
+import { Box, Text, XStack } from '@hanzo/ui';
+/**
+ * Take something away with you.
+ *
+ * It copies the TEXT IT IS GIVEN, which for a message is the source rather than
+ * what is on screen: an answer is markdown — fences, lists, a table — and the
+ * rendered text has thrown all of that away, so pasting it into an editor gives
+ * you the words with the shape stripped off. The bytes the model wrote are the
+ * ones worth having.
+ *
+ * ALWAYS PRESENT, not hover-only. A control that exists only under a pointer is
+ * one a keyboard and a thumb cannot reach; this one rests dim and comes up on
+ * hover or focus, so it is quiet without being conditional. Given a `label` it
+ * stops resting — a word in a row of controls is not decoration and is read at
+ * full weight.
+ */
+export function Take({ text, says = 'this', label, }) {
+    const [took, setTook] = useState(false);
+    useEffect(() => {
+        if (!took)
+            return;
+        const t = setTimeout(() => setTook(false), 1400);
+        return () => clearTimeout(t);
+    }, [took]);
+    return (_jsx(Box, { render: "button", onClick: () => {
+            void navigator.clipboard?.writeText(text).then(() => setTook(true)).catch(() => { });
+        }, "aria-label": took ? 'Copied' : `Copy ${says}`, borderWidth: 0, bg: "transparent", p: "$1", rounded: "$2", opacity: label || took ? 1 : 0.35, hoverStyle: { opacity: 1, bg: '$hover' }, focusStyle: { opacity: 1 }, children: _jsxs(XStack, { items: "center", gap: "$1", children: [took ? _jsx(Check, { size: 13, "aria-hidden": true }) : _jsx(Copy, { size: 13, "aria-hidden": true }), label ? (_jsx(Text, { fontSize: "$2", color: "$ink", children: took ? 'Copied' : label })) : null] }) }));
+}

package/dist/crew.d.ts

@@ -0,0 +1,36 @@
+import { useAgents } from '@hanzo/ai/react';
+/**
+ * The org's agents, read again whenever the sheet makes one. `useAgents` holds
+ * one list per caller, so the strip, the chat header and the sheet each hold
+ * their own; the event is how a new agent reaches every one of them.
+ */
+export declare function useCrew(): ReturnType<typeof useAgents>;
+/** The house crew's names, which a reply may be split by even after one has left the room. */
+export declare const HOUSE: readonly string[];
+/**
+ * `to` is the chat a press opens, for a strip on a page that is not one. Absent,
+ * the strip sits under a chat and a press changes who is in it.
+ */
+export declare function Crew({ to }?: {
+    to?: string;
+}): import("react").JSX.Element;
+/**
+ * The sheet that makes an agent.
+ *
+ * A name, a mind and a spending limit are what the agents API requires; what it
+ * does becomes its instructions; the likeness is whichever the maker gives — a
+ * photo uploaded onto the round picture (pressed, or dropped on), or a face
+ * described and drawn by the image model. Both go through `mark`, the one crop
+ * every saved face takes, so a drawn face and an uploaded one are the same kind
+ * of picture. The row keeps at most one of a picture and an emoji, so choosing
+ * one clears the other here too.
+ *
+ * Create stays off until the required fields are filled in the API's own
+ * terms, and a refusal is said in plain words under the field it concerns.
+ *
+ * EXPORTED, because Contacts adds agents too and there is one way to make one.
+ */
+export declare function Hire({ onClose, onMade }: {
+    onClose: () => void;
+    onMade: (name: string) => void;
+}): import("react").JSX.Element;