@saadnvd1/agent-os 0.3.779 → 0.3.780

package/app/api/live-shares/[id]/route.ts

@@ -7,16 +7,29 @@ import {
   deny,
   dismissSuggestion,
   endLive,
+  giveWheel,
   kick,
   sendSuggestion,
   startLive,
 } from "@/lib/live/service";
 
 const Action = z.discriminatedUnion("action", [
-  z.object({ action: z.literal("admit"), guestId: z.string().min(1).max(64) }),
+  z.object({
+    action: z.literal("admit"),
+    guestId: z.string().min(1).max(64),
+    drive: z.boolean().optional(),
+  }),
   z.object({ action: z.literal("deny"), guestId: z.string().min(1).max(64) }),
   z.object({ action: z.literal("kick"), guestId: z.string().min(1).max(64) }),
-  z.object({ action: z.literal("level"), level: z.enum(["watch", "suggest"]) }),
+  z.object({
+    action: z.literal("level"),
+    level: z.enum(["watch", "suggest", "drive"]),
+  }),
+  // Gives the wheel to an admitted guest of a Drive share; null takes it back.
+  z.object({
+    action: z.literal("wheel"),
+    guestId: z.string().min(1).max(64).nullable(),
+  }),
   z.object({
     action: z.literal("send"),
     suggestionId: z.string().min(1).max(64),
@@ -29,7 +42,8 @@ const Action = z.discriminatedUnion("action", [
 ]);
 
 // POST /api/live-shares/:id - the host's decisions: let a guest in, turn one
-// away, remove one, send a suggestion to the agent or dismiss it.
+// away, remove one, send a suggestion to the agent or dismiss it, change the
+// level, give or take back the wheel.
 export async function POST(
   request: Request,
   { params }: { params: Promise<{ id: string }> }
@@ -44,10 +58,11 @@ export async function POST(
   startLive();
   try {
     const a = body.data;
-    if (a.action === "admit") admit(id, a.guestId);
+    if (a.action === "admit") admit(id, a.guestId, { drive: a.drive });
     else if (a.action === "deny") deny(id, a.guestId);
     else if (a.action === "kick") kick(id, a.guestId);
     else if (a.action === "level") changeLevel(id, a.level);
+    else if (a.action === "wheel") giveWheel(id, a.guestId);
     else if (a.action === "send")
       await sendSuggestion(id, a.suggestionId, a.text);
     else dismissSuggestion(id, a.suggestionId);

package/app/api/live-shares/route.test.ts

@@ -43,9 +43,10 @@ describe("live-shares routes", () => {
     );
   });
 
-  it("accept watch and suggest only, and history as a boolean", async () => {
+  it("accept watch, suggest and drive, and history as a boolean", async () => {
+    // Past validation: not linked to Connect here, so 409, never 400.
     expect((await POST(req({ sessionId: "s", level: "drive" }))).status).toBe(
-      400
+      409
     );
     expect((await POST(req({ sessionId: "s", level: "root" }))).status).toBe(
       400
@@ -53,8 +54,28 @@ describe("live-shares routes", () => {
     expect((await POST(req({ sessionId: "s", history: "yes" }))).status).toBe(
       400
     );
+    // A level for a share this machine doesn't hold: 404, so it validated.
     expect(
       (await act(req({ action: "level", level: "drive" }), ctx)).status
+    ).toBe(404);
+    expect(
+      (await act(req({ action: "level", level: "admin" }), ctx)).status
     ).toBe(400);
   });
+
+  it("validate the wheel and admit-to-drive actions", async () => {
+    for (const body of [
+      { action: "wheel" },
+      { action: "wheel", guestId: 7 },
+      { action: "wheel", guestId: "" },
+      { action: "admit", guestId: "g", drive: "yes" },
+    ])
+      expect((await act(req(body), ctx)).status).toBe(400);
+    for (const body of [
+      { action: "wheel", guestId: "g1" },
+      { action: "wheel", guestId: null },
+      { action: "admit", guestId: "g", drive: true },
+    ])
+      expect((await act(req(body), ctx)).status).toBe(404);
+  });
 });

package/app/api/live-shares/route.ts

@@ -7,7 +7,7 @@ import { createLive, inviteFor, listLive, startLive } from "@/lib/live/service";
 const Create = z.object({
   sessionId: z.string().min(1).max(100),
   expiresIn: z.enum(["1h", "session"]).default("1h"),
-  level: z.enum(["watch", "suggest"]).default("suggest"),
+  level: z.enum(["watch", "suggest", "drive"]).default("suggest"),
   history: z.boolean().default(true),
 });
 

package/components/Chat/Approval.tsx

@@ -1,7 +1,7 @@
 "use client";
 
 import { useState } from "react";
-import { MessageCircleQuestion, ShieldQuestion } from "lucide-react";
+import { MessageCircleQuestion, ShieldQuestion, Users } from "lucide-react";
 import { Button } from "@/components/ui/button";
 import type { ApprovalDecision, ChatItem } from "@/lib/chat/events";
 import { cn } from "@/lib/utils";
@@ -20,6 +20,17 @@ function AccessCard({
 }) {
   return (
     <div className="bg-primary/[0.06] space-y-3 rounded-xl p-3">
+      {item.guest && (
+        <p className="text-muted-foreground flex items-center gap-1.5 text-xs">
+          <Users className="h-3.5 w-3.5 shrink-0" aria-hidden />
+          <span className="min-w-0 truncate">
+            <span className="text-foreground font-medium">
+              {item.guest.name}&apos;s turn
+            </span>{" "}
+            · a live guest asked for this
+          </span>
+        </p>
+      )}
       <div className="flex items-start gap-2 text-sm">
         <ShieldQuestion className="text-primary mt-0.5 h-4 w-4 shrink-0" />
         <span className="min-w-0 break-words">{item.title}</span>
@@ -33,7 +44,7 @@ function AccessCard({
         >
           Deny
         </Button>
-        {item.canAlways && (
+        {item.canAlways && !item.guest && (
           <Button
             variant="secondary"
             className="h-11 md:h-9"

package/components/Chat/EventRow.tsx

@@ -29,6 +29,7 @@ export const ICON: Record<ChatOriginKind, LucideIcon> = {
   decision: UserCheck,
   device: Smartphone,
   guest: Users,
+  "guest-drive": Users,
 };
 
 // Longer than this (what fits beside a source on a phone), or more than one line,
@@ -183,6 +184,10 @@ export function EventRow({
               <span className="truncate font-medium">
                 Suggested by {origin.label}
               </span>
+            ) : origin.kind === "guest-drive" ? (
+              <span className="truncate font-medium">
+                Prompted by {origin.label}
+              </span>
             ) : (
               <Source origin={origin} />
             )

package/components/Chat/Queue.tsx

@@ -53,7 +53,15 @@ export function Queue({
             <span className="text-muted-foreground w-5 shrink-0 pt-3 text-center text-xs tabular-nums">
               {i + 1}
             </span>
-            {editing?.id === m.id ? (
+            {m.guest ? (
+              // A driving guest's prompt: theirs to word, the host's to remove.
+              <div className="min-h-11 min-w-0 flex-1 px-2 py-2.5 text-sm break-words whitespace-pre-wrap">
+                <span className="text-muted-foreground block text-xs">
+                  {m.guest.name} (guest)
+                </span>
+                <span className="line-clamp-3">{m.guest.body}</span>
+              </div>
+            ) : editing?.id === m.id ? (
               <textarea
                 autoFocus
                 value={editing.text}
@@ -99,20 +107,24 @@ export function Queue({
               </button>
             )}
             <div className="flex shrink-0 items-center">
-              <IconButton
-                label="Send now"
-                onClick={() => onSendNow(m.id)}
-                className="text-foreground"
-              >
-                <SendHorizontal className="h-4 w-4" />
-              </IconButton>
-              <IconButton
-                label="Edit"
-                onClick={() => setEditing({ id: m.id, text: m.text })}
-                className="max-md:hidden"
-              >
-                <Pencil className="h-3.5 w-3.5" />
-              </IconButton>
+              {!m.guest && (
+                <>
+                  <IconButton
+                    label="Send now"
+                    onClick={() => onSendNow(m.id)}
+                    className="text-foreground"
+                  >
+                    <SendHorizontal className="h-4 w-4" />
+                  </IconButton>
+                  <IconButton
+                    label="Edit"
+                    onClick={() => setEditing({ id: m.id, text: m.text })}
+                    className="max-md:hidden"
+                  >
+                    <Pencil className="h-3.5 w-3.5" />
+                  </IconButton>
+                </>
+              )}
               <IconButton
                 label="Move up"
                 disabled={i === 0}

package/components/Live/DriveBanner.tsx

@@ -0,0 +1,42 @@
+"use client";
+
+import { Hand, Users } from "lucide-react";
+import { Button } from "@/components/ui/button";
+import type { LiveView } from "@/data/live";
+
+// A guest holds the wheel: what they're doing, and the host's way back.
+export function DriveBanner({
+  banner,
+  busy,
+  onTakeBack,
+}: {
+  banner: NonNullable<LiveView["banner"]>;
+  busy: boolean;
+  onTakeBack: () => void;
+}) {
+  return (
+    <div
+      role="status"
+      className="bg-primary/[0.06] flex items-center gap-2 rounded-xl py-1 pr-1 pl-3 shadow-sm"
+    >
+      <Users className="text-primary h-4 w-4 shrink-0" aria-hidden />
+      <div className="min-w-0 flex-1 text-sm">
+        <p className="leading-snug font-medium">{banner.text}</p>
+        <p className="text-muted-foreground truncate text-xs max-sm:hidden">
+          Every edit, command and outside read asks you first.
+        </p>
+      </div>
+      {banner.action && (
+        <Button
+          variant="outline"
+          className="min-h-11 shrink-0"
+          disabled={busy}
+          onClick={onTakeBack}
+        >
+          <Hand className="h-4 w-4" aria-hidden />
+          {banner.action.label}
+        </Button>
+      )}
+    </div>
+  );
+}

package/components/Live/LivePanel.tsx

@@ -3,12 +3,14 @@
 import { toast } from "sonner";
 import { useEndLive, useLiveAction, useLiveShare } from "@/data/live";
 import { liveUiActions } from "@/stores/liveUi";
+import { DriveBanner } from "./DriveBanner";
 import { GuestPromptCard } from "./GuestPromptCard";
 import { LiveChip } from "./LiveChip";
 import { LobbyCard } from "./LobbyCard";
 
 // Above the composer while a session has a live link: the Live chip, who is
-// waiting to come in, and the suggestions to send, edit or dismiss.
+// driving, who is waiting to come in, and the suggestions to send, edit or
+// dismiss.
 export function LivePanel({
   sessionId,
   title,
@@ -28,6 +30,12 @@ export function LivePanel({
   const doAction = (guestId: string, kind: string) => {
     if (kind === "admit" || kind === "deny" || kind === "kick")
       act.mutate({ action: kind, guestId }, { onError: fail });
+    else if (kind === "admit_drive")
+      act.mutate({ action: "admit", guestId, drive: true }, { onError: fail });
+    else if (kind === "give_wheel")
+      act.mutate({ action: "wheel", guestId }, { onError: fail });
+    else if (kind === "take_back")
+      act.mutate({ action: "wheel", guestId: null }, { onError: fail });
   };
   const lobby = share.guests.filter((g) => g.status === "pending");
   return (
@@ -42,6 +50,15 @@ export function LivePanel({
         onEnd={() => end.mutate(undefined, { onError: fail })}
         onInvite={() => liveUiActions.open(sessionId, title)}
       />
+      {share.banner && share.driver && (
+        <DriveBanner
+          banner={share.banner}
+          busy={busy}
+          onTakeBack={() =>
+            act.mutate({ action: "wheel", guestId: null }, { onError: fail })
+          }
+        />
+      )}
       {lobby.map((g) => (
         <LobbyCard
           key={g.id}

package/data/live/queries.ts

@@ -63,7 +63,9 @@ export function useCreateLive() {
 }
 
 export type LiveAction =
-  | { action: "admit" | "deny" | "kick"; guestId: string }
+  | { action: "admit"; guestId: string; drive?: boolean }
+  | { action: "deny" | "kick"; guestId: string }
+  | { action: "wheel"; guestId: string | null }
   | { action: "level"; level: LiveLevel }
   | { action: "send"; suggestionId: string; text?: string }
   | { action: "dismiss"; suggestionId: string };

package/lib/chat/driver.ts

@@ -2,6 +2,7 @@ import type {
   McpServerConfig,
   PermissionMode,
 } from "@anthropic-ai/claude-agent-sdk";
+import type { GuestGate } from "./worker/guest-gate";
 import type {
   ApprovalDecision,
   ChatAccess,
@@ -60,6 +61,9 @@ export interface ChatStartOptions {
   // refused, null to let it go on to them, or a warning the agent is shown
   // while the call still goes on.
   toolGuard?: ToolGuard;
+  // Holds a live guest's turn to the host's taps (./worker/guest-gate). A
+  // driver without it can't take Drive prompts (the worker's caps say so).
+  guestGate?: GuestGate;
   // The note handed back to the agent right after its context is compacted
   // (lib/chat/compact-context), empty for none. Only Claude Code has a hook
   // for it; other drivers ignore it.

package/lib/chat/drivers/claude-approvals.ts

@@ -15,6 +15,7 @@ import type {
 } from "../events";
 import { toolDiff, toolTitle } from "../tools";
 import type { ToolGuard } from "../driver";
+import { guestGateHook, type GuestGate } from "../worker/guest-gate";
 
 type Approval = Extract<ChatItem, { kind: "approval" }>;
 
@@ -101,45 +102,94 @@ export class Approvals {
     private planFile: () => string | undefined = () => undefined
   ) {}
 
+  // Who steers the running turn, when a live guest does (lib/chat/worker/
+  // guest-gate): every card it raises is theirs, with no Always.
+  guestOf: () => { name: string } | null = () => null;
+  // Calls the guest gate let through, by tool use id: the permission prompt
+  // that may follow for one is already answered.
+  private gatePassed = new Set<string>();
+
   canUseTool: CanUseTool = (toolName, input, options) => {
     // Already answered on its card by the question hook.
     if (toolName === "AskUserQuestion" && "answers" in input)
       return Promise.resolve({ behavior: "allow", updatedInput: input });
+    if (options.toolUseID && this.gatePassed.delete(options.toolUseID))
+      return Promise.resolve({ behavior: "allow", updatedInput: input });
     const questions =
       toolName === "AskUserQuestion"
         ? ((input as { questions?: ChatQuestion[] }).questions ?? [])
         : undefined;
-    const item: Approval = {
-      id: `approval-${options.toolUseID}`,
-      kind: "approval",
-      toolName,
-      title: options.title ?? toolTitle(toolName, input),
-      input,
-      diff: toolDiff(toolName, input),
-      questions,
-      canAlways:
-        !questions &&
-        !!options.suggestions?.length &&
-        !options.suppressAlwaysAllowRule,
-      status: "pending",
-      createdAt: Date.now(),
-    };
+    const guest = this.guestOf() ?? undefined;
+    return this.ask(
+      {
+        id: `approval-${options.toolUseID}`,
+        kind: "approval",
+        toolName,
+        title: options.title ?? toolTitle(toolName, input),
+        input,
+        diff: toolDiff(toolName, input),
+        questions,
+        canAlways:
+          !guest &&
+          !questions &&
+          !!options.suggestions?.length &&
+          !options.suppressAlwaysAllowRule,
+        status: "pending",
+        createdAt: Date.now(),
+        ...(guest && { guest }),
+      },
+      options.signal,
+      guest ? undefined : options.suggestions
+    );
+  };
+
+  // A step of a guest-steered turn: the host's card, never Always.
+  askGuest(
+    toolName: string,
+    input: Record<string, unknown>,
+    toolUseID: string,
+    signal: AbortSignal,
+    guest: { name: string }
+  ): Promise<PermissionResult> {
+    return this.ask(
+      {
+        id: `approval-${toolUseID}`,
+        kind: "approval",
+        toolName,
+        title: toolTitle(toolName, input),
+        input,
+        diff: toolDiff(toolName, input),
+        canAlways: false,
+        status: "pending",
+        createdAt: Date.now(),
+        guest,
+      },
+      signal
+    );
+  }
+
+  passed(toolUseID: string): void {
+    if (toolUseID) this.gatePassed.add(toolUseID);
+  }
+
+  private ask(
+    item: Approval,
+    signal: AbortSignal,
+    suggestions?: Parameters<CanUseTool>[2]["suggestions"]
+  ): Promise<PermissionResult> {
     return new Promise<PermissionResult>((resolve) => {
-      this.pending.set(item.id, {
-        item,
-        suggestions: options.suggestions,
-        resolve,
-      });
-      options.signal.addEventListener("abort", () => {
+      this.pending.set(item.id, { item, suggestions, resolve });
+      const expire = () =>
         this.settle(item.id, "expired", {
           behavior: "deny",
           message: DENIED,
         });
-      });
+      if (signal.aborted) return queueMicrotask(expire);
+      signal.addEventListener("abort", expire);
       this.emit({ type: "item", item });
       this.emit({ type: "state", state: "waiting" });
     });
-  };
+  }
 
   // Full access approves every tool before canUseTool is asked, questions
   // included, so the agent's questions come through this hook instead.
@@ -209,11 +259,14 @@ export class Approvals {
     } else if (answer.decision === "deny") {
       this.settle(id, "denied", { behavior: "deny", message: DENIED });
     } else {
+      // A guest's card has no Always: an "always" answer is a plain allow.
       this.settle(id, "allowed", {
         behavior: "allow",
         updatedInput: input,
         updatedPermissions:
-          answer.decision === "always" ? p.suggestions : undefined,
+          answer.decision === "always" && !p.item.guest
+            ? p.suggestions
+            : undefined,
       });
     }
   }
@@ -270,9 +323,24 @@ export function guardHook(guard: ToolGuard): HookCallback {
 export function preToolUseHooks(
   approvals: Approvals,
   guard?: ToolGuard,
-  subagentModels?: HookCallback | null
+  subagentModels?: HookCallback | null,
+  // A live guest's turn: every call but a worktree read waits for the host.
+  guest?: { gate: GuestGate; cwd: string }
 ): HookCallbackMatcher[] {
+  if (guest)
+    approvals.guestOf = () =>
+      guest.gate.steer ? { name: guest.gate.steer.name } : null;
   return [
+    // First, and on every tool: no steer, no effect. It waits on the host
+    // for as long as the card is up (the turn's own cap ends it sooner).
+    ...(guest
+      ? [
+          {
+            hooks: [guestGateHook(approvals, guest.gate, guest.cwd)],
+            timeout: 24 * 60 * 60,
+          },
+        ]
+      : []),
     // Sets the model of a subagent call by its type. It only fills in the
     // input, so the guard and permissions below still see the call.
     ...(subagentModels

package/lib/chat/drivers/claude.ts

@@ -222,7 +222,8 @@ export const claudeDriver: ChatDriver = {
           PreToolUse: preToolUseHooks(
             approvals,
             options.toolGuard,
-            subagentHook(options.env)
+            subagentHook(options.env),
+            options.guestGate && { gate: options.guestGate, cwd: options.cwd }
           ),
           ...(options.compactContext && {
             SessionStart: compactedHooks(options.compactContext),

package/lib/chat/events.ts

@@ -84,7 +84,12 @@ export type ChatOriginKind =
   | "device"
   // A suggestion from a guest on a live link, sent by the reader after
   // reading it. Its label is the guest's name.
-  | "guest";
+  | "guest"
+  // A prompt from the guest holding the wheel on a Drive live link: it went
+  // in without the host's tap, so every step it takes past reading the
+  // task's files waits for one (lib/chat/worker/guest-gate). Its body is
+  // the guest's own text; the agent got it framed as a stranger's.
+  | "guest-drive";
 
 export interface ChatOrigin {
   kind: ChatOriginKind;
@@ -102,6 +107,11 @@ export interface ChatOrigin {
   // Only Away mode's own lines: the turn it starts isn't anyone's activity
   // (lib/away/activity).
   away?: true;
+  // A guest-drive message: the live share, the guest it came from, and the
+  // wheel it was sent under (a new one each time the host gives it).
+  share?: string;
+  guestId?: string;
+  wheel?: string;
 }
 
 // Who sent a message, carried with it through the queue and the worker.
@@ -109,6 +119,10 @@ export interface SentBy {
   from?: string;
   peer?: PeerMessage;
   origin?: ChatOrigin;
+  // The host sent it themselves: set only by their own composer and taps
+  // (never by an agent, event or schedule). Only such a message ends a live
+  // guest's steer (lib/chat/worker/guest-gate).
+  host?: true;
 }
 
 export interface McpServerView {
@@ -285,6 +299,9 @@ export type ChatItem =
       status: "pending" | "allowed" | "denied" | "answered" | "expired";
       // Allowed by No approvals mode, not by the reader.
       auto?: boolean;
+      // Asked in a turn a live guest steered: only the reader's tap answers
+      // it (never No approvals mode), and it has no Always.
+      guest?: { name: string };
     })
   | (Base & {
       // Work the agent runs alongside the turn: a background shell, a
@@ -323,6 +340,9 @@ export interface QueuedMessage {
   imageCount?: number;
   fileCount?: number;
   createdAt: number;
+  // A live guest's Drive prompt: who it's from and what they typed (the
+  // text is what the agent gets, framed).
+  guest?: { name: string; body: string };
 }
 
 // A file or folder the agent would match for an @mention.

package/lib/chat/queued.ts

@@ -26,7 +26,7 @@ export function listQueue(sessionId: string): QueuedMessage[] {
   return (
     db
       .prepare(
-        `SELECT id, text, image_count, files, created_at
+        `SELECT id, text, image_count, files, sent_by, created_at
          FROM chat_queue WHERE session_id = ? ORDER BY position, created_at`
       )
       .all(sessionId) as {
@@ -34,15 +34,57 @@ export function listQueue(sessionId: string): QueuedMessage[] {
       text: string;
       image_count: number;
       files: string | null;
+      sent_by: string | null;
       created_at: number;
     }[]
-  ).map((r) => ({
-    id: r.id,
-    text: r.text,
-    imageCount: r.image_count || undefined,
-    fileCount: r.files ? (JSON.parse(r.files) as unknown[]).length : undefined,
-    createdAt: r.created_at,
-  }));
+  ).map((r) => {
+    const o = r.sent_by ? (JSON.parse(r.sent_by) as SentBy).origin : undefined;
+    return {
+      id: r.id,
+      text: r.text,
+      imageCount: r.image_count || undefined,
+      fileCount: r.files
+        ? (JSON.parse(r.files) as unknown[]).length
+        : undefined,
+      createdAt: r.created_at,
+      ...(o?.kind === "guest-drive"
+        ? { guest: { name: o.label, body: o.body ?? r.text } }
+        : {}),
+    };
+  });
+}
+
+// Who sent the message that goes next, without taking it.
+export function peekNextSentBy(sessionId: string): SentBy | null {
+  const row = db
+    .prepare(
+      `SELECT sent_by FROM chat_queue WHERE session_id = ? ORDER BY position, created_at LIMIT 1`
+    )
+    .get(sessionId) as { sent_by: string | null } | undefined;
+  if (!row) return null;
+  return row.sent_by ? (JSON.parse(row.sent_by) as SentBy) : {};
+}
+
+// Drops every queued message whose sender matches; returns the ids dropped.
+export function deleteQueuedWhere(
+  sessionId: string,
+  match: (by: SentBy) => boolean
+): string[] {
+  return db.transaction(() => {
+    const rows = db
+      .prepare(
+        `SELECT id, sent_by FROM chat_queue WHERE session_id = ? AND sent_by IS NOT NULL`
+      )
+      .all(sessionId) as { id: string; sent_by: string }[];
+    const ids = rows
+      .filter((r) => match(JSON.parse(r.sent_by) as SentBy))
+      .map((r) => r.id);
+    const del = db.prepare(
+      `DELETE FROM chat_queue WHERE session_id = ? AND id = ?`
+    );
+    for (const id of ids) del.run(sessionId, id);
+    return ids;
+  })();
 }
 
 // At the back. A retried send with the same id is only queued once.
@@ -56,7 +98,12 @@ export function enqueue(
   } & SentBy
 ): void {
   const images = m.images?.length ? JSON.stringify(m.images) : null;
-  const sentBy: SentBy = { from: m.from, peer: m.peer, origin: m.origin };
+  const sentBy: SentBy = {
+    from: m.from,
+    peer: m.peer,
+    origin: m.origin,
+    host: m.host,
+  };
   if (m.text.length > MAX_QUEUED_TEXT)
     throw new Error("That message is too long to queue");
   if (images && images.length > MAX_QUEUED_IMAGES)
@@ -77,7 +124,7 @@ export function enqueue(
     images,
     m.images?.length ?? 0,
     m.files?.length ? JSON.stringify(m.files) : null,
-    m.from || m.peer || m.origin ? JSON.stringify(sentBy) : null,
+    m.from || m.peer || m.origin || m.host ? JSON.stringify(sentBy) : null,
     Date.now()
   );
 }