@joe-broadhead/messaging-bin-linux-arm64-gnu 0.2.0 → 0.3.0

package/lib/messagingd.mjs

@@ -6118,6 +6118,8 @@ var init_common = __esm(() => {
     delegation: `messaging/1/delegation
 `,
     grant: `messaging/1/grant
+`,
+    card: `messaging/1/card
 `,
     seal: "messaging/1/seal",
     directAuth: `messaging/1/direct-auth
@@ -6210,6 +6212,7 @@ var init_common = __esm(() => {
     deletionPollMs: 6 * 60 * 60 * 1000,
     dormantDays: 180,
     requestsPerDay: 20,
+    requestChars: 500,
     unsolicitedPerPairPerDay: 20,
     unsolicitedTargetsPerDay: 50,
     dirLookupPersons: 64,
@@ -6225,6 +6228,7 @@ var init_common = __esm(() => {
     trustDefaultMs: 30 * 24 * 60 * 60 * 1000,
     trustMaxMs: 90 * 24 * 60 * 60 * 1000,
     grantBytes: 2048,
+    cardBytes: 2048,
     grantsPerPerson: 5000,
     heldPerSender: 20,
     heldTotal: 200,
@@ -6688,7 +6692,14 @@ function grantProblem(grant) {
     return "resignedAt is before ts";
   return;
 }
-var ChatLevel, AgentMailLevel, AskLevel, GrantSubject, ConsentGrant, GRANTS_PER_SYNC = 100, GrantSync;
+function cardProblem(card) {
+  if (card.from === card.to)
+    return "a card is about another person";
+  if (card.can.trustedUntil !== undefined && card.can.ask !== "open")
+    return "trustedUntil needs ask open";
+  return;
+}
+var ChatLevel, AgentMailLevel, AskLevel, GrantSubject, ConsentGrant, GRANTS_PER_SYNC = 100, GrantSync, CardCan, ContactCard, CardData, CardGetData;
 var init_consent = __esm(() => {
   init_zod();
   init_common();
@@ -6718,6 +6729,30 @@ var init_consent = __esm(() => {
       ctx.addIssue({ code: "custom", message: problem });
   });
   GrantSync = strictObject({ grants: array(record(string2(), unknown())).min(1).max(GRANTS_PER_SYNC) });
+  CardCan = strictObject({
+    chat: boolean2(),
+    agentMail: boolean2(),
+    ask: AskLevel,
+    trustedUntil: Millis.optional()
+  });
+  ContactCard = object({
+    v: literal(PROTOCOL),
+    realm: RealmId,
+    from: PersonId,
+    to: PersonId,
+    by: MachineId,
+    seq: number2().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+    ts: Millis,
+    grantId: Ulid.optional(),
+    can: CardCan,
+    sig: Base64Url
+  }).superRefine((card, ctx) => {
+    const problem = cardProblem(card);
+    if (problem)
+      ctx.addIssue({ code: "custom", message: problem });
+  });
+  CardData = strictObject({ card: record(string2(), unknown()) });
+  CardGetData = strictObject({ get: literal(true) });
 });
 
 // packages/core/dist/schema/delegation.js
@@ -6754,7 +6789,14 @@ var init_delegation = __esm(() => {
 });
 
 // packages/core/dist/schema/envelope.js
-var EnvelopeType, SEAL_ALG = "x25519-hkdf-sha256-a256gcm", EnvelopeClass, Party, Sender, Recipient, Envelope, ChannelPersons, ChannelConv, SelfConv, Conv, MessagePayload, TaskStatusPayload, TaskArtifactPayload, TaskCancelPayload, ReceiptPayload, SessionInfo, DirectEndpoint, PresencePayload, PAYLOAD_BY_TYPE, Provenance;
+function requestMessage(message) {
+  const text = message.parts[0]?.text;
+  return bare(message, "text") && typeof text === "string" && text.length >= 1 && text.length <= LIMITS.requestChars;
+}
+function cardMessage(message, what) {
+  return bare(message, "data") && (what === "card" ? CardData : CardGetData).safeParse(message.parts[0].data).success;
+}
+var EnvelopeType, SEAL_ALG = "x25519-hkdf-sha256-a256gcm", EnvelopeClass, Party, Sender, Recipient, Envelope, ChannelPersons, ChannelConv, SelfConv, RequestConv, CardConv, Conv, MessagePayload, BARE_MESSAGE, bare = (message, part) => Object.keys(message).every((key) => BARE_MESSAGE.has(key)) && message.parts.length === 1 && Object.keys(message.parts[0]).join() === part, TaskStatusPayload, TaskArtifactPayload, TaskCancelPayload, ReceiptPayload, SessionInfo, DirectEndpoint, PresencePayload, PAYLOAD_BY_TYPE, Provenance;
 var init_envelope = __esm(() => {
   init_zod();
   init_a2a();
@@ -6764,7 +6806,7 @@ var init_envelope = __esm(() => {
   init_errors3();
   init_realm();
   EnvelopeType = _enum(["message", "task.status", "task.artifact", "task.cancel", "receipt", "presence"]);
-  EnvelopeClass = _enum(["self", "contact"]);
+  EnvelopeClass = _enum(["self", "contact", "request"]);
   Party = object({
     person: PersonId,
     device: MachineId,
@@ -6802,7 +6844,9 @@ var init_envelope = __esm(() => {
     object({ kind: literal("channel"), op: literal("post"), id: Ulid, name: ChannelName })
   ]);
   SelfConv = object({ kind: literal("self"), what: _enum(["grant", "snapshot"]) });
-  Conv = discriminatedUnion("kind", [ChannelConv, SelfConv]);
+  RequestConv = object({ kind: literal("request") });
+  CardConv = object({ kind: literal("card"), what: _enum(["card", "get"]) });
+  Conv = discriminatedUnion("kind", [ChannelConv, SelfConv, RequestConv, CardConv]);
   MessagePayload = object({
     kind: _enum(["message", "task"]),
     message: Message,
@@ -6812,9 +6856,14 @@ var init_envelope = __esm(() => {
     conv: Conv.optional()
   }).refine((p) => p.kind === "task" ? p.message.taskId !== undefined : true, { message: "a task message needs message.taskId" }).refine((p) => p.kind === "task" === (p.delegation !== undefined), { message: "a task request carries a delegation chain, and only a task request" }).refine((p) => p.conv?.kind !== "self" || p.message.parts.length === 1 && GrantSync.safeParse(p.message.parts[0].data).success, {
     message: "a self sync message carries exactly one data part with its grants"
+  }).refine((p) => p.conv?.kind !== "request" || requestMessage(p.message), {
+    message: `a message request carries one text part of 1 to ${LIMITS.requestChars} characters, and nothing else`
+  }).refine((p) => p.conv?.kind !== "card" || cardMessage(p.message, p.conv.what), {
+    message: "a card message carries one data part, the card or the request for one, and nothing else"
   }).refine((p) => p.message.taskId === undefined || Ulid.safeParse(p.message.taskId).success, {
     message: "Messaging task ids are ULIDs"
   });
+  BARE_MESSAGE = new Set(["messageId", "role", "parts"]);
   TaskStatusPayload = TaskStatusUpdateEvent;
   TaskArtifactPayload = TaskArtifactUpdateEvent;
   TaskCancelPayload = object({
@@ -7304,7 +7353,7 @@ var init_shapes = __esm(() => {
     direction: _enum(["in", "out"]),
     body: ChatText,
     thread: Ulid.optional(),
-    state: _enum(["sent", "delivered", "refused"]).optional(),
+    state: _enum(["sent", "held", "delivered", "refused"]).optional(),
     refused: array(PersonId).max(LIMITS.channelPersons).optional(),
     notice: literal(true).optional()
   });
@@ -7375,6 +7424,95 @@ var init_shapes = __esm(() => {
   });
 });
 
+// packages/core/dist/schema/ipc/consent.js
+var GrantTarget, Levels, GrantView, GrantReview, GrantSetParams, AskRequest, ContactRequestView, ContactSuggestion, HeldRequest, RequestAnswer, RequestText, PersonReach, CONSENT_METHODS;
+var init_consent2 = __esm(() => {
+  init_zod();
+  init_common();
+  init_consent();
+  init_directory_frames();
+  GrantTarget = union([strictObject({ person: PersonId }), strictObject({ channel: ChannelName })]);
+  Levels = {
+    chat: ChatLevel.optional(),
+    agentMail: AgentMailLevel.optional(),
+    ask: AskLevel.optional(),
+    trustedUntil: Millis.optional(),
+    discoverable: boolean2().optional()
+  };
+  GrantView = object({
+    subject: union([object({ person: PersonId }), object({ channel: Ulid, name: ChannelName.optional() })]),
+    ...Levels,
+    id: Ulid,
+    ts: Millis,
+    by: MachineId,
+    resignedAt: Millis.optional()
+  });
+  GrantReview = object({
+    subject: GrantView.shape.subject,
+    chat: literal("open").optional(),
+    agentMail: literal("open").optional(),
+    ask: _enum(["open", "request"]).optional(),
+    trustedUntil: Millis.optional(),
+    discoverable: literal(true).optional(),
+    at: Millis
+  });
+  GrantSetParams = strictObject({ subject: GrantTarget, ...Levels, trust: literal(true).optional() });
+  AskRequest = object({
+    id: Ulid,
+    kind: _enum(["message", "task"]),
+    from: object({ person: PersonId, device: MachineId, label: MachineLabel, agent: SessionName, address: SessionAddress }),
+    to: SessionName,
+    preview: string2().max(LIMITS.previewChars),
+    at: Millis,
+    exp: Millis
+  });
+  ContactRequestView = object({
+    id: Ulid,
+    kind: literal("contact"),
+    from: object({
+      person: PersonId,
+      device: MachineId,
+      label: MachineLabel,
+      name: string2().max(200),
+      email: string2().max(320).optional(),
+      org: _enum(["same", "other", "none"])
+    }),
+    text: string2().max(LIMITS.requestChars),
+    at: Millis,
+    exp: Millis
+  });
+  ContactSuggestion = object({
+    id: Ulid,
+    kind: literal("suggestion"),
+    agent: SessionName,
+    email: Email,
+    at: Millis
+  });
+  HeldRequest = union([AskRequest, ContactRequestView, ContactSuggestion]);
+  RequestAnswer = _enum(["once", "always", "accept", "decline", "block"]);
+  RequestText = string2().min(1).refine((text) => text.length <= LIMITS.requestChars, { message: `at most ${LIMITS.requestChars} UTF-16 code units` });
+  PersonReach = object({ person: PersonId, can: CardCan, source: _enum(["card", "default"]), at: Millis.optional() });
+  CONSENT_METHODS = {
+    "grant.list": {
+      params: strictObject({ subject: GrantTarget.optional() }),
+      result: object({ grants: array(GrantView), review: array(GrantReview) })
+    },
+    "grant.set": { params: GrantSetParams, result: object({ grant: GrantView }) },
+    "grant.set.preview": { params: GrantSetParams, result: object({ sentence: string2().max(500) }) },
+    "request.list": { params: strictObject({}), result: object({ requests: array(HeldRequest).max(LIMITS.heldTotal * 3) }) },
+    "request.answer": {
+      params: strictObject({ id: Ulid, answer: RequestAnswer, all: boolean2().optional() }),
+      result: object({ answered: array(Ulid).max(LIMITS.heldTotal) })
+    },
+    "contact.request": {
+      params: strictObject({ email: Email, text: RequestText, suggestion: Ulid.optional() }),
+      result: object({ id: Ulid, conversation: RoomRef, person: PersonId })
+    },
+    "contact.request.preview": { params: strictObject({ email: Email }), result: object({ found: boolean2() }) },
+    "card.get": { params: strictObject({ person: PersonId }), result: object({ sent: boolean2() }) }
+  };
+});
+
 // packages/core/dist/schema/ipc/surfaces.js
 var METADATA_BYTES = 16384, ConversationRef, ConvPlace, ConvSummary, PersonSummary, SURFACE_METHODS;
 var init_surfaces = __esm(() => {
@@ -7382,7 +7520,9 @@ var init_surfaces = __esm(() => {
   init_a2a();
   init_common();
   init_delegation();
+  init_directory_frames();
   init_errors3();
+  init_consent2();
   init_shapes();
   ConversationRef = string2().regex(/^(?:dm:(?:[a-z][a-z0-9-]{0,31}|p_[a-z2-7]{26})|channel:[a-z][a-z0-9-]{0,31}|agent:(?:[a-z][a-z0-9-]{0,31}|p_[a-z2-7]{26})\/[a-z0-9][a-z0-9._-]{0,63})$/, "dm:<person>, channel:<name> or agent:<person>/<agent>");
   ConvPlace = union([ChatSeq, ConvCursor]);
@@ -7405,7 +7545,7 @@ var init_surfaces = __esm(() => {
   SURFACE_METHODS = {
     "contacts.list": {
       params: strictObject({ person: PersonId.optional(), includeOffline: boolean2().optional() }),
-      result: object({ entries: array(DirectoryEntry), conversations: array(ConvSummary) })
+      result: object({ entries: array(DirectoryEntry), conversations: array(ConvSummary), reach: array(PersonReach) })
     },
     "msg.send": {
       params: strictObject({
@@ -7422,6 +7562,7 @@ var init_surfaces = __esm(() => {
         extensions: array(string2().min(1).max(256)).max(16).optional(),
         referenceTaskIds: array(Ulid).max(16).optional(),
         wake: boolean2().optional().describe("hint that the recipient may wake an idle session; default true"),
+        request: strictObject({ contact: Email }).optional(),
         external: strictObject({ principal: string2().min(1).max(64) }).optional(),
         onBehalfOf: strictObject({
           taskId: Ulid.describe("a task this session executes"),
@@ -7491,63 +7632,6 @@ var init_surfaces = __esm(() => {
   };
 });
 
-// packages/core/dist/schema/ipc/consent.js
-var GrantTarget, Levels, GrantView, GrantReview, GrantSetParams, HeldRequest, RequestAnswer, CONSENT_METHODS;
-var init_consent2 = __esm(() => {
-  init_zod();
-  init_common();
-  init_consent();
-  GrantTarget = union([strictObject({ person: PersonId }), strictObject({ channel: ChannelName })]);
-  Levels = {
-    chat: ChatLevel.optional(),
-    agentMail: AgentMailLevel.optional(),
-    ask: AskLevel.optional(),
-    trustedUntil: Millis.optional(),
-    discoverable: boolean2().optional()
-  };
-  GrantView = object({
-    subject: union([object({ person: PersonId }), object({ channel: Ulid, name: ChannelName.optional() })]),
-    ...Levels,
-    id: Ulid,
-    ts: Millis,
-    by: MachineId,
-    resignedAt: Millis.optional()
-  });
-  GrantReview = object({
-    subject: GrantView.shape.subject,
-    chat: literal("open").optional(),
-    agentMail: literal("open").optional(),
-    ask: _enum(["open", "request"]).optional(),
-    trustedUntil: Millis.optional(),
-    discoverable: literal(true).optional(),
-    at: Millis
-  });
-  GrantSetParams = strictObject({ subject: GrantTarget, ...Levels, trust: literal(true).optional() });
-  HeldRequest = object({
-    id: Ulid,
-    from: object({ person: PersonId, device: MachineId, label: MachineLabel, agent: SessionName, address: SessionAddress }),
-    to: SessionName,
-    kind: _enum(["message", "task"]),
-    preview: string2().max(LIMITS.previewChars),
-    at: Millis,
-    exp: Millis
-  });
-  RequestAnswer = _enum(["once", "always", "decline", "block"]);
-  CONSENT_METHODS = {
-    "grant.list": {
-      params: strictObject({ subject: GrantTarget.optional() }),
-      result: object({ grants: array(GrantView), review: array(GrantReview) })
-    },
-    "grant.set": { params: GrantSetParams, result: object({ grant: GrantView }) },
-    "grant.set.preview": { params: GrantSetParams, result: object({ sentence: string2().max(500) }) },
-    "request.list": { params: strictObject({}), result: object({ requests: array(HeldRequest).max(LIMITS.heldTotal) }) },
-    "request.answer": {
-      params: strictObject({ id: Ulid, answer: RequestAnswer, all: boolean2().optional() }),
-      result: object({ answered: array(Ulid).max(LIMITS.heldTotal) })
-    }
-  };
-});
-
 // packages/core/dist/schema/ipc/jelly.js
 var NoticeId, NOTICE_LINE_CHARS = 120, Notice, NoticeCounts, DaemonHealth, AgentSummary, AgentConversation, JELLY_METHODS;
 var init_jelly2 = __esm(() => {
@@ -7929,7 +8013,7 @@ var init_b64u = __esm(() => {
 });
 
 // packages/core/dist/version.js
-var VERSION = "0.2.0";
+var VERSION = "0.3.0";
 
 // packages/core/dist/jcs.js
 function hasLoneSurrogate(text) {
@@ -8494,16 +8578,17 @@ function seal(args, randomness) {
   const plaintext = utf8(canonicalize(payload));
   if (plaintext.length > LIMITS.plaintextBytes)
     throw new MessagingError("too_large", `payload exceeds ${LIMITS.plaintextBytes} bytes`);
-  assertMeaning(type, args.from, args.to, payload);
+  const klass = type === "message" && payload.conv?.kind === "request" ? "request" : classOf(args.from, args.to);
+  assertMeaning(type, args.from, args.to, klass, payload);
   if (type !== "presence")
-    return sealBytes(args, type, plaintext, randomness);
+    return sealBytes(args, type, klass, plaintext, randomness);
   if (args.recipientEnc !== undefined)
     throw new MessagingError("invalid_request", "presence is not sealed");
-  const header = parseWith(Header, { ...base2(args, type), enc: "none" }, "envelope header");
+  const header = parseWith(Header, { ...base2(args, type, undefined), enc: "none" }, "envelope header");
   assertShape(header);
   return signed(args.identity, { ...header, body: payload });
 }
-function base2(args, type) {
+function base2(args, type, klass) {
   if (args.from?.device !== args.identity.machine)
     throw new MessagingError("invalid_request", "from.device must be the signing identity");
   const ttl = args.ttlMs ?? LIMITS.ttlMs;
@@ -8520,15 +8605,15 @@ function base2(args, type) {
     ts: now,
     exp: now + ttl,
     anchor: args.anchor?.kind === "epoch" ? { kind: "epoch", size: args.anchor.size, root: args.anchor.root } : { kind: args.anchor?.kind, seq: args.anchor?.seq, hash: args.anchor?.hash },
-    ...type === "presence" ? {} : { class: classOf(args.from, args.to) },
+    ...klass === undefined ? {} : { class: klass },
     ...args.replyTo === undefined ? {} : { replyTo: args.replyTo }
   };
 }
 function classOf(from, to) {
   return to !== undefined && "person" in to && to.person === from?.person ? "self" : "contact";
 }
-function sealBytes(args, type, plaintext, randomness) {
-  const head = base2(args, type);
+function sealBytes(args, type, klass, plaintext, randomness) {
+  const head = base2(args, type, klass);
   const recipient = recipientKey(args.recipientEnc);
   const { ephemeral, nonce } = randomness();
   const epk = rawPublicKey(ephemeral);
@@ -8629,13 +8714,15 @@ function open2(env, identity) {
   const value = parseWire(text, { maxBytes: LIMITS.plaintextBytes });
   canonicalize(value);
   const payload = parseWith(schema, value, `${type} payload`);
-  assertMeaning(type, env.from, env.to, payload);
+  assertMeaning(type, env.from, env.to, env.class, payload);
   return payload;
 }
-function assertMeaning(type, from, to, payload) {
+function assertMeaning(type, from, to, klass, payload) {
   if (type !== "message" || to === undefined || !("device" in to))
     return;
   const p = payload;
+  if (klass === "request" !== (p.conv?.kind === "request"))
+    throw new MessagingError("invalid_request", "a message request is exactly an envelope of class request");
   if (to.agent !== undefined) {
     if (p.conv !== undefined)
       throw new MessagingError("invalid_request", "mail to an agent has no conv");
@@ -8643,6 +8730,8 @@ function assertMeaning(type, from, to, payload) {
   }
   if (p.conv?.kind === "self" && from?.person !== to.person)
     throw new MessagingError("invalid_request", "a self sync goes between devices of one person");
+  if (p.conv?.kind === "card" && (from?.person === to.person || from?.agent !== undefined))
+    throw new MessagingError("invalid_request", "a card goes from a person to another person");
   const line = p.kind === "message" && p.external === undefined && p.message.taskId === undefined && Ulid.safeParse(p.message.messageId).success && (p.message.contextId === undefined || Ulid.safeParse(p.message.contextId).success);
   if (!line)
     throw new MessagingError("invalid_request", "a chat line is kind message, outside any task, with ULID messageId and contextId");
@@ -8701,6 +8790,17 @@ function shapeProblem(env) {
     return "a sealed envelope needs epk and nonce";
   if (env.class === undefined)
     return "a sealed envelope needs class";
+  if (env.class === "request") {
+    if (env.type !== "message")
+      return "only a message is of class request";
+    if (classOf(env.from, env.to) !== "contact")
+      return "a message request goes to another person";
+    if (env.from.agent !== undefined || "agent" in env.to && env.to.agent !== undefined)
+      return "a message request goes from a person to a person";
+    if (env.replyTo !== undefined)
+      return "a message request answers nothing";
+    return;
+  }
   if (env.class !== classOf(env.from, env.to))
     return `class ${env.class} does not match the ends`;
   return;
@@ -10468,6 +10568,10 @@ function decide(args) {
       if (policy.chat === "request_required")
         return { action: "refuse", code: "request_required" };
       return policy.chat === "muted" ? { action: "deliver", consent: "guarded", silent: true } : { action: "deliver", consent: "guarded" };
+    case "request":
+      if (stranger)
+        return { action: "hold" };
+      return policy.chat === "muted" ? { action: "deliver", consent: "guarded", silent: true } : { action: "deliver", consent: "guarded" };
     case "ask":
       if (policy.ask === "open")
         return { action: "deliver", consent: trusted(inbound.chain) ? "trusted" : "guarded" };
@@ -10497,6 +10601,67 @@ var init_consent3 = __esm(() => {
   ASK_RANK = { no: 0, request: 1, open: 2 };
 });
 
+// packages/core/dist/contact-card.js
+function signContactCard(identity, args) {
+  const unsigned = {
+    v: PROTOCOL,
+    realm: args.realm,
+    from: args.from,
+    to: args.to,
+    by: identity.machine,
+    seq: args.seq,
+    ts: args.now,
+    ...args.grantId !== undefined ? { grantId: args.grantId } : {},
+    can: { chat: args.can.chat, agentMail: args.can.agentMail, ask: args.can.ask, ...args.can.trustedUntil !== undefined ? { trustedUntil: args.can.trustedUntil } : {} }
+  };
+  const problem = cardProblem(unsigned);
+  if (problem)
+    throw new MessagingError("invalid_request", problem);
+  const card = parseWith(ContactCard, { ...unsigned, sig: sign(identity, DOMAIN.card, unsigned) }, "card");
+  if (utf8(canonicalize(card)).length > LIMITS.cardBytes)
+    throw new MessagingError("too_large", `a card is at most ${LIMITS.cardBytes} bytes`);
+  return card;
+}
+function verifyContactCard(raw, ctx) {
+  try {
+    const card = parseWith(ContactCard, raw, "card");
+    if (utf8(canonicalize(raw)).length > LIMITS.cardBytes)
+      throw new MessagingError("too_large", `a card is at most ${LIMITS.cardBytes} bytes`);
+    const { sig, ...unsigned } = raw;
+    const input = signingInput(DOMAIN.card, unsigned);
+    if (card.realm !== ctx.realm)
+      throw new MessagingError("invalid_request", "the card is for another realm");
+    if (card.from !== ctx.from)
+      throw new MessagingError("invalid_request", "the card is not its sender's");
+    if (card.to !== ctx.to)
+      throw new MessagingError("invalid_request", "the card is for another person");
+    if (typeof sig !== "string" || !verifyInput(card.by, input, sig))
+      throw new MessagingError("bad_signature", "the card's signature is invalid");
+    return card;
+  } catch (error) {
+    throw asMessagingError(error, "card");
+  }
+}
+function cardCan(relation, grant, now) {
+  const policy = effectivePolicy(relation, grant, [], now);
+  return {
+    chat: policy.chat === "open" || policy.chat === "muted",
+    agentMail: policy.agentMail === "open",
+    ask: policy.ask,
+    ...policy.trustedUntil !== undefined ? { trustedUntil: policy.trustedUntil } : {}
+  };
+}
+var init_contact_card = __esm(() => {
+  init_b64u();
+  init_check();
+  init_consent3();
+  init_jcs();
+  init_common();
+  init_consent();
+  init_errors3();
+  init_sign();
+});
+
 // packages/core/dist/delegation.js
 function grantHash(grant) {
   return sha256(canonicalize(grant));
@@ -11925,6 +12090,7 @@ var TaskStateName, ToolErrorBody, fenced = (what) => string2().describe(`${what}
 var init_agent_tools = __esm(() => {
   init_zod();
   init_common();
+  init_directory_frames();
   init_errors3();
   init_ipc();
   TaskStateName = _enum(["submitted", "working", "completed", "failed", "canceled", "input_required", "rejected", "auth_required"]);
@@ -11960,14 +12126,15 @@ var init_agent_tools = __esm(() => {
   ContactsInput = strictObject({
     query: string2().min(1).max(100).optional().describe("Only contacts whose person, agent or channel name contains this text"),
     kind: _enum(["person", "agent", "channel"]).optional().describe("Only persons (each with their agents), only agents, or only channels. Omit for persons and channels."),
-    can: _enum(["chat", "ask"]).optional().describe("Only those you can chat with (a line to a person or channel) or ask (a task to an agent)"),
+    can: _enum(["chat", "ask"]).optional().describe("Only those you can chat with (a line to a person or channel) or ask (a task to an agent, at once or after their person agrees)"),
     limit: number2().int().min(1).max(50).optional().describe("At most this many (default 20)")
   });
   Can = object({
     chat: boolean2().describe("A chat line reaches them: a person other than you, or a channel you are in"),
     agentMail: boolean2().describe("Agent mail reaches them"),
-    ask: _enum(["open", "request", "no"]).describe("open: a task request goes straight to the agent, which runs it as a guarded peer turn unless its person trusts you"),
-    source: _enum(["card", "default"]).describe("default: today's team policy; nobody has granted or narrowed it")
+    ask: _enum(["open", "request", "no"]).describe("open: a task request goes straight to the agent, which runs it as a guarded peer turn unless its person trusts you; request: their person sees a request card first; no: refused"),
+    source: _enum(["card", "default"]).describe("card: what their person's card says; default: the policy for your org, or for a stranger outside it"),
+    card: iso.optional().describe("With source card: when their person signed it. It is advice: their person may have changed it since")
   });
   Agent = object({
     address: string2().describe("person/agent@label"),
@@ -12007,7 +12174,8 @@ var init_agent_tools = __esm(() => {
     ask: boolean2().optional().describe("true: a task request, which the agent runs and reports on; follow it with messaging_tasks and messaging_read {id}. Only to an agent."),
     replyTo: Ulid.optional().describe("What this answers: a message or task id from messaging_inbox or messaging_read (to an agent), or a line id (to a person or channel, a reply in that thread). Answering a task you asked for, while it waits for input, goes to that task."),
     onBehalfOf: Ulid.optional().describe("With ask: a task you are running that this new task is part of, so the recipient sees who asked whom. Without it, the task starts a new chain."),
-    key: string2().min(1).max(64).optional().describe("Any id of yours for this send: repeating a call with the same key sends once")
+    key: string2().min(1).max(64).optional().describe("Any id of yours for this send: repeating a call with the same key sends once"),
+    request: strictObject({ contact: Email.describe("Their exact email, lower-case") }).optional().describe('Only with to: "me": ask your person to send a message request to someone outside your org. Only your person can send one; you are not told what they decide.')
   });
   SendOutput = object({
     id: string2().describe("The message, task request or line id; messaging_read {id} shows how far mail got"),
@@ -12196,6 +12364,7 @@ var init_dist = __esm(() => {
   init_address();
   init_cards();
   init_consent3();
+  init_contact_card();
   init_delegation2();
   init_task();
   init_direct2();
@@ -14430,6 +14599,17 @@ class Chats {
     });
     return { id, conversation: room };
   }
+  sendRequest(person, text) {
+    const { realm, me } = this.#host.joined();
+    if (person === me.person || !realm.persons().includes(person))
+      throw new MessagingError("not_found", "no Messaging user with that email accepts requests");
+    const now = this.#host.now();
+    this.#paced([person], now);
+    const id = ulid2(now);
+    this.#fan([person], { kind: "request" }, line(id, text));
+    this.#file({ id, room: `dm:${person}`, direction: "out", person: me.person, body: text, at: now });
+    return { id };
+  }
   create(p) {
     const { realm, me } = this.#host.joined();
     if (this.#store.channelByLocal(p.name))
@@ -14665,6 +14845,12 @@ class Chats {
       return false;
     if (payload.stage === "delivered" || payload.stage === "rejected")
       this.settle(row.envelope, payload.stage, payload.code);
+    if (payload.stage === "held" && this.#store.holdChatSent(row.envelope, this.#host.now())) {
+      const sent = this.#store.line(row.line);
+      const rev = sent && this.#store.touchLine(sent.id);
+      if (sent && rev !== undefined)
+        this.#emit(sent.room, sent.id, this.#host.joined().me.person, rev);
+    }
     return true;
   }
   settle(envelope, stage, code) {
@@ -16515,7 +16701,8 @@ class Notices {
     return { ok: true };
   }
   counts() {
-    return { unread: this.#host.store.unreadLines(), requests: this.#host.store.heldCount() };
+    const store = this.#host.store;
+    return { unread: store.unreadLines(), requests: store.heldCount() + store.contactRequestCount() + store.contactSuggestionCount() };
   }
   disconnected(id) {
     this.#watchers.delete(id);
@@ -17190,6 +17377,17 @@ function upgradeStore(db, migrations) {
     throw error;
   }
 }
+function contactRequestRow(row) {
+  return {
+    id: String(row.id),
+    person: String(row.person),
+    machine: String(row.machine),
+    envelope: JSON.parse(String(row.envelope)),
+    payload: JSON.parse(String(row.payload)),
+    at: Number(row.at),
+    exp: Number(row.exp)
+  };
+}
 function heldRow(row) {
   return {
     id: String(row.id),
@@ -17619,6 +17817,58 @@ class Store {
   deleteExpiredHeld(now) {
     return this.#run("DELETE FROM held WHERE exp <= ?", now);
   }
+  contactCard(person) {
+    const row = this.#get("SELECT card, seq, at FROM contact_cards WHERE person = ?", person);
+    return row && { card: JSON.parse(String(row.card)), seq: Number(row.seq), at: Number(row.at) };
+  }
+  contactCards() {
+    return this.#all("SELECT person, card FROM contact_cards ORDER BY person").map((row) => ({ person: String(row.person), card: JSON.parse(String(row.card)) }));
+  }
+  putContactCard(person, card, seq, at) {
+    return this.#run("INSERT INTO contact_cards (person, card, seq, at) VALUES (?, ?, ?, ?) ON CONFLICT (person) DO UPDATE SET card = excluded.card, seq = excluded.seq, at = excluded.at WHERE excluded.seq > contact_cards.seq", person, JSON.stringify(card), seq, at) > 0;
+  }
+  deleteContactCard(person) {
+    this.#run("DELETE FROM contact_cards WHERE person = ?", person);
+  }
+  putContactRequest(row) {
+    this.#run("INSERT INTO contact_requests (id, person, machine, envelope, payload, at, exp) VALUES (?, ?, ?, ?, ?, ?, ?)", row.id, row.person, row.machine, JSON.stringify(row.envelope), JSON.stringify(row.payload), row.at, row.exp);
+  }
+  contactRequest(id) {
+    const row = this.#get("SELECT * FROM contact_requests WHERE id = ?", id);
+    return row && contactRequestRow(row);
+  }
+  contactRequests(person) {
+    const rows = person === undefined ? this.#all("SELECT * FROM contact_requests ORDER BY at, id") : this.#all("SELECT * FROM contact_requests WHERE person = ? ORDER BY at, id", person);
+    return rows.map(contactRequestRow);
+  }
+  contactRequestCount() {
+    return Number(this.#get("SELECT COUNT(*) AS n FROM contact_requests")?.n ?? 0);
+  }
+  deleteContactRequest(id) {
+    this.#run("DELETE FROM contact_requests WHERE id = ?", id);
+  }
+  deleteExpiredContactRequests(now) {
+    return this.#run("DELETE FROM contact_requests WHERE exp <= ?", now);
+  }
+  putContactSuggestion(row) {
+    this.#run("INSERT INTO contact_suggestions (id, session, email, at) VALUES (?, ?, ?, ?)", row.id, row.session, row.email, row.at);
+  }
+  contactSuggestion(id) {
+    const row = this.#get("SELECT * FROM contact_suggestions WHERE id = ?", id);
+    return row && { id: String(row.id), session: String(row.session), email: String(row.email), at: Number(row.at) };
+  }
+  contactSuggestions() {
+    return this.#all("SELECT * FROM contact_suggestions ORDER BY at, id").map((row) => ({ id: String(row.id), session: String(row.session), email: String(row.email), at: Number(row.at) }));
+  }
+  contactSuggestionCount() {
+    return Number(this.#get("SELECT COUNT(*) AS n FROM contact_suggestions")?.n ?? 0);
+  }
+  deleteContactSuggestion(id) {
+    this.#run("DELETE FROM contact_suggestions WHERE id = ?", id);
+  }
+  deleteContactSuggestionsBefore(before) {
+    return this.#run("DELETE FROM contact_suggestions WHERE at < ?", before);
+  }
   putGrant(subject, grant) {
     this.#run("INSERT INTO grants (subject, grant) VALUES (?, ?) ON CONFLICT (subject) DO UPDATE SET grant = excluded.grant", subject, JSON.stringify(grant));
   }
@@ -17711,6 +17961,9 @@ class Store {
   settleChatSent(envelope, stage, code) {
     return this.#run("UPDATE chat_sent SET stage = ?, code = ? WHERE envelope = ? AND stage = 'sent'", stage, opt(code), envelope) > 0;
   }
+  holdChatSent(envelope, at) {
+    return this.#run("UPDATE chat_sent SET held_at = ? WHERE envelope = ? AND stage = 'sent' AND held_at IS NULL", at, envelope) > 0;
+  }
   chatSentDue(now) {
     return this.#all("SELECT * FROM chat_sent WHERE stage = 'sent' AND exp <= ?", now).map(chatSentRow);
   }
@@ -17725,19 +17978,23 @@ class Store {
     const out = new Map;
     if (lines.length === 0)
       return out;
-    const rows = this.#all(`SELECT line, person, MAX(stage = 'delivered') AS d, MIN(stage IN ('rejected', 'expired')) AS r
+    const rows = this.#all(`SELECT line, person, MAX(stage = 'delivered') AS d, MIN(stage IN ('rejected', 'expired')) AS r, MAX(stage = 'sent' AND held_at IS NOT NULL) AS h
        FROM chat_sent WHERE line IN (SELECT value FROM json_each(?)) AND person <> ? GROUP BY line, person ORDER BY person`, JSON.stringify(lines), me);
     for (const row of rows) {
       const line = String(row.line);
-      const entry = out.get(line) ?? { state: "sent", refused: [], pending: false };
+      const entry = out.get(line) ?? { state: "sent", refused: [], pending: false, waiting: false };
       if (Number(row.r) === 1)
         entry.refused.push(String(row.person));
-      else if (Number(row.d) !== 1)
-        entry.pending = true;
+      else if (Number(row.d) !== 1) {
+        if (Number(row.h) === 1)
+          entry.waiting = true;
+        else
+          entry.pending = true;
+      }
       out.set(line, entry);
     }
     for (const entry of out.values())
-      entry.state = entry.refused.length > 0 ? "refused" : entry.pending ? "sent" : "delivered";
+      entry.state = entry.refused.length > 0 ? "refused" : entry.pending ? "sent" : entry.waiting ? "held" : "delivered";
     return out;
   }
   sentUndelivered(now) {
@@ -18053,7 +18310,7 @@ function taskRow2(r) {
   }
   return row;
 }
-var CHAT_COUNTER = "chat", STORE_SCHEMA = 8, STORE_MIN_READER = 3, MIGRATIONS, BASELINE = `
+var CHAT_COUNTER = "chat", STORE_SCHEMA = 9, STORE_MIN_READER = 3, MIGRATIONS, BASELINE = `
 CREATE TABLE IF NOT EXISTS kv (k TEXT PRIMARY KEY, v TEXT NOT NULL) STRICT;
 CREATE TABLE IF NOT EXISTS counters (name TEXT PRIMARY KEY, value INTEGER NOT NULL) STRICT;
 CREATE TABLE IF NOT EXISTS roster (seq INTEGER PRIMARY KEY, hash TEXT NOT NULL, entry TEXT NOT NULL) STRICT;
@@ -18293,6 +18550,24 @@ CREATE TABLE IF NOT EXISTS notices (
 ) STRICT;
 CREATE INDEX IF NOT EXISTS notices_at ON notices (at);
 `
+    },
+    {
+      schema: 9,
+      ddl: `
+CREATE TABLE IF NOT EXISTS contact_cards (person TEXT PRIMARY KEY, card TEXT NOT NULL, seq INTEGER NOT NULL, at INTEGER NOT NULL) STRICT;
+CREATE TABLE IF NOT EXISTS contact_requests (
+  id TEXT PRIMARY KEY,
+  person TEXT NOT NULL,
+  machine TEXT NOT NULL,
+  envelope TEXT NOT NULL,
+  payload TEXT NOT NULL,
+  at INTEGER NOT NULL,
+  exp INTEGER NOT NULL
+) STRICT;
+CREATE INDEX IF NOT EXISTS contact_requests_person ON contact_requests (person);
+CREATE TABLE IF NOT EXISTS contact_suggestions (id TEXT PRIMARY KEY, session TEXT NOT NULL, email TEXT NOT NULL, at INTEGER NOT NULL) STRICT;
+`,
+      columns: [{ table: "chat_sent", column: "held_at", decl: "INTEGER" }]
     }
   ];
   UNSPACED = /([\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Thai}])/gu;
@@ -18693,7 +18968,7 @@ class Grants {
     const review = this.#store.grantReviews().filter(({ subject }) => only === undefined || subject === only).map(({ subject, levels, at }) => ({ subject: this.#subjectView(subject), ...levels, at }));
     return { grants, review };
   }
-  set(p) {
+  set(p, opts = {}) {
     const { identity, realm, me } = this.#host.joined();
     const now = this.#host.now();
     const key = this.#subjectKey(p.subject, true);
@@ -18708,13 +18983,15 @@ class Grants {
       this.#sync("grant", [grant]);
     });
     this.#host.log("grant.set", { subject: "person" in subject ? "person" : "channel" });
+    if ("person" in subject && opts.card !== false)
+      this.#host.changed?.(subject.person);
     return { grant: this.#view(grant) };
   }
-  setPerson(person, change) {
+  setPerson(person, change, opts = {}) {
     const levels = { ...this.personGrant(person), ...change };
     if (levels.ask !== "open")
       delete levels.trustedUntil;
-    return this.set({ subject: { person }, ...levels });
+    return this.set({ subject: { person }, ...levels }, opts);
   }
   check(p) {
     const { identity, realm, me } = this.#host.joined();
@@ -18753,6 +19030,8 @@ class Grants {
       if (this.#store.grantReview(key)?.id !== grant.id)
         this.#store.deleteGrantReview(key);
       merged++;
+      if ("person" in grant.subject)
+        this.#host.merged?.(grant.subject.person);
     }
     this.#host.log("grant.sync", { id: env.id, what: conv.what, merged });
     this.sweep();
@@ -18774,6 +19053,8 @@ class Grants {
       if (copy) {
         this.#store.putGrant(subject, copy);
         resigned.push(copy);
+        if ("person" in copy.subject)
+          this.#host.changed?.(copy.subject.person);
       } else {
         this.#store.deleteGrant(subject);
       }
@@ -18931,18 +19212,23 @@ class Holds {
     return { requests };
   }
   answer(p) {
+    if (p.answer === "accept" && !this.#store.held(p.id))
+      throw new MessagingError("not_found", "no request with that id is held here");
     const now = this.#host.now();
     const row = this.#store.held(p.id);
     if (!row || row.exp <= now)
       throw new MessagingError("not_found", "no request with that id is held here");
+    if (p.answer === "accept")
+      throw new MessagingError("invalid_request", "an ask takes once, always, decline or block; accept answers a message request");
     if (p.answer === "always")
       this.#host.grants.setPerson(row.person, { ask: "open" });
     if (p.answer === "block")
       this.#host.grants.setPerson(row.person, { chat: "blocked" });
     const rows = p.all ? this.#store.helds(row.person).filter((held) => held.exp > now) : [row];
     const answered = [];
+    const answer = p.answer;
     for (const held of rows) {
-      this.#host.tx(() => this.#settle(held, p.answer));
+      this.#host.tx(() => this.#settle(held, answer));
       answered.push(held.id);
     }
     this.#host.log("request.answered", { answer: p.answer, count: answered.length });
@@ -18968,6 +19254,351 @@ var init_holds = __esm(() => {
   init_dist();
 });
 
+// packages/daemon/dist/consent/cards.js
+class Cards {
+  #host;
+  #answered = new Map;
+  #asked = new Map;
+  constructor(host) {
+    this.#host = host;
+  }
+  changed(person) {
+    this.#issueSoon(person).catch((error) => this.#host.log("card.failed", { code: error.code ?? "internal" }));
+  }
+  async#issueSoon(person) {
+    await this.#host.prefetch(person);
+    await this.#host.fresh([person], () => this.#issue(person));
+  }
+  #issue(person) {
+    const { identity, realm, me } = this.#host.joined();
+    if (person === me.person)
+      return;
+    const relation = this.#host.relation(person);
+    if (relation === "self" || relation === "stranger")
+      return;
+    const grant = this.#host.personGrant(person);
+    if (grant?.chat === "blocked")
+      return;
+    const now = this.#host.now();
+    const seq = this.#nextSeq(now);
+    const held = this.#host.store.grant(`person:${person}`);
+    const card = signContactCard(identity, {
+      realm: realm.realm,
+      from: me.person,
+      to: person,
+      seq,
+      now,
+      ...grant !== undefined && typeof held?.id === "string" ? { grantId: held.id } : {},
+      can: cardCan(relation, grant, now)
+    });
+    for (const device of realm.known(person).devices) {
+      this.#host.route(this.#host.seal(device.machine, cardMessage2({ card }, "card")));
+    }
+    this.#host.log("card.sent", { seq });
+  }
+  #nextSeq(now) {
+    const store = this.#host.store;
+    const last = Number(store.getKv(SEQ_KEY) ?? 0);
+    const seq = Math.max(now, last + 1);
+    store.setKv(SEQ_KEY, String(seq));
+    return seq;
+  }
+  receive(env, sender, payload) {
+    const conv = payload.conv;
+    const data = payload.message.parts[0].data;
+    if (conv.what === "get")
+      return this.#answer(sender.person);
+    const { realm, me } = this.#host.joined();
+    const drop = (code) => this.#host.log("card.dropped", { id: env.id, code });
+    const relation = this.#host.relation(sender.person);
+    if (relation === "stranger")
+      return drop("request_required");
+    if (this.#host.personGrant(sender.person)?.chat === "blocked")
+      return drop("refused");
+    let card;
+    try {
+      card = verifyContactCard(data.card, { realm: realm.realm, from: sender.person, to: me.person });
+    } catch (error) {
+      return drop(error.code ?? "invalid_request");
+    }
+    if (!realm.known(sender.person).devices.some((device) => device.machine === card.by))
+      return drop("unknown_device");
+    if (this.#host.store.putContactCard(sender.person, data.card, card.seq, this.#host.now()))
+      this.#host.log("card.kept", { seq: card.seq });
+  }
+  #answer(person) {
+    const now = this.#host.now();
+    const last = this.#answered.get(person);
+    if (last !== undefined && now - last < DAY_MS2)
+      return;
+    if (this.#host.personGrant(person) === undefined)
+      return;
+    this.#answered.set(person, now);
+    this.changed(person);
+  }
+  async get(person) {
+    const { me } = this.#host.joined();
+    if (person === me.person)
+      return false;
+    const now = this.#host.now();
+    const last = this.#asked.get(person);
+    if (last !== undefined && now - last < DAY_MS2)
+      return false;
+    this.#asked.set(person, now);
+    await this.#host.fresh([person], () => {
+      const { realm } = this.#host.joined();
+      for (const device of realm.known(person).devices)
+        this.#host.route(this.#host.seal(device.machine, cardMessage2({ get: true }, "get")));
+    });
+    return true;
+  }
+  refused(person) {
+    this.#host.store.deleteContactCard(person);
+    this.get(person).catch(() => {
+      return;
+    });
+  }
+  reach(person, sameOrg) {
+    const card = this.#card(person);
+    if (card)
+      return { person, can: card.can, source: "card", at: card.ts };
+    return { person, can: cardCan(sameOrg ? "org" : "stranger", undefined, this.#host.now()), source: "default" };
+  }
+  cardPersons() {
+    return this.#host.store.contactCards().map((row) => row.person);
+  }
+  #card(person) {
+    const held = this.#host.store.contactCard(person);
+    if (!held)
+      return;
+    const { realm, me } = this.#host.joined();
+    try {
+      const card = verifyContactCard(held.card, { realm: realm.realm, from: person, to: me.person });
+      if (!realm.known(person).devices.some((device) => device.machine === card.by))
+        return;
+      const { trustedUntil, ...rest } = card.can;
+      return { can: trustedUntil !== undefined && trustedUntil > this.#host.now() ? card.can : rest, ts: card.ts };
+    } catch {
+      this.#host.store.deleteContactCard(person);
+      return;
+    }
+  }
+}
+function cardMessage2(data, what) {
+  return { kind: "message", message: { messageId: ulid2(), role: "ROLE_USER", parts: [{ data }] }, conv: { kind: "card", what } };
+}
+var SEQ_KEY = "cards.seq", DAY_MS2 = 86400000;
+var init_cards2 = __esm(() => {
+  init_dist();
+});
+
+// packages/daemon/dist/consent/requests.js
+class Requests {
+  #host;
+  #store;
+  #waiting = new Map;
+  #day = -1;
+  #today = new Set;
+  constructor(host) {
+    this.#host = host;
+    this.#store = host.store;
+  }
+  async preview(p) {
+    this.#hosted();
+    return { found: await this.#resolve(p.email) !== undefined };
+  }
+  async request(p) {
+    this.#hosted();
+    const { me } = this.#host.joined();
+    if (p.suggestion !== undefined && !this.#store.contactSuggestion(p.suggestion))
+      throw new MessagingError("not_found", "no suggestion with that id is held here");
+    const person = await this.#resolve(p.email);
+    if (person === undefined)
+      throw new MessagingError("not_found", "no Messaging user with that email accepts requests");
+    if (person === me.person)
+      throw new MessagingError("invalid_request", "that email is your own");
+    if (this.#host.grants.personGrant(person)?.chat === "blocked")
+      throw new MessagingError("invalid_state", "you blocked that person; unblock them with grant.set first");
+    const now = this.#host.now();
+    this.#paced(person, now);
+    await this.#host.grants.prefetch(person);
+    const line = await this.#host.fresh([person], () => this.#host.tx(() => {
+      if (this.#host.grants.personGrant(person)?.chat === undefined)
+        this.#host.grants.setPerson(person, { chat: "open" }, { card: false });
+      const sent = this.#host.chats.sendRequest(person, p.text);
+      if (p.suggestion !== undefined)
+        this.#store.deleteContactSuggestion(p.suggestion);
+      return sent;
+    }));
+    this.#waiting.set(person, now);
+    this.#today.add(person);
+    this.#host.log("contact.request.sent", {});
+    return { id: line.id, conversation: `dm:${person}`, person };
+  }
+  async#resolve(email) {
+    const { realm } = this.#host.joined();
+    const found = await realm.resolve(email, "exact-email");
+    if (found.length > 1)
+      throw new MessagingError("ambiguous_address", "more than one person has that email");
+    return found[0];
+  }
+  #hosted() {
+    if (this.#host.realmKind() !== "directory") {
+      throw new MessagingError("invalid_request", "message requests are for a hosted realm: on a team, every person is in your org and can be written to");
+    }
+  }
+  #paced(person, now) {
+    const day = Math.floor(now / DAY_MS3);
+    if (day !== this.#day) {
+      this.#day = day;
+      this.#today.clear();
+    }
+    const waiting = this.#waiting.get(person);
+    if (waiting !== undefined && now - waiting < LIMITS.ttlMs)
+      throw new MessagingError("rate_limited", "a request to that person is waiting for their answer");
+    if (!this.#today.has(person) && this.#today.size >= LIMITS.requestsPerDay) {
+      throw new MessagingError("rate_limited", `you sent message requests to ${LIMITS.requestsPerDay} persons today; try again tomorrow`);
+    }
+  }
+  answered(person) {
+    this.#waiting.delete(person);
+  }
+  receive(env, sender, payload, now) {
+    const reject = (code) => {
+      this.#host.log("contact.request.rejected", { id: env.id, code });
+      this.#host.receipt(sender.machine, env.id, "rejected", code);
+    };
+    if (this.#host.realmKind() !== "directory")
+      return reject("invalid_request");
+    const decision = this.#host.grants.decide(sender.person, { kind: "request" });
+    if (decision.action === "refuse")
+      return reject(decision.code);
+    if (decision.action === "deliver")
+      return this.#host.chats.receive(env, sender, asLine(payload), now);
+    if (this.#store.contactRequest(env.id))
+      return reject("invalid_request");
+    if (this.#store.contactRequests(sender.person).length > 0 || this.#store.contactRequestCount() >= LIMITS.heldTotal)
+      return reject("rate_limited");
+    this.#store.putContactRequest({ id: env.id, person: sender.person, machine: sender.machine, envelope: env, payload, at: now, exp: env.exp });
+    this.#host.held({ id: env.id, person: sender.person, agent: undefined, at: now });
+    this.#host.log("contact.request.held", { id: env.id });
+    this.#host.receipt(sender.machine, env.id, "held");
+  }
+  async list() {
+    const { realm } = this.#host.joined();
+    const now = this.#host.now();
+    const out = [];
+    for (const row of this.#store.contactRequests()) {
+      if (row.exp <= now)
+        continue;
+      const device = realm.device(row.machine);
+      const profile = await this.#host.profile(row.person).catch(() => {
+        return;
+      });
+      out.push({
+        id: row.id,
+        kind: "contact",
+        from: {
+          person: row.person,
+          device: row.machine,
+          label: device?.label ?? "gone",
+          name: (profile?.name ?? row.person).slice(0, 200),
+          ...profile?.email !== undefined ? { email: profile.email.slice(0, 320) } : {},
+          org: profile?.org ?? "none"
+        },
+        text: requestText(row.payload),
+        at: row.at,
+        exp: row.exp
+      });
+    }
+    for (const row of this.#store.contactSuggestions())
+      out.push({ id: row.id, kind: "suggestion", agent: row.session, email: row.email, at: row.at });
+    return out;
+  }
+  holds(id) {
+    return this.#store.contactRequest(id) !== undefined || this.#store.contactSuggestion(id) !== undefined;
+  }
+  answer(p) {
+    const suggestion = this.#store.contactSuggestion(p.id);
+    if (suggestion) {
+      if (p.answer !== "decline")
+        throw new MessagingError("invalid_request", "a suggestion is dismissed with decline; send the request itself with contact.request");
+      this.#host.tx(() => this.#store.deleteContactSuggestion(p.id));
+      return { answered: [p.id] };
+    }
+    const now = this.#host.now();
+    const row = this.#store.contactRequest(p.id);
+    if (!row || row.exp <= now)
+      throw new MessagingError("not_found", "no request with that id is held here");
+    if (p.answer !== "accept" && p.answer !== "decline" && p.answer !== "block") {
+      throw new MessagingError("invalid_request", "a message request takes accept, decline or block");
+    }
+    const answer = p.answer;
+    const rows = p.all ? this.#store.contactRequests(row.person).filter((held) => held.exp > now) : [row];
+    this.#host.tx(() => {
+      if (answer === "accept")
+        this.#host.grants.setPerson(row.person, { chat: "open" });
+      if (answer === "block")
+        this.#host.grants.setPerson(row.person, { chat: "blocked" });
+      for (const held of rows)
+        this.#settle(held, answer === "accept" ? "accept" : "decline");
+    });
+    this.#host.log("contact.request.answered", { answer, count: rows.length });
+    return { answered: rows.map((held) => held.id) };
+  }
+  granted(person) {
+    const chat = this.#host.grants.personGrant(person)?.chat;
+    if (chat !== "open" && chat !== "blocked")
+      return;
+    for (const row of this.#store.contactRequests(person))
+      this.#settle(row, chat === "open" ? "accept" : "decline");
+  }
+  #settle(row, answer) {
+    this.#store.deleteContactRequest(row.id);
+    const { realm } = this.#host.joined();
+    const sender = realm.device(row.machine);
+    if (!sender || sender.person !== row.person)
+      return;
+    if (answer === "decline")
+      return this.#host.receipt(sender.machine, row.id, "rejected", "declined");
+    this.#host.chats.receive(row.envelope, sender, asLine(row.payload), this.#host.now());
+  }
+  suggest(session, email) {
+    const { me } = this.#host.joined();
+    const now = this.#host.now();
+    if (this.#store.contactSuggestionCount() >= LIMITS.heldTotal)
+      throw new MessagingError("rate_limited", "your person has too many suggestions waiting");
+    const id = ulid2(now);
+    this.#host.tx(() => {
+      this.#store.putContactSuggestion({ id, session, email, at: now });
+      this.#host.held({ id, person: me.person, agent: session, at: now });
+    });
+    return id;
+  }
+  sweep(now) {
+    const requests = this.#store.deleteExpiredContactRequests(now);
+    const suggestions = this.#store.deleteContactSuggestionsBefore(now - SUGGESTION_MS);
+    if (requests + suggestions > 0)
+      this.#host.log("contact.request.expired", { requests, suggestions });
+    for (const [person, at] of this.#waiting)
+      if (now - at >= LIMITS.ttlMs)
+        this.#waiting.delete(person);
+  }
+}
+function asLine(payload) {
+  const { conv: _conv, ...line } = payload;
+  return line;
+}
+function requestText(payload) {
+  const text = payload.message.parts[0]?.text;
+  return typeof text === "string" ? text.slice(0, LIMITS.requestChars) : "";
+}
+var DAY_MS3 = 86400000, SUGGESTION_MS;
+var init_requests = __esm(() => {
+  init_dist();
+  SUGGESTION_MS = LIMITS.ttlMs;
+});
+
 // packages/daemon/dist/consent/sentence.js
 function grantSentence(p, me, now) {
   const levels = levelsFrom(p, now);
@@ -19063,6 +19694,8 @@ class Daemon {
   #chats;
   #grants;
   #holds;
+  #cards;
+  #requests;
   #notices;
   #jellyHost;
   #jellyAuth;
@@ -19128,6 +19761,36 @@ class Daemon {
       seal: (machine, payload) => this.#seal("message", machine, undefined, payload),
       route: (env) => this.#route(env),
       tx: (fn) => this.#tx(fn),
+      log: (event, fields) => this.#log("info", event, fields),
+      changed: (person) => this.#cards.changed(person),
+      merged: (person) => this.#requests.granted(person)
+    });
+    this.#cards = new Cards({
+      store,
+      now: this.#now,
+      joined: () => this.#joined(),
+      relation: (person) => this.#grants.relation(person),
+      personGrant: (person) => this.#grants.personGrant(person),
+      prefetch: (person) => this.#grants.prefetch(person),
+      fresh: async (persons, fn) => {
+        await this.#withFresh(persons, () => this.#tx(fn), { first: false });
+      },
+      seal: (machine, payload) => this.#seal("message", machine, undefined, payload),
+      route: (env) => this.#route(env),
+      log: (event, fields) => this.#log("info", event, fields)
+    });
+    this.#requests = new Requests({
+      store,
+      grants: this.#grants,
+      chats: this.#chats,
+      now: this.#now,
+      joined: () => this.#joined(),
+      realmKind: () => this.#realm?.kind,
+      fresh: (persons, fn) => this.#withFresh(persons, fn),
+      profile: async (person) => await this.#joined().realm.profile(person),
+      receipt: (machine, ref, stage, code) => this.#receipt(machine, ref, undefined, stage, code),
+      tx: (fn) => this.#tx(fn),
+      held: (row) => this.#notices.held(row),
       log: (event, fields) => this.#log("info", event, fields)
     });
     this.#holds = new Holds({
@@ -19414,10 +20077,12 @@ class Daemon {
       "session.register": (p, ctx) => this.#register(p, ctx),
       "session.update": (p, ctx) => this.#updateSession(this.#bound(p, ctx)),
       "session.unregister": (p, ctx) => this.#unregister(this.#bound(p, ctx)),
-      "contacts.list": (p) => ({
-        entries: directory2(this.#view(this.#joined()), p, this.#now(), { wake: (s) => this.#wakes(s) }),
-        conversations: this.#chats.list({ limit: 200 }).conversations
-      }),
+      "contacts.list": async (p) => {
+        const entries = directory2(this.#view(this.#joined()), p, this.#now(), { wake: (s) => this.#wakes(s) });
+        const conversations = this.#chats.list({ limit: 200 }).conversations;
+        const dms = conversations.flatMap((c) => c.conversation.startsWith("dm:") ? [c.conversation.slice("dm:".length)] : []);
+        return { entries, conversations, reach: await this.#reach([...entries.map((entry) => entry.person), ...dms]) };
+      },
       "msg.send": (p, ctx) => isLineTarget(p.to) ? this.#sendLine(this.#bound(p, ctx)) : this.#send(this.#bound(p, ctx)),
       "item.read": (p, ctx) => this.#itemRead(this.#bound(p, ctx)),
       "inbox.list": (p, ctx) => ({ items: this.#store.inbox(this.#bound(p, ctx).key, p.unreadOnly ?? false, p.limit ?? 50) }),
@@ -19478,8 +20143,15 @@ class Daemon {
         this.#grants.check(p);
         return { sentence: grantSentence(p, this.#joined().me.person, this.#now()) };
       },
-      "request.list": () => this.#holds.list(),
-      "request.answer": (p) => this.#holds.answer(p),
+      "request.list": async () => ({ requests: [...this.#holds.list().requests, ...await this.#requests.list()] }),
+      "request.answer": (p) => this.#requests.holds(p.id) ? this.#requests.answer(p) : this.#holds.answer(p),
+      "contact.request": (p) => this.#requests.request(p),
+      "contact.request.preview": (p) => this.#requests.preview(p),
+      "card.get": async (p) => {
+        const { realm } = this.#joined();
+        await realm.profile(p.person);
+        return { sent: await this.#cards.get(p.person) };
+      },
       "daemon.health": () => this.#health(),
       "agents.list": () => this.#agentsList(),
       "agents.read": (p) => this.#agentsRead(p),
@@ -19489,6 +20161,16 @@ class Daemon {
       "device.remove.preview": (p) => this.#removePreview(p)
     };
   }
+  async#reach(persons) {
+    const { realm, me } = this.#joined();
+    const all = [...new Set([...persons, ...this.#cards.cardPersons()])].filter((person) => person !== me.person).sort();
+    const out = [];
+    for (const person of all) {
+      const org = realm.kind === "roster" ? "same" : await realm.profile(person).then((profile) => profile.org, () => "none");
+      out.push(this.#cards.reach(person, org === "same"));
+    }
+    return out;
+  }
   async#grantSubject(p) {
     const { realm } = this.#joined();
     if ("person" in p.subject)
@@ -19997,7 +20679,12 @@ class Daemon {
       throw new MessagingError("invalid_request", "to is person/agent[@label], a person, or #<channel>");
     }
     const conversation = p.to.startsWith("#") ? `channel:${name}` : `dm:${name}`;
+    if (p.request !== undefined && conversation !== `dm:${this.#joined().me.person}`) {
+      throw new MessagingError("invalid_request", "request.contact goes only with a line to your own person");
+    }
     const line = await this.#withFresh(this.#linePersons(conversation), () => this.#chats.send({ conversation, text, ...p.replyTo !== undefined ? { thread: p.replyTo } : {}, ...p.idempotencyKey !== undefined ? { clientId: p.idempotencyKey } : {} }, session, p.key));
+    if (p.request !== undefined)
+      this.#requests.suggest(session, p.request.contact);
     return { results: [{ to: p.to, envelopeId: line.id, messageId: line.id, contextId: line.id, stage: "accepted" }] };
   }
   #linePersons(conversation) {
@@ -20065,7 +20752,7 @@ class Daemon {
       this.#freshBound.set(env.id, this.#staleBound);
     this.#routed = true;
   }
-  async#withFresh(persons, fn) {
+  async#withFresh(persons, fn, opts = {}) {
     const realm = this.#realm;
     if (realm?.kind !== "directory")
       return fn();
@@ -20086,8 +20773,9 @@ class Daemon {
     this.#staleBound = stale;
     try {
       const result = fn();
-      for (const person of others)
-        this.#sealedTo.add(person);
+      if (opts.first !== false)
+        for (const person of others)
+          this.#sealedTo.add(person);
       return result;
     } finally {
       this.#staleBound = undefined;
@@ -20197,7 +20885,9 @@ ${row.receipt ? "receipt" : "envelope"}`;
             this.#releaseWaiters();
             return;
           }
-          if (code === undefined || code === "rate_limited" || code === "internal") {
+          if (code === "rate_limited" && row.env.class === "request")
+            this.#nacked(row, code);
+          else if (code === undefined || code === "rate_limited" || code === "internal") {
             this.#retryLater(row);
             waiting.add(lane);
           } else
@@ -20529,6 +21219,14 @@ ${row.receipt ? "receipt" : "envelope"}`;
       const data = payload.message.parts[0].data;
       return this.#grants.receive(env, payload.conv, data.grants);
     }
+    if (payload.conv?.kind === "request")
+      return this.#requests.receive(env, sender, payload, now);
+    if (payload.conv?.kind === "card") {
+      this.#requests.answered(sender.person);
+      return this.#cards.receive(env, sender, payload);
+    }
+    if (toSession === undefined && sender.person !== this.#joined().me.person)
+      this.#requests.answered(sender.person);
     if (toSession === undefined)
       return this.#chats.receive(env, sender, payload, now);
     if (fromSession === undefined)
@@ -20730,6 +21428,9 @@ ${row.receipt ? "receipt" : "envelope"}`;
     this.#sendStatus(row);
   }
   #onReceipt(env, sender, payload) {
+    if (payload.stage === "rejected" && sender.person !== this.#joined().me.person && (payload.code === "refused" || payload.code === "request_required" || payload.code === "declined")) {
+      this.#cards.refused(sender.person);
+    }
     const sent = this.#store.sent(payload.ref);
     if (sent && this.#counterpart(sent.toMachine, sender))
       return void this.#advance(sent, payload.stage, payload.code);
@@ -20907,6 +21608,7 @@ ${row.receipt ? "receipt" : "envelope"}`;
           this.#advance(sent, "expired");
         this.#chats.sweep(now);
         this.#holds.sweep(now);
+        this.#requests.sweep(now);
         sessions = this.#store.expireKept(now - KEPT_MS);
         for (const row of this.#store.interruptedTasks(now - INPUT_TIMEOUT_MS))
           this.#timeOut(row, now);
@@ -21627,6 +22329,8 @@ var init_daemon = __esm(() => {
   init_wake_bridge();
   init_grants();
   init_holds();
+  init_cards2();
+  init_requests();
   init_sentence();
   DEFAULT_TUNING = {
     presenceMinMs: 2000,
@@ -22322,18 +23026,18 @@ var init_directory3 = __esm(() => {
 });
 
 // packages/relay/dist/directory/feed.js
-var DAY_MS2 = 86400000, FEED_RETENTION_MS;
+var DAY_MS4 = 86400000, FEED_RETENTION_MS;
 var init_feed = __esm(() => {
   init_dist();
   init_jelly4();
-  FEED_RETENTION_MS = 90 * DAY_MS2;
+  FEED_RETENTION_MS = 90 * DAY_MS4;
 });
 
 // packages/relay/dist/directory/pacing.js
-var DAY_MS3 = 86400000, PAIR_WINDOW_MS;
+var DAY_MS5 = 86400000, PAIR_WINDOW_MS;
 var init_pacing = __esm(() => {
   init_dist();
-  PAIR_WINDOW_MS = 30 * DAY_MS3;
+  PAIR_WINDOW_MS = 30 * DAY_MS5;
 });
 
 // packages/relay/dist/directory/module.js
@@ -23321,7 +24025,7 @@ var HINTS = {
   unknown_address: "find a person, agent or channel with `messaging who` or `messaging people`.",
   refused: "do not retry; the recipient's policy refuses this from you.",
   declined: "do not retry: the recipient's person declined this request.",
-  request_required: "send them a message request first: they are outside your org and have not accepted you.",
+  request_required: "send them a message request first, with messaging contact <email> <text>: they are outside your org and have not accepted you.",
   rate_limited: "wait a minute, then retry.",
   loop_guard: "wait before sending more: the agent-to-agent loop guard tripped.",
   too_large: "shorten the content or split it.",
@@ -24021,24 +24725,27 @@ function optional2(key, value) {
 }
 var requests = {
   name: "requests",
-  summary: "List the requests waiting for you, or answer one: once, always, decline or block",
-  usage: "[answer <id> once|always|decline|block [--all]]",
+  summary: "List the requests waiting for you, or answer one: once, always, accept, decline or block",
+  usage: "[answer <id> once|always|accept|decline|block [--all]]",
   details: [
-    "A request is mail or a task from someone's agent to one of yours that waits for you (their ask level is request).",
-    "once: deliver this one. always: let their agents ask yours from now on, then deliver it.",
-    "decline: refuse it. block: block their lines and decline it. --all: answer every request from that person.",
-    "Previews are peer text, shown in a frame."
+    "An ask is mail or a task from someone's agent to one of yours that waits for you (their ask level is request):",
+    "once delivers this one; always lets their agents ask yours from now on, then delivers it.",
+    "A message request is a person of another org asking to write to you: accept lets them chat with you and files",
+    "their text as their first line. A suggestion is one of your agents asking you to contact someone: send it with",
+    "`messaging contact`, or dismiss it with decline.",
+    "decline: refuse it. block: block their lines and decline it. --all: answer every request of that kind from that person.",
+    "Previews and request text are peer text, shown in a frame; a request's name and email are the directory's, never the text's."
   ].join(`
 `),
-  options: { all: { type: "boolean", description: "With answer: every request from that person" } },
+  options: { all: { type: "boolean", description: "With answer: every request of that kind from that person" } },
   args: { min: 0, max: 3 },
   async run(ctx, positionals, values) {
     const client = await ctx.client();
     if (positionals.length > 0) {
       if (positionals[0] !== "answer" || positionals.length !== 3)
-        throw new UsageError("answer with: messaging requests answer <id> once|always|decline|block [--all]");
+        throw new UsageError("answer with: messaging requests answer <id> once|always|accept|decline|block [--all]");
       const id = parseWith2(Ulid, positionals[1], "<id> must be a request id from `messaging requests`");
-      const answer = parseWith2(RequestAnswer, positionals[2], "the answer must be once, always, decline or block");
+      const answer = parseWith2(RequestAnswer, positionals[2], "the answer must be once, always, accept, decline or block");
       const result = await client.call("request.answer", { id, answer, ...values.all === true ? { all: true } : {} });
       if (ctx.json) {
         ctx.out.json(result);
@@ -24060,13 +24767,80 @@ var requests = {
     }
     const now = ctx.now();
     for (const r of held) {
+      if (r.kind === "suggestion") {
+        ctx.out.line(`${ctx.out.style.bold("Suggestion")} ${r.id} from your agent ${inline(r.agent, 64)}: contact ${inline(r.email, 320)}  ${ago(r.at, now)}`);
+        continue;
+      }
+      if (r.kind === "contact") {
+        const who = `${inline(r.from.name, 64)}${r.from.email !== undefined ? ` <${inline(r.from.email, 320)}>` : ""}`;
+        const org = r.from.org === "same" ? "your org" : r.from.org === "other" ? "another org" : "no org";
+        ctx.out.line(`${ctx.out.style.bold("Message request")} ${r.id} from ${who} (${org})  ${ago(r.at, now)}, expires ${iso2(r.exp)}`);
+        ctx.out.lines(peerBlock(r.from.name, [r.text]));
+        continue;
+      }
       ctx.out.line(`${ctx.out.style.bold(r.kind === "task" ? "Task request" : "Message")} ${r.id} from ${inline(r.from.address)} to ${inline(r.to, 64)}  ${ago(r.at, now)}, expires ${iso2(r.exp)}`);
       ctx.out.lines(peerBlock(r.from.address, [r.preview]));
     }
-    ctx.out.note("Answer with: messaging requests answer <id> once|always|decline|block [--all]");
+    ctx.out.note("Answer with: messaging requests answer <id> once|always|accept|decline|block [--all]");
   }
 };
-var CONSENT_COMMANDS = [grants, grant2, requests];
+var contact = {
+  name: "contact",
+  summary: "Send a message request to a person of another org, by their exact email",
+  usage: "<email> <text\u2026> [--dry-run] [--suggestion <id>]",
+  details: [
+    "A hosted realm only. The email must be exact; nothing tells an unknown email from one that does not accept requests.",
+    `The text is all they see before they answer: at most ${LIMITS.requestChars} characters. One request waits per person.`,
+    "--dry-run only checks that the email finds someone. --suggestion answers your agent's suggestion of this contact."
+  ].join(`
+`),
+  options: {
+    "dry-run": { type: "boolean", description: "Check the email, send nothing" },
+    suggestion: { type: "string", description: "The suggestion this answers, from `messaging requests`" }
+  },
+  args: { min: 1, max: 200 },
+  async run(ctx, positionals, values) {
+    const email = parseWith2(Email, positionals[0].toLowerCase(), "<email> must be an exact email address");
+    const client = await ctx.client();
+    if (values["dry-run"] === true) {
+      const { found } = await client.call("contact.request.preview", { email });
+      if (ctx.json)
+        return ctx.out.json({ found });
+      ctx.out.line(found ? "That email finds a Messaging user who accepts requests." : "No Messaging user with that email accepts requests.");
+      return;
+    }
+    const text = positionals.slice(1).join(" ");
+    if (text.length === 0)
+      throw new UsageError("say who you are and why you write: messaging contact <email> <text\u2026>");
+    if (text.length > LIMITS.requestChars)
+      throw new UsageError(`a message request is at most ${LIMITS.requestChars} characters`);
+    const suggestion = stringValue(values, "suggestion");
+    const result = await client.call("contact.request", {
+      email,
+      text,
+      ...suggestion !== undefined ? { suggestion: parseWith2(Ulid, suggestion, "--suggestion must be a suggestion id from `messaging requests`") } : {}
+    });
+    if (ctx.json)
+      return ctx.out.json(result);
+    ctx.out.line(`Sent. They see your request first; it is ${result.conversation} once they accept.`);
+  }
+};
+var card = {
+  name: "card",
+  summary: "Ask a person for their contact card: what they let you send them",
+  usage: "<who>",
+  details: "At most once a day per person. Their card arrives later; `messaging who` and the tools show it.",
+  args: { min: 1, max: 1 },
+  async run(ctx, positionals) {
+    const person = parseWith2(PersonId, positionals[0], "<who> is a person (a lowercase name or a p_\u2026 id)");
+    const client = await ctx.client();
+    const { sent } = await client.call("card.get", { person });
+    if (ctx.json)
+      return ctx.out.json({ sent });
+    ctx.out.line(sent ? "Asked. Their card comes when one of their devices answers." : "You asked them in the last day; their card comes when they answer.");
+  }
+};
+var CONSENT_COMMANDS = [grants, grant2, requests, contact, card];
 
 // packages/daemon/dist/cli/commands/daemon.js
 init_dist();
@@ -25401,7 +26175,7 @@ var revokeInvite = {
       ctx.out.line(`Revoked invite ${inviteId}.`);
   }
 };
-var card = {
+var card2 = {
   name: "team card",
   summary: "Print this team's public card (relay, team id, name)",
   usage: "",
@@ -25550,7 +26324,7 @@ var prepare = {
     ctx.out.note("Give this machine id to the relay operator for --allow-team-create, then run `messaging team create`.");
   }
 };
-var TEAM_COMMANDS = [prepare, create, invite, join5, members2, remove, role, revokeInvite, card, add, pair, claim2, pairCancel];
+var TEAM_COMMANDS = [prepare, create, invite, join5, members2, remove, role, revokeInvite, card2, add, pair, claim2, pairCancel];
 
 // packages/daemon/dist/cli/version.js
 init_dist();
@@ -25580,7 +26354,7 @@ var SECTIONS = [
   ["Daemon", ["daemon start", "daemon stop", "status"]],
   ["Team", ["team prepare", "team create", "team card", "team invite", "team join", "team pair", "team add", "team claim", "team pair-cancel", "team members", "team remove", "team role", "team revoke-invite"]],
   ["Identity", ["identity show", "identity migrate", "identity rotate-enc"]],
-  ["People", ["people", "devices", "grants", "grant", "requests", "notices"]],
+  ["People", ["people", "devices", "grants", "grant", "requests", "contact", "card", "notices"]],
   ["Messages", ["who", "send", "inbox", "read", "message-status"]],
   ["Chats", ["chat list", "chat read", "chat post", "chat search"]],
   ["Tasks", ["tasks", "task", "cancel"]],