@joe-broadhead/messaging 0.8.0 → 0.9.0

package/dist/types/core/agent/present.d.ts

@@ -1,6 +1,6 @@
 import { type TaskReadOutput, type ToolConsent, type ToolOutput, type ToolTask } from "../agent-tools.js";
 import type { ConversationToolOutput } from "../conversation-agent-tools.js";
-import type { DirectoryEntry, InboxItem, IpcResult, TaskFollowUp, TaskRecord } from "../schema/ipc.js";
+import { type DirectoryEntry, type InboxItem, type IpcResult, type TaskFollowUp, type TaskRecord } from "../schema/ipc.js";
 import { type ToolFramer as Framer } from "./text.js";
 /**
  * Daemon results → agent tool outputs (`AgentTool`, spec §11). Pure. Every string another person

package/dist/types/core/agent-tools.d.ts

@@ -101,6 +101,7 @@ export declare const ToolErrorBody: z.ZodObject<{
             jelly_unavailable: "jelly_unavailable";
             log_conflict: "log_conflict";
             conv_conflict: "conv_conflict";
+            conflict: "conflict";
             stale_epoch: "stale_epoch";
             device_limit: "device_limit";
             admission_required: "admission_required";
@@ -252,6 +253,7 @@ export declare const TaskSendOutput: z.ZodObject<{
             jelly_unavailable: "jelly_unavailable";
             log_conflict: "log_conflict";
             conv_conflict: "conv_conflict";
+            conflict: "conflict";
             stale_epoch: "stale_epoch";
             device_limit: "device_limit";
             admission_required: "admission_required";
@@ -309,6 +311,16 @@ declare const Task: z.ZodObject<{
         peer: "peer";
         ours: "ours";
     }>>;
+    signIn: z.ZodOptional<z.ZodObject<{
+        tool: z.ZodOptional<z.ZodString>;
+        by: z.ZodEnum<{
+            you: "you";
+            them: "them";
+        }>;
+    }, z.core.$strip>>;
+    refusal: z.ZodOptional<z.ZodObject<{
+        reason: z.ZodString;
+    }, z.core.$strip>>;
     createdAt: z.ZodString;
     updatedAt: z.ZodString;
     consent: z.ZodOptional<z.ZodEnum<{
@@ -455,6 +467,16 @@ export declare const TaskReadOutput: z.ZodObject<{
                 peer: "peer";
                 ours: "ours";
             }>>;
+            signIn: z.ZodOptional<z.ZodObject<{
+                tool: z.ZodOptional<z.ZodString>;
+                by: z.ZodEnum<{
+                    you: "you";
+                    them: "them";
+                }>;
+            }, z.core.$strip>>;
+            refusal: z.ZodOptional<z.ZodObject<{
+                reason: z.ZodString;
+            }, z.core.$strip>>;
             createdAt: z.ZodString;
             updatedAt: z.ZodString;
             consent: z.ZodOptional<z.ZodEnum<{
@@ -691,6 +713,16 @@ export declare const AgentTool: {
                     trusted: "trusted";
                 }>>;
                 updatedAt: z.ZodString;
+                signIn: z.ZodOptional<z.ZodObject<{
+                    tool: z.ZodOptional<z.ZodString>;
+                    by: z.ZodEnum<{
+                        you: "you";
+                        them: "them";
+                    }>;
+                }, z.core.$strip>>;
+                refusal: z.ZodOptional<z.ZodObject<{
+                    reason: z.ZodString;
+                }, z.core.$strip>>;
                 title: z.ZodOptional<z.ZodString>;
                 counterpart: z.ZodString;
                 titleAuthor: z.ZodOptional<z.ZodEnum<{

package/dist/types/core/consent.d.ts

@@ -1,6 +1,7 @@
 import type { Identity } from "./identity.js";
 import { type MachineId, type PersonId, type Ulid } from "./schema/common.js";
 import { type AgentMailLevel, type AskLevel, type ChatLevel, ConsentGrant, type GrantLevels, type GrantSubject } from "./schema/consent.js";
+import type { ReachValue } from "./schema/ipc/consent.js";
 import type { RealmId } from "./schema/realm.js";
 export interface ConsentGrantArgs {
     realm: RealmId;
@@ -25,6 +26,22 @@ export declare function verifyConsentGrant(raw: unknown, ctx: {
 }): ConsentGrant;
 /** The key one grant is stored under: its subject. One grant per subject. */
 export declare function grantSubjectKey(subject: GrantSubject): string;
+/**
+ * The person's two reach choices, from their relation grants. `message` ("Who can message you") is the `outside`
+ * grant's `chat`: `open`, `blocked` (Never), or a grant with no level (Ask me first). `ask` ("How agents may ask
+ * yours") is the `org` grant's `ask`: `open`, `request` (Ask me first), `no` (Never). Absent: no grant, the defaults.
+ */
+export interface ReachChoices {
+    message?: ReachValue;
+    ask?: ReachValue;
+}
+/** The choices a person's two relation grants make; a grant absent (or not current) leaves its choice unset. */
+export declare function reachChoices(outside: GrantLevels | undefined, org: GrantLevels | undefined): ReachChoices;
+/** The relation grant subject and levels that record one choice: the inverse of `reachChoices`. */
+export declare function reachGrant(group: keyof ReachChoices, value: ReachValue): {
+    subject: GrantSubject;
+    levels: GrantLevels;
+};
 /**
  * Of two copies of the grant for one subject, the one that counts (spec §6.9, "Merging"): the newer by `ts`, then
  * by `id`. Copies that tie on both are one grant signed twice: a copy whose signer is current beats one whose
@@ -67,10 +84,11 @@ export interface EffectivePolicy {
 }
 /**
  * Spec §6.9, "Effective policy": each level is the person grant's when it sets one; otherwise, for `ask` and
- * `agentMail`, the most permissive among the grants of channels the sender is in; otherwise the relation's
- * default. An expired `trustedUntil` reads as absent. The caller passes only grants whose signer is current.
+ * `agentMail`, the most permissive among the grants of channels the sender is in; otherwise the relation's level
+ * under the person's reach choices (`baseLevels`). An expired `trustedUntil` reads as absent. The caller passes only
+ * grants whose signer is current.
  */
-export declare function effectivePolicy(relation: Exclude<Relation, "self">, person: GrantLevels | undefined, channels: readonly GrantLevels[], now: number): EffectivePolicy;
+export declare function effectivePolicy(relation: Exclude<Relation, "self">, person: GrantLevels | undefined, channels: readonly GrantLevels[], now: number, reach?: ReachChoices): EffectivePolicy;
 /**
  * What arrived, classified by the receiver (spec §6.9, "Enforcement"):
  * - `answer`: a receipt, a task update or cancel, or a message the counterpart binding ties to this person's own
@@ -114,6 +132,8 @@ export interface DecideArgs {
     grant?: GrantLevels;
     /** Grants of channels the sender is in, in the receiver's own view, each with a current signer. */
     channels: readonly GrantLevels[];
+    /** The receiving person's reach choices (their current relation grants); absent, the relation defaults. */
+    reach?: ReachChoices;
     inbound: Inbound;
     now: number;
 }
@@ -121,12 +141,15 @@ export interface DecideArgs {
  * Spec §6.9, "Enforcement": step 10 of the receiver order (§5), before the inbound policy of §8.3.
  * - The person's own traffic is delivered as `self`.
  * - Answers to the person's own traffic are delivered whatever the grants, so a change never strands a task.
- * - A `blocked` chat level refuses every other class from the sender.
- * - A `stranger` reaches the person only through a level a grant opened; otherwise `request_required`.
+ * - A `blocked` chat level from the person grant refuses every other class from the sender.
+ * - A `blocked` chat level from the reach choice Never refuses the sender's lines, message requests and channel
+ *   changes, `refused`; agent mail and asks follow their own levels, so a grant that opened them still counts.
+ * - A `stranger` reaches the person only through a level a grant or a choice opened; otherwise `request_required`.
  * - Lines follow `chat` (person) or `agentMail` (agent); `muted` delivers silently.
  * - Asks follow `ask`: `open` delivers guarded, or trusted while the person grant trusts the sender and every person
  *   in the delegation chain is the sender or the receiver; `request` holds; `no` refuses, `request_required` when
- *   it is the default of a `contact` or a `stranger`.
- * - A message request from a `stranger` is held for the person to accept; from anyone else it is a DM line.
+ *   it is the default of a `contact` or a `stranger` and the person has not chosen Never for messages.
+ * - A message request is held for the person while `chat` is `request_required` (a `stranger` under Ask me first);
+ *   otherwise it is a DM line.
  */
 export declare function decide(args: DecideArgs): ConsentDecision;

package/dist/types/core/contact-card.d.ts

@@ -1,4 +1,4 @@
-import { type Relation } from "./consent.js";
+import { type ReachChoices, type Relation } from "./consent.js";
 import type { Identity } from "./identity.js";
 import { type PersonId, type Ulid } from "./schema/common.js";
 import { type CardCan, ContactCard, type GrantLevels } from "./schema/consent.js";
@@ -29,6 +29,6 @@ export declare function verifyContactCard(raw: unknown, ctx: {
 }): ContactCard;
 /**
  * What a card says for a sender of `relation` with the person grant `grant` (spec §6.9, "Contact cards"): the
- * person grant over the relation's defaults. Channel grants are not on a card: the sender knows its own channels.
+ * person grant over the relation's level under the person's reach choices. Channel grants are not on a card: the sender knows its own channels.
  */
-export declare function cardCan(relation: Exclude<Relation, "self">, grant: GrantLevels | undefined, now: number): CardCan;
+export declare function cardCan(relation: Exclude<Relation, "self">, grant: GrantLevels | undefined, now: number, reach?: ReachChoices): CardCan;

package/dist/types/core/conversation-agent-tools.d.ts

@@ -260,6 +260,7 @@ export declare const ConversationTools: {
                     jelly_unavailable: "jelly_unavailable";
                     log_conflict: "log_conflict";
                     conv_conflict: "conv_conflict";
+                    conflict: "conflict";
                     stale_epoch: "stale_epoch";
                     device_limit: "device_limit";
                     admission_required: "admission_required";
@@ -496,6 +497,16 @@ export declare const ConversationTools: {
                         peer: "peer";
                         ours: "ours";
                     }>>;
+                    signIn: z.ZodOptional<z.ZodObject<{
+                        tool: z.ZodOptional<z.ZodString>;
+                        by: z.ZodEnum<{
+                            you: "you";
+                            them: "them";
+                        }>;
+                    }, z.core.$strip>>;
+                    refusal: z.ZodOptional<z.ZodObject<{
+                        reason: z.ZodString;
+                    }, z.core.$strip>>;
                     createdAt: z.ZodString;
                     updatedAt: z.ZodString;
                     consent: z.ZodOptional<z.ZodEnum<{
@@ -832,6 +843,16 @@ export declare const ConversationTools: {
                     trusted: "trusted";
                 }>>;
                 updatedAt: z.ZodString;
+                signIn: z.ZodOptional<z.ZodObject<{
+                    tool: z.ZodOptional<z.ZodString>;
+                    by: z.ZodEnum<{
+                        you: "you";
+                        them: "them";
+                    }>;
+                }, z.core.$strip>>;
+                refusal: z.ZodOptional<z.ZodObject<{
+                    reason: z.ZodString;
+                }, z.core.$strip>>;
                 title: z.ZodOptional<z.ZodString>;
                 counterpart: z.ZodString;
                 titleAuthor: z.ZodOptional<z.ZodEnum<{

package/dist/types/core/index.d.ts

@@ -31,7 +31,7 @@ export { MerkleLog, merkleLeafHash, verifyConsistency, verifyInclusion } from ".
 export { MAP_DEPTH, SparseMerkleTree, TOMBSTONE, emptyMapHash, mapKey, mapRootFromProof, mapValue, verifyMapProof } from "./directory/smt.js";
 export { parseAddress, formatAddress, type ParsedAddress } from "./address.js";
 export { decodeAdmitCard, decodeTeamCard, encodeAdmitCard, encodeTeamCard, type AdmitCard, type TeamCard, } from "./cards.js";
-export { decide, effectivePolicy, grantSubjectKey, levelsOf, preferGrant, resignGrant, restrictingLevels, signConsentGrant, verifyConsentGrant, wideningLevels, type ConsentClass, type ConsentDecision, type ConsentGrantArgs, type DecideArgs, type EffectivePolicy, type Inbound, type Relation, } from "./consent.js";
+export { decide, effectivePolicy, grantSubjectKey, levelsOf, preferGrant, reachChoices, reachGrant, resignGrant, restrictingLevels, signConsentGrant, verifyConsentGrant, wideningLevels, type ConsentClass, type ConsentDecision, type ConsentGrantArgs, type DecideArgs, type EffectivePolicy, type Inbound, type ReachChoices, type Relation, } from "./consent.js";
 export { cardCan, signContactCard, verifyContactCard, type ContactCardArgs } from "./contact-card.js";
 export { createGrant, verifyChain, type GrantArgs, type ChainHop, type ChainContext, type VerifiedChain } from "./delegation.js";
 export { canTransition, isTerminal, isInterrupted } from "./task.js";

package/dist/types/core/schema/common.d.ts

@@ -66,6 +66,8 @@ export declare const URI: {
     readonly binding: "urn:messaging:binding:relay:v1";
     readonly provenance: "urn:messaging:ext:provenance:v1";
     readonly presence: "urn:messaging:ext:presence:v1";
+    /** An `AUTH_REQUIRED` status message's `metadata[URI.signIn]`: `{tool}`, the tool whose sign-in the task waits on (spec §6.2). */
+    readonly signIn: "urn:messaging:ext:sign-in:v1";
 };
 export declare const Base64Url: z.ZodString;
 /** Any 32-byte value in base64url, e.g. a raw public key. */

package/dist/types/core/schema/consent.d.ts

@@ -24,18 +24,34 @@ export declare const AskLevel: z.ZodEnum<{
     no: "no";
 }>;
 export type AskLevel = z.infer<typeof AskLevel>;
-/** Whom a grant is about: one person, or the verified participants of one conversation. */
+/**
+ * The relations a reach choice is about (spec §6.9, "Reach choices"): `outside`, the people of other orgs (`contact`
+ * and `stranger`), whose `chat` the person's "Who can message you" sets; `org`, the person's teammates, whose `ask`
+ * their "How agents may ask yours" sets.
+ */
+export declare const GrantRelation: z.ZodEnum<{
+    org: "org";
+    outside: "outside";
+}>;
+export type GrantRelation = z.infer<typeof GrantRelation>;
+/** Whom a grant is about: one person, the verified participants of one conversation, or one relation (a reach choice). */
 export declare const GrantSubject: z.ZodUnion<readonly [z.ZodObject<{
     person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
 }, z.core.$strict>, z.ZodObject<{
     conv: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    relation: z.ZodEnum<{
+        org: "org";
+        outside: "outside";
+    }>;
 }, z.core.$strict>]>;
 export type GrantSubject = z.infer<typeof GrantSubject>;
 /**
  * A grant, signed by `by`, a device of `person`: `sig = Ed25519(by, "messaging/1/grant\n" || JCS(grant without sig))`.
  * Every level is optional: an absent level is the default for the relation (spec §6.9, "Effective policy"), and a
  * grant with none is a clear. `trustedUntil` needs `ask: "open"` and is at most `ts + LIMITS.trustMaxMs`. A channel
- * grant sets only `ask` and `agentMail`. A grant about the person themself sets only `discoverable`.
+ * grant sets only `ask` and `agentMail`. A grant about the person themself sets only `discoverable`. A relation
+ * grant (a reach choice) sets only `chat` (`open` or `blocked`) for `outside`, and only `ask` for `org`.
  * `resignedAt` marks a grant re-signed by another device of the person (spec §6.9, "Signers"); it keeps `id` and
  * `ts`.
  */
@@ -50,6 +66,11 @@ export declare const ConsentGrant: z.ZodObject<{
         person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
     }, z.core.$strict>, z.ZodObject<{
         conv: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        relation: z.ZodEnum<{
+            org: "org";
+            outside: "outside";
+        }>;
     }, z.core.$strict>]>;
     chat: z.ZodOptional<z.ZodEnum<{
         open: "open";

package/dist/types/core/schema/conv-frames.d.ts

@@ -8,7 +8,7 @@
  *   conv.share {req, events}                     → conv.shared {req, cid, count}        key shares, one recipient each
  *   conv.fetch {req, cid, after, limit?, sharesAfter?} → conv.entries {req, cid, head, entries, shares, more}
  *   conv.head {req, cids? | after?}              → conv.heads {req, heads, more}
- *   conv.caps {req, persons}                     → conv.capabilities {req, outdated}   who cannot read conversations yet
+ *   conv.caps {req, persons}                     → conv.capabilities {req, outdated, unknown?}   who cannot read conversations yet
  *   relay → conv.push {cid, entry} | {cid, share}   a new entry to the members' online devices; a share to its recipient
  *
  * The relay sequences and filters; members verify everything (spec §16.4, §16.7). It never signs an entry.
@@ -828,11 +828,15 @@ export declare const ConvHeadsFrame: z.ZodObject<{
     more: z.ZodBoolean;
 }, z.core.$strict>;
 export type ConvHeadsFrame = z.infer<typeof ConvHeadsFrame>;
-/** `conv.caps`'s answer: the named persons that cannot read conversations yet. */
+/**
+ * `conv.caps`'s answer: the named persons that cannot read conversations yet, and, only when there are any, the
+ * persons it says nothing about (`unknown`: unrelated persons past the asker's daily budget).
+ */
 export declare const ConvCapabilitiesFrame: z.ZodObject<{
     t: z.ZodLiteral<"conv.capabilities">;
     req: z.ZodString;
     outdated: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+    unknown: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>>;
 }, z.core.$strict>;
 export type ConvCapabilitiesFrame = z.infer<typeof ConvCapabilitiesFrame>;
 /** A new entry, to the online devices of the conversation's participant persons; or a new share, to its recipient. */

package/dist/types/core/schema/directory-frames.d.ts

@@ -23,7 +23,7 @@
  *   dir.watch {req, persons}              → dir.ok {req}; then dir.changed {persons, sth} pushes
  *   presence.watch {req, persons}         → dir.ok {req}
  *   dir.erase {req, entries, token}       → dir.ok {req}
- *   wake.arm {req, url, ticket, agents, awaiting} → dir.ok {req}   a Jelly host's device, before it sleeps (§7, "Wake tickets")
+ *   wake.arm {req, url, ticket, agents, awaiting, dms?} → dir.ok {req}   a Jelly host's device, before it sleeps (§7, "Wake tickets")
  *   wake.disarm {req}                     → dir.ok {req}
  *   relay → dir.unbound {entry, sth}      this device's own unbind, just before close 4003
  *
@@ -363,6 +363,8 @@ export declare const DirEraseFrame: z.ZodObject<{
 /** Most agents a wake ticket's filter names, and most awaited task requests (spec §7, "Wake tickets"). */
 export declare const WAKE_AGENTS = 64;
 export declare const WAKE_AWAITING = 500;
+/** Most dm conversations a wake ticket's filter names (spec §7, "Wake tickets", "a peer's dm"). */
+export declare const WAKE_DMS = 256;
 /** Most bytes of a wake ticket, and its longest life: Jelly's `jelly-wake+jwt` lives at most seven days. */
 export declare const WAKE_TICKET_BYTES = 4096;
 export declare const WAKE_TICKET_MAX_S: number;
@@ -372,8 +374,9 @@ export declare const WakeUrl: z.ZodString;
  * A Jelly host's device arms a wake ticket before the host sleeps (spec §7, "Wake tickets"). `url` is Jelly ID's wake
  * endpoint for this device's host; `ticket` the host's single-use `jelly-wake+jwt`, which the relay never verifies
  * (Jelly ID does) and reads only for its `exp`; `agents` the local sessions whose own person's mail may wake the host;
- * `awaiting` the request envelope ids of the tasks those agents wait on, whose updates (`replyTo`) may wake it. A new
- * arm replaces the device's previous one.
+ * `awaiting` the request envelope ids of the tasks those agents wait on, whose updates (`replyTo`) may wake it; `dms`
+ * the dm conversations whose other participant's events may wake it (absent: none), which the host's daemon chose. A
+ * new arm replaces the device's previous one.
  */
 export declare const WakeArmFrame: z.ZodObject<{
     t: z.ZodLiteral<"wake.arm">;
@@ -382,6 +385,7 @@ export declare const WakeArmFrame: z.ZodObject<{
     ticket: z.ZodString;
     agents: z.ZodArray<z.ZodString>;
     awaiting: z.ZodArray<z.ZodString>;
+    dms: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 export type WakeArmFrame = z.infer<typeof WakeArmFrame>;
 /** The relay forgets this device's wake ticket. */
@@ -643,6 +647,7 @@ export declare const DirectoryClientFrame: z.ZodDiscriminatedUnion<[z.ZodObject<
     ticket: z.ZodString;
     agents: z.ZodArray<z.ZodString>;
     awaiting: z.ZodArray<z.ZodString>;
+    dms: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>, z.ZodObject<{
     t: z.ZodLiteral<"wake.disarm">;
     req: z.ZodString;

package/dist/types/core/schema/envelope.d.ts

@@ -392,6 +392,7 @@ export declare const ReceiptPayload: z.ZodObject<{
         jelly_unavailable: "jelly_unavailable";
         log_conflict: "log_conflict";
         conv_conflict: "conv_conflict";
+        conflict: "conflict";
         stale_epoch: "stale_epoch";
         device_limit: "device_limit";
         admission_required: "admission_required";
@@ -639,6 +640,7 @@ export declare const PAYLOAD_BY_TYPE: {
             jelly_unavailable: "jelly_unavailable";
             log_conflict: "log_conflict";
             conv_conflict: "conv_conflict";
+            conflict: "conflict";
             stale_epoch: "stale_epoch";
             device_limit: "device_limit";
             admission_required: "admission_required";

package/dist/types/core/schema/errors.d.ts

@@ -30,6 +30,7 @@ export declare const ErrorCode: z.ZodEnum<{
     jelly_unavailable: "jelly_unavailable";
     log_conflict: "log_conflict";
     conv_conflict: "conv_conflict";
+    conflict: "conflict";
     stale_epoch: "stale_epoch";
     device_limit: "device_limit";
     admission_required: "admission_required";
@@ -98,6 +99,7 @@ export declare const ErrorBody: z.ZodObject<{
         jelly_unavailable: "jelly_unavailable";
         log_conflict: "log_conflict";
         conv_conflict: "conv_conflict";
+        conflict: "conflict";
         stale_epoch: "stale_epoch";
         device_limit: "device_limit";
         admission_required: "admission_required";