zas-agent 0.8.0 → 0.10.0

package/dist/cli.js

@@ -123,7 +123,16 @@ var RENAMES = {
   // agent (expired, or cancelled from the receiving side); `direct_too_big`
   // is the plan's Directo ceiling.
   not_live: "direct_cancelled",
-  direct_too_big: "file_too_big"
+  direct_too_big: "file_too_big",
+  // The item-change routes. `not_allowed` there means the item is not this
+  // agent's; a share of any kind, armed or not, is the one reason a replace
+  // is refused that the owner fixes from the item itself.
+  not_allowed: "not_yours",
+  shared: "item_shared",
+  bar_armed: "item_shared",
+  // An organization whose plan stopped pauses every send in its channels.
+  // Retrying cannot help; only the owner or a billing admin can.
+  enterprise_plan_inactive: "plan_inactive"
 };
 var ZasError = class extends Error {
   constructor(code, status, message, retryAfterMs, serverCode) {
@@ -178,9 +187,15 @@ var SENTENCES = {
   fallback_unavailable: "Reliable delivery is not available right now. Try again later.",
   key_stale: "The channel key changed. The owner refreshes it by opening Zas.",
   quota_exceeded: "The account reached its storage limit.",
+  plan_inactive: "The organization's plan is inactive, so sending to its channels is paused. The owner or a billing admin reactivates it in Zas.",
   rate_limited: "Too many sends in a row. Wait a moment.",
   file_too_big: "The file is over the plan limit.",
   duplicate: "That item is already in the channel.",
+  not_yours: "That item was not sent by this agent. It can only change its own items.",
+  stale: "That item changed while this agent was working on it. Read it again and retry.",
+  not_a_note: "That item is a file, not a note. Only its title can change; use zas_replace_file for the bytes.",
+  not_a_file: "That item is a note, not a file. Use zas_edit_item.",
+  item_shared: "That item has a public share. The owner removes the share first.",
   pairing_expired: "The pairing expired. Run \u201Czas-agent pair\u201D again.",
   pairing_cancelled: "The owner cancelled the pairing.",
   claim_mismatch: "The code does not match. Try again.",
@@ -282,8 +297,8 @@ function loadIdentity(profile) {
 function saveIdentity(profile, identity) {
   writePrivate(profileDir(profile), IDENTITY_FILE, identity);
 }
-function savePending(profile, pending) {
-  writePrivate(profileDir(profile), PENDING_FILE, pending);
+function savePending(profile, pending2) {
+  writePrivate(profileDir(profile), PENDING_FILE, pending2);
 }
 function clearPending(profile) {
   rmSync(join(profileDir(profile), PENDING_FILE), { force: true });
@@ -533,6 +548,24 @@ var ZasClient = class _ZasClient {
     }
     await this.pendingSignIn;
   }
+  telemetrySending = false;
+  /** Optional traffic must never initiate or invalidate the shared auth session.
+   * One bounded request, no retries, and no response body parsing. */
+  async reportTelemetry(body) {
+    const session2 = this.session;
+    if (this.telemetrySending || !session2 || session2.expiresAt <= this.now() + REFRESH_MARGIN_MS) return;
+    this.telemetrySending = true;
+    try {
+      const res = await this.call(`${this.identity.api_base}/v1/agents/telemetry`, {
+        ...jsonInit("POST", body, { Authorization: `Bearer ${session2.idToken}` }),
+        signal: AbortSignal.timeout(2e3)
+      });
+      await res.body?.cancel().catch(() => void 0);
+    } catch {
+    } finally {
+      this.telemetrySending = false;
+    }
+  }
   async api(method, path, body, headers = {}) {
     const res = await this.authedRetrying(`${this.identity.api_base}/v1${path}`, method, body, headers);
     const parsed = res.status === 204 ? void 0 : await readBody2(res);
@@ -717,7 +750,7 @@ async function runPair(opts) {
   try {
     const port = listener?.port;
     const link = pairUrl(opts.webBase, created.pairing_id, port);
-    const pending = {
+    const pending2 = {
       version: 1,
       profile: opts.profile,
       pairing_id: created.pairing_id,
@@ -732,7 +765,7 @@ async function runPair(opts) {
       protocol: 2,
       ...port ? { port } : {}
     };
-    savePending(opts.profile, pending);
+    savePending(opts.profile, pending2);
     const minutesLeft = Math.max(0, Math.round((created.expires_at - now()) / 6e4));
     opts.log(
       [
@@ -1706,116 +1739,857 @@ function startReceiver(opts) {
   };
 }
 
-// src/direct.ts
-import { randomBytes } from "node:crypto";
-import { openAsBlob } from "node:fs";
-import { basename as basename2 } from "node:path";
-
-// src/shared/manifest.ts
-import { xchacha20poly1305 } from "@noble/ciphers/chacha";
-function newManifest(partial) {
-  return { v: MANIFEST_VERSION, chunker: CHUNKER_VERSION, ...partial };
-}
-var ENVELOPE_MAGIC = 90;
-var KEY_VERSION_LEGACY = 1;
-function envelopeVersion(sealed) {
-  if (sealed.length > 26 && sealed[0] === ENVELOPE_MAGIC && sealed[1] >= 1) return sealed[1];
-  return KEY_VERSION_LEGACY;
-}
-function sealBytes(key, version, plain) {
-  if (version < 1 || version > 255) throw new Error("key version out of range");
-  const nonce = new Uint8Array(24);
-  crypto.getRandomValues(nonce);
-  const ct = xchacha20poly1305(key, nonce).encrypt(plain);
-  return concatBytes(new Uint8Array([ENVELOPE_MAGIC, version]), nonce, ct);
-}
-function openSealed(key, sealed) {
-  const versioned = envelopeVersion(sealed) !== KEY_VERSION_LEGACY || sealed[0] === ENVELOPE_MAGIC;
-  if (versioned && sealed.length > 26) {
-    try {
-      return xchacha20poly1305(key, sealed.slice(2, 26)).decrypt(sealed.slice(26));
-    } catch {
-    }
-  }
-  return xchacha20poly1305(key, sealed.slice(0, 24)).decrypt(sealed.slice(24));
-}
-var sealRaw = sealBytes;
-var openRaw = openSealed;
-function sealManifest(channelKey, manifest, version = KEY_VERSION_LEGACY) {
-  return sealBytes(channelKey, version, new TextEncoder().encode(JSON.stringify(manifest)));
-}
-function openManifest(channelKey, sealed) {
-  const m = JSON.parse(new TextDecoder().decode(openSealed(channelKey, sealed)));
-  if (!Array.isArray(m.chunks)) m.chunks = [];
-  return m;
-}
-function decryptChannelName(channelKey, sealed) {
-  return new TextDecoder().decode(openSealed(channelKey, sealed));
-}
+// src/transfer-telemetry.ts
+import { randomUUID } from "node:crypto";
 
-// src/file-source.ts
-import { promises as fsp, statSync } from "node:fs";
-async function readFileRange(path, start, length) {
-  const fh = await fsp.open(path, "r");
-  try {
-    const buf = Buffer.allocUnsafe(Math.max(0, length));
-    let read = 0;
-    while (read < length) {
-      const { bytesRead } = await fh.read(buf, read, length - read, start + read);
-      if (bytesRead === 0) break;
-      read += bytesRead;
-    }
-    const out = new Uint8Array(read);
-    out.set(buf.subarray(0, read));
-    return out.buffer;
-  } finally {
-    await fh.close();
-  }
+// src/shared/product-analytics.ts
+var PRODUCT_EVENTS = [
+  "account_created",
+  "item.created",
+  "item.downloaded",
+  "item.copied",
+  "item.shared",
+  "item.pinned",
+  "item.unpinned",
+  "item.deleted",
+  "item.departed",
+  "channel_shared",
+  "channel_mode_set",
+  "invite_created",
+  "invite_link_copied",
+  "invite_qr_shown",
+  "invite_system_sheet_opened",
+  "invite_joined",
+  "invite_converted",
+  "channel.invite_preview",
+  "channel.invite_accept",
+  "channel.invite_signin",
+  "enterprise.invite_preview",
+  "enterprise.invite_identity",
+  "enterprise.invite_signin",
+  "enterprise.invite_account_switch",
+  "enterprise.invite_attach",
+  "enterprise.invite_accept",
+  "enterprise.invite_admin",
+  "enterprise.signin",
+  "enterprise.alpha_waitlist",
+  "enterprise.alpha_access",
+  "enterprise.org_create",
+  "enterprise.workspace_opened",
+  "enterprise.workspace_switched",
+  "enterprise.channel_created",
+  "enterprise.channel_members_added",
+  "share_link_copied",
+  "share_qr_shown",
+  "share_system_sheet_opened",
+  "share_opened",
+  "share_content_copied",
+  "share_downloaded",
+  "share_signin_click",
+  "share.saved",
+  "share_bar_on",
+  "share_bar_off",
+  "upload.phase_timing",
+  "transfer.started",
+  "transfer.stage_started",
+  "transfer.phase_timing",
+  "transfer.slow",
+  "transfer.finished",
+  "auth.signin_started",
+  "auth.signin_result",
+  "auth.session_started",
+  "auth.signed_out",
+  "auth.session_lost",
+  "auth.token_refresh_failed",
+  "account_switch.started",
+  "account_switch.completed",
+  "account_switch.failed",
+  "bootstrap.result",
+  "direct_mode_set",
+  "direct.offered",
+  "direct.claimed",
+  "direct.connected",
+  "direct.completed",
+  "direct.received",
+  "direct.failed",
+  "direct.fallback_started",
+  "direct.fallback_ready",
+  "direct.fallback_received",
+  "direct.fallback_failed",
+  "direct.fallback_aborted",
+  "direct.too_big",
+  "agent.pair_opened",
+  "agent.pair_approved",
+  "agent.pair_refused",
+  "agent.paired",
+  "agent.revoked",
+  "agent.send",
+  "agent.edit",
+  "agent.replace",
+  "agent.tool_call",
+  // The public pages, which until now reported nothing at all: `capture_pageview`
+  // is off, so a visitor who read the enterprise page and left was invisible.
+  // These five are the funnel that ends at `enterprise.org_create`.
+  "marketing.page_viewed",
+  "marketing.section_viewed",
+  "marketing.scroll_depth",
+  "marketing.cta_clicked",
+  "marketing.language_switched"
+];
+var SERVER_OWNED_PRODUCT_EVENTS = [
+  "account_created",
+  "item.departed",
+  "invite_created",
+  "invite_joined",
+  "invite_converted",
+  "share_opened",
+  "share_content_copied",
+  "share_downloaded",
+  "share_signin_click",
+  "agent.send",
+  "agent.edit",
+  "agent.replace",
+  "agent.tool_call"
+];
+var SERVER_OWNED_PRODUCT_EVENT_SET = new Set(SERVER_OWNED_PRODUCT_EVENTS);
+var CLIENT_PRODUCT_EVENTS = PRODUCT_EVENTS.filter(
+  (event) => !SERVER_OWNED_PRODUCT_EVENT_SET.has(event)
+);
+var bool = { type: "boolean" };
+var count = { type: "number", min: 0 };
+var oneOf = (...values) => ({ type: "string", values: new Set(values) });
+var sizeBucket = oneOf("lt_1mb", "1_10mb", "10_100mb", "100_512mb", "512mb_5gb", "gt_5gb");
+var itemKind = oneOf("file", "text");
+var itemKindOrUnknown = oneOf("file", "text", "unknown");
+var role = oneOf("sender", "receiver");
+var candidateType = oneOf("", "host", "srflx", "relay", "prflx", "other");
+var enterpriseRole = oneOf("owner", "admin", "billing_admin", "member", "guest");
+var agentKind = oneOf("claude_code", "codex", "other");
+var pairHandoff = oneOf("loopback", "manual", "unknown");
+var marketingSurface = oneOf("home", "plans", "enterprise", "app");
+var marketingSection = oneOf(
+  "enterprise_band",
+  "hero",
+  "what",
+  "benefits",
+  "agents",
+  "fit",
+  "billing",
+  "signin"
+);
+var marketingCta = oneOf(
+  "see_enterprise",
+  "see_plans",
+  "contact",
+  "start_org",
+  "sign_in",
+  "open_console",
+  "switch_language",
+  "footer_home"
+);
+var marketingPlacement = oneOf("nav", "hero", "band", "fit", "billing", "signin", "footer", "menu", "limit");
+var arrivalKind = oneOf("direct", "internal", "search", "social", "other");
+var uiLocale = oneOf("es-AR", "pt-BR", "en");
+var signinContext = oneOf("page", "alpha_access", "handoff_site", "handoff_share");
+var AGENT_TOOL_NAMES = [
+  "status",
+  "pair",
+  "send_file",
+  "send_note",
+  "send_direct",
+  "send_direct_fallback",
+  "receive_direct",
+  "receive_direct_fallback",
+  "list_items",
+  "get_item",
+  "jobs",
+  "edit_item",
+  "replace_file"
+];
+var AGENT_ERROR_CODES = [
+  "none",
+  "other",
+  "identity_corrupt",
+  "not_paired",
+  "internal",
+  "agent_forbidden",
+  "agent_revoked",
+  "grant_missing",
+  "not_found",
+  "invalid_cap",
+  "write_failed",
+  "send_forbidden",
+  "read_forbidden",
+  "direct_mode",
+  "not_direct_mode",
+  "not_claimed",
+  "no_offer",
+  "offer_taken",
+  "direct_cancelled",
+  "direct_failed",
+  "direct_not_failed",
+  "file_changed",
+  "webrtc_unavailable",
+  "fallback_unavailable",
+  "key_stale",
+  "quota_exceeded",
+  "rate_limited",
+  "file_too_big",
+  "duplicate",
+  "pairing_expired",
+  "pairing_cancelled",
+  "claim_mismatch",
+  "pairing_not_approved",
+  "pairing_claimed",
+  "agent_limit",
+  "grant_limit",
+  "feature_disabled",
+  "upload_failed",
+  "oprf_failed",
+  "network",
+  "sign_in_failed",
+  "bad_signature",
+  "missing_token",
+  // An agent changing its own items (2026-09-09).
+  "not_yours",
+  "stale",
+  "not_a_note",
+  "not_a_file",
+  "item_shared"
+];
+function agentDurationBucket(ms) {
+  if (ms < 1e3) return "lt_1s";
+  if (ms < 1e4) return "1_10s";
+  if (ms < 6e4) return "10_60s";
+  return "gt_60s";
 }
-function directFileFrom(path, raw) {
-  let statSize;
-  try {
-    statSize = statSync(path).size;
-  } catch {
-    return raw;
-  }
-  if (statSize <= raw.size) return raw;
-  const type = raw.type;
-  const file = {
-    size: statSize,
-    type,
-    slice(start, end) {
-      const from = Math.max(0, Math.min(start, statSize));
-      const to = Math.max(from, Math.min(end, statSize));
-      return { arrayBuffer: () => readFileRange(path, from, to - from) };
-    }
-  };
-  return file;
+var transferProperties = {
+  transfer_id: { type: "transfer_id" },
+  item_kind: oneOf("file", "text", "code", "link", "unknown"),
+  transport: oneOf("storage", "manifest", "direct", "fallback"),
+  cache_hit: bool,
+  telemetry_version: count,
+  direction: oneOf("upload", "download"),
+  purpose: oneOf("send", "download", "preview", "export"),
+  scope: oneOf("personal", "organization"),
+  size_bucket: sizeBucket,
+  stage: oneOf("staging", "encrypting", "uploading", "finishing", "authorization", "downloading", "decrypting", "assembling"),
+  duration_ms: count,
+  bytes_completed: count,
+  size_bytes: count,
+  foreground: bool,
+  online: bool,
+  outcome: oneOf("success", "failure", "cancelled"),
+  error_code: oneOf("none", "network", "timeout", "authorization", "storage", "crypto", "worker", "other"),
+  timing_mode: oneOf("wall", "cumulative_work")
+};
+var EVENT_PROPERTY_RULES = {
+  "transfer.started": transferProperties,
+  "transfer.stage_started": transferProperties,
+  "transfer.phase_timing": transferProperties,
+  "transfer.slow": transferProperties,
+  "transfer.finished": transferProperties,
+  account_created: {},
+  "item.created": { kind: itemKind, size_bytes: count, size_bucket: sizeBucket },
+  "item.downloaded": { size_bytes: count, size_bucket: sizeBucket },
+  "item.copied": {},
+  "item.shared": { kind: itemKind },
+  "item.pinned": { age_ms: count },
+  "item.unpinned": {},
+  "item.deleted": { age_ms: count, was_pinned: bool, kind: itemKindOrUnknown },
+  "item.departed": {},
+  channel_shared: {},
+  channel_mode_set: { mode: oneOf("edit", "view") },
+  invite_created: {},
+  invite_link_copied: {},
+  invite_qr_shown: {},
+  invite_system_sheet_opened: {},
+  invite_joined: {},
+  invite_converted: {},
+  "channel.invite_preview": {
+    outcome: oneOf("ready", "unavailable", "missing_key"),
+    signed_in: bool
+  },
+  "channel.invite_accept": {
+    outcome: oneOf("started", "completed", "already_member", "unavailable", "failed")
+  },
+  "channel.invite_signin": {
+    stage: oneOf("link_requested", "link_sent", "link_completed", "failed")
+  },
+  "enterprise.invite_preview": {
+    outcome: oneOf("pending", "resumable", "unavailable"),
+    role: enterpriseRole
+  },
+  "enterprise.invite_identity": {
+    outcome: oneOf("matched", "mismatched", "unavailable", "failed")
+  },
+  "enterprise.invite_signin": {
+    stage: oneOf("link_requested", "link_sent", "link_completed", "failed")
+  },
+  "enterprise.invite_account_switch": { stage: oneOf("started", "completed", "failed") },
+  "enterprise.invite_attach": {
+    stage: oneOf("link_requested", "link_sent", "verify_started", "completed", "address_taken", "link_invalid", "failed")
+  },
+  "enterprise.invite_accept": {
+    outcome: oneOf("started", "completed", "recovered", "timeout", "unavailable", "email_mismatch", "seat_limit", "failed"),
+    role: enterpriseRole,
+    destination: oneOf("workspace", "admin_console"),
+    duration_ms: count
+  },
+  "enterprise.invite_admin": {
+    outcome: oneOf("created", "email_sent", "email_failed", "reissued", "revoked"),
+    role: enterpriseRole,
+    external: bool
+  },
+  // The workspace sign-in card, wherever it is shown: the public enterprise
+  // page, a `?site=` handoff from a customer domain, or a `?share=` link.
+  "enterprise.signin": {
+    context: signinContext,
+    stage: oneOf(
+      "shown",
+      "email_submitted",
+      "email_sent",
+      "email_failed",
+      "provider_clicked",
+      "link_completed",
+      "link_failed"
+    ),
+    provider: oneOf("google.com", "apple.com", "email_link", "none")
+  },
+  // Closed-alpha funnel. It intentionally names only a step: never an email,
+  // password, password cohort, access token, or raw HTTP error.
+  "enterprise.alpha_waitlist": { stage: oneOf("submitted", "joined", "failed") },
+  "enterprise.alpha_access": { stage: oneOf("revealed", "submitted", "granted", "denied") },
+  // The end of the funnel. `opened` is the create form appearing, which is
+  // what someone signing in with no organization yet is shown.
+  "enterprise.org_create": { stage: oneOf("opened", "submitted", "created", "failed", "access_required") },
+  "enterprise.workspace_opened": { role: enterpriseRole, first_visit: bool },
+  "enterprise.workspace_switched": { destination: oneOf("personal", "organization"), role: enterpriseRole },
+  "enterprise.channel_created": { member_count: count },
+  "enterprise.channel_members_added": { member_count: count },
+  share_link_copied: {},
+  share_qr_shown: {},
+  share_system_sheet_opened: {},
+  share_opened: {},
+  share_content_copied: {},
+  share_downloaded: {},
+  share_signin_click: {},
+  "share.saved": {},
+  share_bar_on: {},
+  share_bar_off: {},
+  "upload.phase_timing": {
+    stage: oneOf("staging", "bootstrap", "thumbnail", "encrypting", "uploading", "finishing"),
+    duration_ms: count,
+    size_bucket: sizeBucket,
+    outcome: oneOf("success", "failure", "cancelled"),
+    attempt: { type: "number", min: 1 }
+  },
+  "auth.signin_started": { provider: oneOf("google.com", "apple.com") },
+  "auth.signin_result": {
+    provider: oneOf("google.com", "apple.com"),
+    outcome: oneOf("signed_in", "cancelled", "taken", "failed", "needs_link"),
+    flow: oneOf("signin", "link", "connect")
+  },
+  "account_switch.started": { operation: oneOf("remember", "switch"), provider: oneOf("google.com", "apple.com", "email_link", "qr", "code") },
+  "account_switch.completed": { operation: oneOf("remember", "switch"), provider: oneOf("google.com", "apple.com", "email_link", "qr", "code") },
+  "account_switch.failed": { operation: oneOf("remember", "switch"), provider: oneOf("google.com", "apple.com", "email_link", "qr", "code") },
+  "auth.session_started": { cold: bool },
+  "auth.signed_out": { reason: oneOf("user", "account_switch", "abandoned_new_account", "account_deleted") },
+  "auth.session_lost": { session_age_ms: count, foreground: bool },
+  "auth.token_refresh_failed": {
+    code: oneOf("network", "token_invalid", "user_disabled", "user_missing", "rate_limited", "internal", "unknown")
+  },
+  "bootstrap.result": {
+    outcome: oneOf("offline", "ok", "timeout_warm", "timeout", "failed_warm", "failed"),
+    stage: oneOf("cached", "done", "unknown", "keyring", "account_init", "listeners"),
+    duration_ms: count,
+    fault: oneOf("intercepted", "offline", "unknown")
+  },
+  direct_mode_set: { on: bool },
+  "direct.offered": { size_bucket: sizeBucket },
+  // `via_agent`: the offer came from a paired agent's process, not from one
+  // of the person's devices. The claim and the two receiver outcomes carry it.
+  "direct.claimed": { size_bucket: sizeBucket, via_agent: bool },
+  "direct.connected": { role, ms: count },
+  "direct.completed": {
+    via: oneOf("lan", "wan", "relay", "unknown"),
+    pair_local: candidateType,
+    pair_remote: candidateType,
+    connect_ms: count,
+    duration_ms: count,
+    size_bucket: sizeBucket,
+    turn_urls_supplied: count,
+    turn_urls_configured: count,
+    restarts: count
+  },
+  "direct.received": {
+    via_agent: bool,
+    via: oneOf("lan", "wan", "relay", "unknown"),
+    pair_local: candidateType,
+    pair_remote: candidateType,
+    connect_ms: count,
+    duration_ms: count,
+    size_bucket: sizeBucket,
+    turn_urls_supplied: count,
+    turn_urls_configured: count,
+    restarts: count
+  },
+  "direct.failed": {
+    role,
+    via_agent: bool,
+    reason: oneOf(
+      "peer_silent",
+      "connect_timeout",
+      "ice_failed",
+      "disconnected",
+      "peer_closed",
+      "peer_abort",
+      "signaling",
+      "signal_send",
+      "protocol",
+      "sink",
+      "transfer",
+      "integrity",
+      "too_big",
+      "unknown"
+    ),
+    ms: count,
+    ice_state: oneOf("", "new", "checking", "connected", "completed", "failed", "disconnected", "closed"),
+    gather_state: oneOf("", "new", "gathering", "complete"),
+    had_remote: bool,
+    local_host: count,
+    local_srflx: count,
+    local_relay: count,
+    remote_host: count,
+    remote_srflx: count,
+    remote_relay: count,
+    turn_urls_supplied: count,
+    turn_urls_configured: count,
+    moved_bucket: sizeBucket,
+    size_bucket: sizeBucket,
+    restarts: count,
+    // Whether the reporting tab was on screen when the run died — the lead a
+    // slept machine or a frozen background tab leaves behind.
+    visibility: oneOf("visible", "hidden", "prerender")
+  },
+  "direct.fallback_started": { size_bucket: sizeBucket },
+  "direct.fallback_ready": { size_bucket: sizeBucket, duration_ms: count, retries: count },
+  "direct.fallback_received": { size_bucket: sizeBucket, duration_ms: count, retries: count },
+  "direct.fallback_failed": {
+    stage: oneOf("upload", "download"),
+    size_bucket: sizeBucket,
+    retries: count
+  },
+  "direct.fallback_aborted": {},
+  "direct.too_big": { size_bucket: sizeBucket },
+  "agent.pair_opened": { agent_kind: agentKind, protocol: count, replaces: bool },
+  "agent.pair_approved": {
+    agent_kind: agentKind,
+    destination: oneOf("new_channel", "existing"),
+    channels: count,
+    handoff: pairHandoff
+  },
+  "agent.pair_refused": {
+    agent_kind: agentKind,
+    step: oneOf("open", "approve", "claim"),
+    reason: oneOf(
+      "agent_limit",
+      "grant_limit",
+      "channel_limit",
+      "code_mismatch",
+      "pairing_expired",
+      "pairing_cancelled",
+      "pairing_claimed",
+      "feature_disabled",
+      "rate_limited",
+      "network",
+      "other"
+    )
+  },
+  "agent.paired": {
+    agent_kind: agentKind,
+    destination: oneOf("new_channel", "existing"),
+    channels: count,
+    handoff: pairHandoff,
+    protocol: count
+  },
+  "agent.revoked": { agent_kind: agentKind },
+  "agent.send": { size_bucket: sizeBucket, agent_kind: agentKind },
+  "agent.edit": { agent_kind: agentKind },
+  "agent.replace": { size_bucket: sizeBucket, agent_kind: agentKind },
+  // What the CLI reports after every tool call: the tool, whether it worked,
+  // the code when it did not, and the version that answered. No path, no file
+  // name, no channel, no sentence.
+  "marketing.page_viewed": {
+    surface: marketingSurface,
+    locale: uiLocale,
+    // Whether the URL carried a language prefix. `/en/enterprise` and
+    // `/enterprise` are the same page in different languages, and which one
+    // search sends people to is worth knowing on its own.
+    prefixed: bool,
+    signed_in: bool,
+    arrival: arrivalKind
+  },
+  "marketing.section_viewed": { surface: marketingSurface, section: marketingSection },
+  "marketing.scroll_depth": {
+    surface: marketingSurface,
+    depth: oneOf("p25", "p50", "p75", "p100")
+  },
+  "marketing.cta_clicked": {
+    surface: marketingSurface,
+    cta: marketingCta,
+    placement: marketingPlacement
+  },
+  "marketing.language_switched": { surface: marketingSurface, from: uiLocale, to: uiLocale },
+  "agent.tool_call": {
+    tool: oneOf(...AGENT_TOOL_NAMES),
+    result: oneOf("ok", "error"),
+    code: oneOf(...AGENT_ERROR_CODES),
+    agent_kind: agentKind,
+    duration_bucket: oneOf("lt_1s", "1_10s", "10_60s", "gt_60s"),
+    version_major: count,
+    version_minor: count,
+    version_patch: count
+  }
+};
+var platformRule = oneOf("web", "android", "ios", "agent", "unknown");
+function valid(rule, value) {
+  if (rule.type === "transfer_id") return typeof value === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
+  if (rule.type === "boolean") return typeof value === "boolean";
+  if (rule.type === "number") {
+    return typeof value === "number" && Number.isFinite(value) && (rule.min === void 0 || value >= rule.min);
+  }
+  return typeof value === "string" && rule.values.has(value);
+}
+function sanitizeProductEventProperties(event, properties) {
+  if (!properties || typeof properties !== "object" || Array.isArray(properties)) return {};
+  const input = properties;
+  const rules = EVENT_PROPERTY_RULES[event];
+  const output = {};
+  for (const [key, value] of Object.entries(input)) {
+    const rule = key === "platform" ? platformRule : rules[key];
+    if (rule && valid(rule, value)) output[key] = value;
+  }
+  return output;
 }
+var PERSON_PROPERTY_RULES = {
+  plan: oneOf("anon", "free", "pro", "max"),
+  locale: oneOf("es-AR", "pt-BR", "en"),
+  storage_bytes: count
+};
 
-// src/shared/direct-fallback.ts
-function createFallbackMeta(file) {
-  const key = crypto.getRandomValues(new Uint8Array(32));
-  const nonce = crypto.getRandomValues(new Uint8Array(8));
-  return {
-    v: 1,
-    name: file.name,
-    size: file.size,
-    mime: file.type,
-    key_b64: bytesToB64(key),
-    nonce_b64: bytesToB64(nonce),
-    part_bytes: DIRECT_FALLBACK_PART_BYTES,
-    tag_bytes: DIRECT_FALLBACK_TAG_BYTES,
-    part_count: directFallbackPartCount(file.size),
-    cipher_size: directFallbackCipherSize(file.size)
-  };
-}
-function fallbackMetaOf(value) {
-  const meta = value;
-  if (!meta || meta.v !== 1 || typeof meta.name !== "string" || meta.name.length === 0 || typeof meta.mime !== "string" || !Number.isSafeInteger(meta.size) || (meta.size ?? -1) < 0 || typeof meta.key_b64 !== "string" || typeof meta.nonce_b64 !== "string" || meta.part_bytes !== DIRECT_FALLBACK_PART_BYTES || meta.tag_bytes !== DIRECT_FALLBACK_TAG_BYTES || meta.part_count !== directFallbackPartCount(meta.size) || meta.cipher_size !== directFallbackCipherSize(meta.size)) throw new Error("bad_fallback_meta");
-  let key;
-  let nonce;
-  try {
+// src/telemetry.ts
+var OFF_WORDS = /* @__PURE__ */ new Set(["0", "off", "false", "no"]);
+var ON_WORDS = /* @__PURE__ */ new Set(["1", "on", "true", "yes"]);
+function telemetryState() {
+  const env = (process.env.ZAS_AGENT_TELEMETRY ?? "").toLowerCase();
+  if (OFF_WORDS.has(env)) return { on: false, source: "env" };
+  if (ON_WORDS.has(env)) return { on: true, source: "env" };
+  if (process.env.DO_NOT_TRACK === "1") return { on: false, source: "do_not_track" };
+  const stored = loadSettings();
+  if (stored && typeof stored.telemetry === "boolean") return { on: stored.telemetry, source: "file" };
+  return { on: true, source: "default" };
+}
+function setTelemetry(on) {
+  const stored = loadSettings();
+  saveSettings({ ...stored ?? {}, version: 1, telemetry: on, decided_at: Date.now() });
+}
+function noticeShown() {
+  return typeof loadSettings()?.notified_at === "number";
+}
+function markNoticeShown() {
+  const stored = loadSettings();
+  saveSettings({ ...stored ?? {}, version: 1, notified_at: Date.now() });
+}
+var TELEMETRY_NOTICE = [
+  "Zas collects usage data from this agent to improve the product: which tool",
+  "ran, whether it worked, the error code when it did not, how long it took,",
+  "item type, transfer stages, byte counts, outcomes, and the version.",
+  "Never file names, file contents, paths or channel names.",
+  "The data is linked to your Zas account.",
+  "Turn it off with: npx -y zas-agent telemetry off"
+].join("\n");
+var SOURCE_WORDS = {
+  env: "ZAS_AGENT_TELEMETRY",
+  do_not_track: "DO_NOT_TRACK",
+  file: "zas-agent telemetry",
+  default: "default"
+};
+function telemetryLine() {
+  const state = telemetryState();
+  return `telemetry: ${state.on ? "on" : "off"} (${SOURCE_WORDS[state.source]})`;
+}
+var TOOL_NAMES = new Set(AGENT_TOOL_NAMES);
+function versionParts(version) {
+  const [major = 0, minor = 0, patch = 0] = version.split("-")[0].split(".").map((part) => {
+    const value = Number.parseInt(part, 10);
+    return Number.isFinite(value) && value >= 0 ? value : 0;
+  });
+  return { major, minor, patch };
+}
+function toolCallProperties(input) {
+  const tool = input.tool.startsWith("zas_") ? input.tool.slice(4) : input.tool;
+  if (!TOOL_NAMES.has(tool)) return null;
+  const version = versionParts(input.version);
+  return {
+    tool,
+    result: input.code === null ? "ok" : "error",
+    // `other` is the server's word for a code outside the vocabulary. The
+    // shared list is the one that decides, and it drops anything else.
+    code: input.code ?? "none",
+    duration_bucket: agentDurationBucket(input.ms),
+    version_major: version.major,
+    version_minor: version.minor,
+    version_patch: version.patch
+  };
+}
+var REPORT_TIMEOUT_MS = 5e3;
+async function report(client, properties) {
+  if (properties === null) return;
+  await new Promise((resolve2) => {
+    const timer = setTimeout(resolve2, 0);
+    timer.unref?.();
+  });
+  if (!telemetryState().on) return;
+  const timeout = new Promise((resolve2) => {
+    const timer = setTimeout(resolve2, REPORT_TIMEOUT_MS);
+    timer.unref?.();
+  });
+  const body = { event: "agent.tool_call", properties };
+  const sent = (client.reportTelemetry ? client.reportTelemetry(body) : client.api("POST", "/agents/telemetry", body)).then(() => void 0).catch(() => void 0);
+  await Promise.race([sent, timeout]);
+}
+
+// src/transfer-telemetry.ts
+var pending = /* @__PURE__ */ new WeakMap();
+function flush(client) {
+  const queue = pending.get(client);
+  if (!queue) return;
+  clearTimeout(queue.timer);
+  pending.delete(client);
+  try {
+    if (!telemetryState().on) return;
+    const body = { events: queue.events };
+    void (client.reportTelemetry ? client.reportTelemetry(body) : client.api("POST", "/agents/telemetry", body)).catch(() => void 0);
+  } catch {
+  }
+}
+function enqueue(client, report2) {
+  let queue = pending.get(client);
+  if (!queue) {
+    const timer = setTimeout(() => flush(client), 0);
+    timer.unref?.();
+    queue = { events: [], timer };
+    pending.set(client, queue);
+  }
+  if (queue.events.length < 32) queue.events.push(report2);
+}
+function itemKind2(item) {
+  if (item.kind === "file") return "file";
+  if (item.code || item.lang) return "code";
+  if (item.link_preview || /^https?:\/\/\S+$/.test(item.text?.trim() ?? "")) return "link";
+  return item.kind === "text" || item.text !== void 0 ? "text" : "unknown";
+}
+var TransferTelemetry = class {
+  constructor(client, direction, kind, transport) {
+    this.client = client;
+    this.direction = direction;
+    this.kind = kind;
+    this.transport = transport;
+    this.capture("transfer.started");
+    this.slow = setTimeout(() => this.capture("transfer.slow"), 3e4);
+    this.slow.unref?.();
+  }
+  id = randomUUID();
+  started = performance.now();
+  changed = this.started;
+  stage = "staging";
+  seen = /* @__PURE__ */ new Set();
+  spans = /* @__PURE__ */ new Map();
+  ended = false;
+  slow;
+  size = 0;
+  completed = 0;
+  describe(size, kind = this.kind, transport = this.transport) {
+    this.size = Math.max(0, size);
+    this.kind = kind;
+    this.transport = transport;
+  }
+  progress(bytes) {
+    this.completed = Math.max(this.completed, bytes);
+  }
+  mark(phase) {
+    if (this.ended) return;
+    const stage = {
+      hashing: "staging",
+      waiting: "staging",
+      connecting: "authorization",
+      flight: this.direction === "upload" ? "uploading" : "downloading",
+      done: "finishing"
+    }[phase] ?? phase;
+    if (!["staging", "encrypting", "uploading", "finishing", "authorization", "downloading", "decrypting", "assembling"].includes(stage)) return;
+    const now = performance.now();
+    this.spans.set(this.stage, (this.spans.get(this.stage) ?? 0) + now - this.changed);
+    this.changed = now;
+    this.stage = stage;
+    if (!this.seen.has(stage)) {
+      this.seen.add(stage);
+      this.capture("transfer.stage_started");
+    }
+  }
+  finish(outcome, error = "none", cacheHit = false) {
+    if (this.ended) return;
+    this.mark(this.stage);
+    this.ended = true;
+    if (outcome === "success") this.completed = this.size;
+    clearTimeout(this.slow);
+    for (const [stage, duration] of this.spans) this.capture("transfer.phase_timing", {
+      stage,
+      duration_ms: Math.round(duration),
+      timing_mode: "wall",
+      outcome
+    });
+    this.capture("transfer.finished", { outcome, error_code: error, cache_hit: cacheHit });
+  }
+  failed(error) {
+    const e = error;
+    const cancelled = e?.name === "AbortError" || e?.code === "cancelled";
+    const code = cancelled ? "none" : this.stage === "decrypting" ? "crypto" : e?.status === 401 || e?.status === 403 ? "authorization" : e?.code === "timeout" ? "timeout" : e?.code === "network" || error instanceof TypeError ? "network" : e?.code === "write_failed" ? "storage" : this.stage === "decrypting" ? "crypto" : "other";
+    this.finish(cancelled ? "cancelled" : "failure", code);
+  }
+  capture(event, extra = {}) {
+    try {
+      const mb = this.size / 1048576;
+      const properties = sanitizeProductEventProperties(event, {
+        transfer_id: this.id,
+        telemetry_version: 1,
+        direction: this.direction,
+        purpose: this.direction === "upload" ? "send" : "download",
+        item_kind: this.kind,
+        transport: this.transport,
+        size_bytes: this.size,
+        bytes_completed: this.completed,
+        size_bucket: mb < 1 ? "lt_1mb" : mb < 10 ? "1_10mb" : mb < 100 ? "10_100mb" : mb < 512 ? "100_512mb" : mb < 5120 ? "512mb_5gb" : "gt_5gb",
+        stage: this.stage,
+        duration_ms: Math.round(performance.now() - this.started),
+        ...extra
+      });
+      enqueue(this.client, { event, properties });
+    } catch {
+    }
+  }
+};
+
+// src/direct.ts
+import { randomBytes } from "node:crypto";
+import { openAsBlob } from "node:fs";
+import { basename as basename2 } from "node:path";
+
+// src/shared/manifest.ts
+import { xchacha20poly1305 } from "@noble/ciphers/chacha";
+function newManifest(partial) {
+  return { v: MANIFEST_VERSION, chunker: CHUNKER_VERSION, ...partial };
+}
+var ENVELOPE_MAGIC = 90;
+var KEY_VERSION_LEGACY = 1;
+function envelopeVersion(sealed) {
+  if (sealed.length > 26 && sealed[0] === ENVELOPE_MAGIC && sealed[1] >= 1) return sealed[1];
+  return KEY_VERSION_LEGACY;
+}
+function sealBytes(key, version, plain) {
+  if (version < 1 || version > 255) throw new Error("key version out of range");
+  const nonce = new Uint8Array(24);
+  crypto.getRandomValues(nonce);
+  const ct = xchacha20poly1305(key, nonce).encrypt(plain);
+  return concatBytes(new Uint8Array([ENVELOPE_MAGIC, version]), nonce, ct);
+}
+function openSealed(key, sealed) {
+  const versioned = envelopeVersion(sealed) !== KEY_VERSION_LEGACY || sealed[0] === ENVELOPE_MAGIC;
+  if (versioned && sealed.length > 26) {
+    try {
+      return xchacha20poly1305(key, sealed.slice(2, 26)).decrypt(sealed.slice(26));
+    } catch {
+    }
+  }
+  return xchacha20poly1305(key, sealed.slice(0, 24)).decrypt(sealed.slice(24));
+}
+var sealRaw = sealBytes;
+var openRaw = openSealed;
+function sealManifest(channelKey, manifest, version = KEY_VERSION_LEGACY) {
+  return sealBytes(channelKey, version, new TextEncoder().encode(JSON.stringify(manifest)));
+}
+function openManifest(channelKey, sealed) {
+  const m = JSON.parse(new TextDecoder().decode(openSealed(channelKey, sealed)));
+  if (!Array.isArray(m.chunks)) m.chunks = [];
+  return m;
+}
+function decryptChannelName(channelKey, sealed) {
+  return new TextDecoder().decode(openSealed(channelKey, sealed));
+}
+
+// src/file-source.ts
+import { promises as fsp, statSync } from "node:fs";
+async function readFileRange(path, start, length) {
+  const fh = await fsp.open(path, "r");
+  try {
+    const buf = Buffer.allocUnsafe(Math.max(0, length));
+    let read = 0;
+    while (read < length) {
+      const { bytesRead } = await fh.read(buf, read, length - read, start + read);
+      if (bytesRead === 0) break;
+      read += bytesRead;
+    }
+    const out = new Uint8Array(read);
+    out.set(buf.subarray(0, read));
+    return out.buffer;
+  } finally {
+    await fh.close();
+  }
+}
+function directFileFrom(path, raw) {
+  let statSize;
+  try {
+    statSize = statSync(path).size;
+  } catch {
+    return raw;
+  }
+  if (statSize <= raw.size) return raw;
+  const type = raw.type;
+  const file = {
+    size: statSize,
+    type,
+    slice(start, end) {
+      const from = Math.max(0, Math.min(start, statSize));
+      const to = Math.max(from, Math.min(end, statSize));
+      return { arrayBuffer: () => readFileRange(path, from, to - from) };
+    }
+  };
+  return file;
+}
+
+// src/shared/direct-fallback.ts
+function createFallbackMeta(file) {
+  const key = crypto.getRandomValues(new Uint8Array(32));
+  const nonce = crypto.getRandomValues(new Uint8Array(8));
+  return {
+    v: 1,
+    name: file.name,
+    size: file.size,
+    mime: file.type,
+    key_b64: bytesToB64(key),
+    nonce_b64: bytesToB64(nonce),
+    part_bytes: DIRECT_FALLBACK_PART_BYTES,
+    tag_bytes: DIRECT_FALLBACK_TAG_BYTES,
+    part_count: directFallbackPartCount(file.size),
+    cipher_size: directFallbackCipherSize(file.size)
+  };
+}
+function fallbackMetaOf(value) {
+  const meta = value;
+  if (!meta || meta.v !== 1 || typeof meta.name !== "string" || meta.name.length === 0 || typeof meta.mime !== "string" || !Number.isSafeInteger(meta.size) || (meta.size ?? -1) < 0 || typeof meta.key_b64 !== "string" || typeof meta.nonce_b64 !== "string" || meta.part_bytes !== DIRECT_FALLBACK_PART_BYTES || meta.tag_bytes !== DIRECT_FALLBACK_TAG_BYTES || meta.part_count !== directFallbackPartCount(meta.size) || meta.cipher_size !== directFallbackCipherSize(meta.size)) throw new Error("bad_fallback_meta");
+  let key;
+  let nonce;
+  try {
     key = b64ToBytes(meta.key_b64);
     nonce = b64ToBytes(meta.nonce_b64);
   } catch {
@@ -2151,17 +2925,17 @@ function cutPoint(buf, gear, eof) {
 }
 async function* chunkStream(source) {
   const gear = await gearTable();
-  let pending = [];
+  let pending2 = [];
   let pendingLen = 0;
   const compact = () => {
-    if (pending.length === 1) return pending[0];
+    if (pending2.length === 1) return pending2[0];
     const merged = new Uint8Array(pendingLen);
     let off = 0;
-    for (const p of pending) {
+    for (const p of pending2) {
       merged.set(p, off);
       off += p.length;
     }
-    pending = [merged];
+    pending2 = [merged];
     return merged;
   };
   const drain = function* (eof) {
@@ -2170,13 +2944,13 @@ async function* chunkStream(source) {
       const cut = cutPoint(buf, gear, eof);
       if (cut === null) return;
       yield buf.slice(0, cut);
-      pending = cut < buf.length ? [buf.slice(cut)] : [];
+      pending2 = cut < buf.length ? [buf.slice(cut)] : [];
       pendingLen = buf.length - cut;
     }
   };
   for await (const piece of source) {
     if (piece.length === 0) continue;
-    pending.push(piece);
+    pending2.push(piece);
     pendingLen += piece.length;
     if (pendingLen >= CHUNK_MAX) yield* drain(false);
   }
@@ -2566,32 +3340,20 @@ async function postLink(ctx, grant, manifest, placed, idempotencyKey, expiresInD
   }
   return created.link_id;
 }
-async function sendFile(ctx, input, onPhase) {
-  const stat = await fsp2.stat(input.path).catch(() => {
+async function checkFilePath(path) {
+  const stat = await fsp2.stat(path).catch(() => {
     throw new ZasError("upload_failed", 400);
   });
   if (!stat.isFile()) throw new ZasError("upload_failed", 400);
   if (stat.size > MAX_FILE_BYTES) throw new ZasError("file_too_big", 413);
-  const grant = await grantFor(ctx, input.channel);
-  const name = basename(input.path);
-  const title = input.title ?? name;
-  const file = await fsp2.readFile(input.path);
+}
+async function readFileChecked(path) {
+  await checkFilePath(path);
+  const file = await fsp2.readFile(path);
   if (file.byteLength > MAX_FILE_BYTES) throw new ZasError("file_too_big", 413);
-  const bytes = new Uint8Array(file.buffer, file.byteOffset, file.byteLength);
-  const contentHash = await sendIdentity(await blake3Hex(bytes), input.expires_in_days);
-  const key = await receiptKey(ctx, grant.channel_id, contentHash, title);
-  const stored = receiptFor(ctx, key);
-  if (stored) {
-    return {
-      link_id: stored.link_id,
-      channel_id: grant.channel_id,
-      channel_name: channelNameOf(ctx.identity, grant),
-      bytes: stored.bytes,
-      chunks: stored.chunks,
-      deduplicated: stored.deduplicated,
-      replayed: true
-    };
-  }
+  return { bytes: new Uint8Array(file.buffer, file.byteOffset, file.byteLength), name: basename(path) };
+}
+async function placeFile(ctx, bytes, onPhase) {
   onPhase?.("hashing");
   const plains = [];
   for await (const piece of chunkStream([bytes])) plains.push(piece);
@@ -2608,7 +3370,38 @@ async function sendFile(ctx, input, onPhase) {
     (plain, i) => encryptChunk(oprfFinalize(hashes[i], blinds[i].blind, b64ToBytes(evaluated[i])), plain)
   ));
   onPhase?.("uploading");
-  const placed = await placeChunks(ctx, encs);
+  return placeChunks(ctx, encs);
+}
+function forgetLink(profile, linkId) {
+  const entries = {};
+  let dropped = false;
+  for (const [k, v] of Object.entries(loadFingerprints(profile).entries)) {
+    if (v && v.link_id === linkId) dropped = true;
+    else entries[k] = v;
+  }
+  if (dropped) saveFingerprints(profile, { entries });
+}
+async function sendFileMeasured(ctx, input, onPhase) {
+  await checkFilePath(input.path);
+  const grant = await grantFor(ctx, input.channel);
+  const { bytes, name } = await readFileChecked(input.path);
+  ctx.transferTelemetry?.describe(bytes.length);
+  const title = input.title ?? name;
+  const contentHash = await sendIdentity(await blake3Hex(bytes), input.expires_in_days);
+  const key = await receiptKey(ctx, grant.channel_id, contentHash, title);
+  const stored = receiptFor(ctx, key);
+  if (stored) {
+    return {
+      link_id: stored.link_id,
+      channel_id: grant.channel_id,
+      channel_name: channelNameOf(ctx.identity, grant),
+      bytes: stored.bytes,
+      chunks: stored.chunks,
+      deduplicated: stored.deduplicated,
+      replayed: true
+    };
+  }
+  const placed = await placeFile(ctx, bytes, onPhase);
   onPhase?.("finishing");
   const mime = mimeFor(input.path);
   const thumb = await thumbnailFor(bytes, mime);
@@ -2624,6 +3417,7 @@ async function sendFile(ctx, input, onPhase) {
     ...thumb ? { thumb_data: thumb } : {},
     chunks: placed.map((p) => p.entry)
   });
+  ctx.transferTelemetry?.mark("finishing");
   const linkId = await postLink(
     ctx,
     grant,
@@ -2653,10 +3447,12 @@ async function sendFile(ctx, input, onPhase) {
 function noteName(text2) {
   return text2.split("\n", 1)[0].trim().slice(0, NOTE_NAME_MAX) || "nota";
 }
-async function sendNote(ctx, input) {
+async function sendNoteMeasured(ctx, input) {
   const grant = await grantFor(ctx, input.channel);
   const name = input.title ?? noteName(input.text);
   const encoded = new TextEncoder().encode(input.text);
+  ctx.transferTelemetry?.describe(encoded.length);
+  ctx.transferTelemetry?.mark("encrypting");
   const contentHash = await sendIdentity(
     await blake3Hex(new TextEncoder().encode(
       `${input.lang ?? ""}\0${input.secret ? "1" : "0"}\0${input.text}`
@@ -2690,6 +3486,7 @@ async function sendNote(ctx, input) {
     ...input.secret ? { sensitive: true } : {},
     chunks: []
   });
+  ctx.transferTelemetry?.mark("finishing");
   const linkId = await postLink(
     ctx,
     grant,
@@ -2715,6 +3512,34 @@ async function sendNote(ctx, input) {
     replayed: false
   };
 }
+async function sendFile(...args) {
+  const telemetry = new TransferTelemetry(args[0].client, "upload", "file", "storage");
+  try {
+    const report2 = args[2];
+    const result = await sendFileMeasured({ ...args[0], transferTelemetry: telemetry }, args[1], (phase) => {
+      telemetry.mark(phase);
+      report2?.(phase);
+    });
+    telemetry.describe(result.bytes);
+    telemetry.finish("success", "none", result.replayed);
+    return result;
+  } catch (error) {
+    telemetry.failed(error);
+    throw error;
+  }
+}
+async function sendNote(...args) {
+  const telemetry = new TransferTelemetry(args[0].client, "upload", itemKind2({ text: args[1].text, lang: args[1].lang }), "manifest");
+  try {
+    const result = await sendNoteMeasured({ ...args[0], transferTelemetry: telemetry }, ...args.slice(1));
+    telemetry.describe(result.bytes);
+    telemetry.finish("success", "none", result.replayed);
+    return result;
+  } catch (error) {
+    telemetry.failed(error);
+    throw error;
+  }
+}
 
 // src/direct.ts
 var OFFER_WAIT_MS = 9.5 * 60 * 1e3;
@@ -2765,16 +3590,18 @@ function sealer(key, keyVersion) {
     open: (enc) => JSON.parse(new TextDecoder().decode(openRaw(key, b64ToBytes(enc))))
   };
 }
-async function sendDirect(ctx, input, report2, deps = {}) {
+async function sendDirectMeasured(ctx, input, report2, deps = {}) {
   const now = deps.now ?? (() => Date.now());
   const sleep2 = deps.sleep ?? defaultSleep2;
   const grant = await directGrantFor(ctx, input.channel);
   const key = channelKeyOf(ctx.identity, grant);
   const channelName = channelLabel(ctx, grant);
+  ctx.transferTelemetry?.mark("authorization");
   const raw = await (deps.openFile ?? openAsBlob)(input.path, { type: mimeFor(input.path) }).catch(() => {
     throw new ZasError("upload_failed", 400);
   });
   const file = directFileFrom(input.path, raw);
+  ctx.transferTelemetry?.describe(file.size);
   if (file.size > DIRECT_FILE_MAX_BYTES) throw new ZasError("file_too_big", 413);
   const name = basename2(input.path);
   const cid = grant.channel_id;
@@ -2914,13 +3741,14 @@ var fetchPut = async (url, bytes, signal, onLoaded) => {
   onLoaded(bytes.length);
   return etag;
 };
-async function sendDirectFallback(ctx, record, report2, deps = {}) {
+async function sendDirectFallbackMeasured(ctx, record, report2, deps = {}) {
   const now = deps.now ?? (() => Date.now());
   const startedAt = now();
   const opened = await (deps.openFile ?? openAsBlob)(record.path).catch(() => {
     throw new ZasError("upload_failed", 400);
   });
   if (opened.size !== record.size) throw new ZasError("file_changed", 0);
+  ctx.transferTelemetry?.describe(record.size);
   const file = new File([opened], record.name, { type: mimeFor(record.path) });
   const { seal } = sealer(record.key, record.key_version);
   const stamp = { device: record.device, owner_uid: record.owner_uid };
@@ -2970,20 +3798,38 @@ async function sendDirectFallback(ctx, record, report2, deps = {}) {
     parts: parts.length
   };
 }
-
-// src/receive.ts
-import { randomBytes as randomBytes3 } from "node:crypto";
-import {
-  closeSync as closeSync2,
-  existsSync as existsSync3,
-  mkdirSync as mkdirSync3,
-  openSync as openSync2,
-  renameSync as renameSync3,
-  rmdirSync as rmdirSync2,
-  unlinkSync as unlinkSync2,
-  writeSync as writeSync2
-} from "node:fs";
-import { dirname as dirname2 } from "node:path";
+async function sendDirect(...args) {
+  const telemetry = new TransferTelemetry(args[0].client, "upload", "file", "direct");
+  try {
+    const report2 = args[2];
+    const result = await sendDirectMeasured({ ...args[0], transferTelemetry: telemetry }, args[1], (phase) => {
+      telemetry.mark(phase);
+      report2?.(phase);
+    }, args[3]);
+    telemetry.describe(result.bytes);
+    telemetry.finish("success", "none", false);
+    return result;
+  } catch (error) {
+    telemetry.failed(error);
+    throw error;
+  }
+}
+async function sendDirectFallback(...args) {
+  const telemetry = new TransferTelemetry(args[0].client, "upload", "file", "fallback");
+  try {
+    const report2 = args[2];
+    const result = await sendDirectFallbackMeasured({ ...args[0], transferTelemetry: telemetry }, args[1], (phase) => {
+      telemetry.mark(phase);
+      report2?.(phase);
+    }, args[3]);
+    telemetry.describe(result.bytes);
+    telemetry.finish("success", "none", false);
+    return result;
+  } catch (error) {
+    telemetry.failed(error);
+    throw error;
+  }
+}
 
 // src/read.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
@@ -3024,7 +3870,8 @@ function rowOf(doc) {
     agent: stringOf(fields.agent),
     createdAt: timeOf(fields.created_at),
     expiresAt: timeOf(fields.expires_at),
-    bar: fields.bar?.booleanValue === true
+    bar: fields.bar?.booleanValue === true,
+    updateTime: timeOf({ timestampValue: document.updateTime })
   };
 }
 function readable(row) {
@@ -3114,6 +3961,7 @@ function redeemFailure(status) {
   return new ZasError("invalid_cap", 403);
 }
 async function fetchChunk(ctx, chunk) {
+  ctx.transferTelemetry?.mark("authorization");
   if (typeof chunk.cap !== "string" || chunk.cap === "") throw new ZasError("invalid_cap", 403);
   let headers = {};
   try {
@@ -3136,6 +3984,7 @@ async function fetchChunk(ctx, chunk) {
     throw err;
   }
   if (url === "") throw new ZasError("invalid_cap", 403);
+  ctx.transferTelemetry?.mark("downloading");
   const res = await fetch(url);
   if (!res.ok) {
     await res.body?.cancel().catch(() => void 0);
@@ -3143,6 +3992,7 @@ async function fetchChunk(ctx, chunk) {
   }
   const ciphertext = new Uint8Array(await res.arrayBuffer());
   try {
+    ctx.transferTelemetry?.mark("decrypting");
     return decryptChunk(b64ToBytes(chunk.key), b64ToBytes(chunk.nonce), ciphertext);
   } catch {
     throw new ZasError("invalid_cap", 403);
@@ -3171,7 +4021,7 @@ function destinationOf(dest, name, fallback) {
   const at = statSync2(dest, { throwIfNoEntry: false })?.isDirectory() ? join2(dest, base) : dest;
   return { target: freeName(at) };
 }
-async function getItem(ctx, channel, id, dest) {
+async function loadItem(ctx, channel, id) {
   const grant = await readGrant(ctx, channel);
   if (!ID_SEGMENT.test(id)) throw new ZasError("not_found", 404);
   const channelKey = channelKeyOf(ctx.identity, grant);
@@ -3190,6 +4040,12 @@ async function getItem(ctx, channel, id, dest) {
   if (!row || !readable(row)) throw new ZasError("not_found", 404);
   const manifest = openFor(channelKey, row);
   if (!manifest) throw new ZasError("not_found", 404);
+  return { grant, channelKey, row, manifest };
+}
+async function getItemMeasured(ctx, channel, id, dest) {
+  ctx.transferTelemetry?.mark("authorization");
+  const { row, manifest } = await loadItem(ctx, channel, id);
+  ctx.transferTelemetry?.describe(manifest.size, itemKind2(manifest), manifest.kind === "text" ? "manifest" : "storage");
   if (manifest.kind === "text") {
     const text2 = manifest.text ?? "";
     return { text: text2, bytes: new TextEncoder().encode(text2).length };
@@ -3209,7 +4065,10 @@ async function getItem(ctx, channel, id, dest) {
     tmp = `${target}.${randomBytes2(6).toString("hex")}.tmp`;
     fd = openSync(tmp, "wx", 384);
     for (const chunk of manifest.chunks) {
-      written += writeSync(fd, await fetchChunk(ctx, chunk));
+      const bytes = await fetchChunk(ctx, chunk);
+      ctx.transferTelemetry?.mark("assembling");
+      written += writeSync(fd, bytes);
+      ctx.transferTelemetry?.progress(written);
     }
     const size = typeof manifest.size === "number" ? manifest.size : 0;
     if (size > 0 && written !== size) throw new ZasError("not_found", 404);
@@ -3239,867 +4098,577 @@ async function getItem(ctx, channel, id, dest) {
   }
   return { path: target, bytes: written };
 }
+async function getItem(...args) {
+  const telemetry = new TransferTelemetry(args[0].client, "download", "unknown", "manifest");
+  try {
+    const result = await getItemMeasured({ ...args[0], transferTelemetry: telemetry }, ...args.slice(1));
+    telemetry.describe(result.bytes);
+    telemetry.finish("success", "none", false);
+    return result;
+  } catch (error) {
+    telemetry.failed(error);
+    throw error;
+  }
+}
 
-// src/receive.ts
-var OFFER_WAIT_MS2 = 9.5 * 60 * 1e3;
-var OFFER_POLL_MS2 = 1e3;
-var SIGNAL_POLL_MS2 = 400;
-var OFFER_PAGE = 10;
-var OPEN_OFFERS = {
-  from: [{ collectionId: "direct" }],
-  orderBy: [{ field: { fieldPath: "created_at" }, direction: "DESCENDING" }],
-  limit: OFFER_PAGE
-};
-var SIGNALS_FOR_RECEIVER = {
-  from: [{ collectionId: "signals" }],
-  where: { fieldFilter: { field: { fieldPath: "for" }, op: "EQUAL", value: { stringValue: "receiver" } } }
-};
-var stringField2 = (doc, key) => doc?.fields?.[key]?.stringValue;
-var idOf = (doc) => (doc.name ?? "").split("/").pop() ?? "";
-async function receiveGrantFor(ctx, channel) {
-  const grant = resolveChannel(ctx.identity, await grantsFor(ctx.client, ctx.profile), channel);
-  if (!grant.read) throw new ZasError("read_forbidden", 403);
-  if (!grant.direct_mode) throw new ZasError("not_direct_mode", 409);
-  return grant;
+// src/edit.ts
+function writable(grant) {
+  if (!grant.send || grant.mode === "view") throw new ZasError("send_forbidden", 403);
+  if (grant.direct_mode) throw new ZasError("direct_mode", 409);
 }
-var DiskSink = class {
-  constructor(dest, fallbackName) {
-    this.dest = dest;
-    this.fallbackName = fallbackName;
-  }
-  /** Where the bytes will be once `close` has run. */
-  target;
-  written = 0;
-  /** A filesystem refusal, kept so the run can answer `write_failed` rather
-   *  than reporting the engine's generic sink failure. */
-  failure;
-  created;
-  tmp;
-  fd;
-  open(meta) {
-    try {
-      const chosen = destinationOf(this.dest, meta.name, this.fallbackName);
-      this.target = chosen.target;
-      this.created = chosen.created;
-      mkdirSync3(dirname2(this.target), { recursive: true, mode: 448 });
-      this.tmp = `${this.target}.${randomBytes3(6).toString("hex")}.tmp`;
-      this.fd = openSync2(this.tmp, "wx", 384);
-    } catch (error) {
-      throw this.remember(error);
-    }
-  }
-  write(bytes) {
-    try {
-      if (this.fd === void 0) throw new Error("sink_closed");
-      this.written += writeSync2(this.fd, bytes);
-    } catch (error) {
-      throw this.remember(error);
-    }
-  }
-  close() {
-    try {
-      if (this.fd === void 0) return;
-      closeSync2(this.fd);
-      this.fd = void 0;
-      renameSync3(this.tmp, this.target);
-      this.tmp = void 0;
-    } catch (error) {
-      throw this.remember(error);
-    }
+async function ownItem(ctx, channel, id) {
+  const loaded = await loadItem(ctx, channel, id);
+  writable(loaded.grant);
+  if (loaded.row.agent !== ctx.identity.agent_uid) throw new ZasError("not_yours", 403);
+  return loaded;
+}
+function sealedFor(item, manifest) {
+  return bytesToB64(sealManifest(item.channelKey, manifest, item.grant.key_version));
+}
+function guardOf(item) {
+  return item.row.updateTime === null ? {} : { expected_update_time: item.row.updateTime };
+}
+async function editItem(ctx, input) {
+  const item = await ownItem(ctx, input.channel, input.id);
+  const { grant, row, manifest } = item;
+  const kind = manifest.kind === "text" ? "text" : "file";
+  const noteFields = input.text !== void 0 || input.lang !== void 0 || input.secret !== void 0;
+  if (noteFields && kind !== "text") throw new ZasError("not_a_note", 400);
+  const done = (updateTime) => ({
+    link_id: row.id,
+    channel_id: grant.channel_id,
+    channel_name: channelNameOf(ctx.identity, grant),
+    kind,
+    title: manifest.title ?? manifest.name,
+    update_time: updateTime
+  });
+  if (input.title === void 0 && !noteFields) return done(row.updateTime ?? Date.now());
+  if (input.title !== void 0) {
+    if (input.title === "") delete manifest.title;
+    else manifest.title = input.title;
   }
-  /** Best effort, and safe to call twice: the engine aborts on every failure
-   *  path of its own, and the job aborts again on the way out. */
-  abort() {
-    if (this.fd !== void 0) {
-      try {
-        closeSync2(this.fd);
-      } catch {
-      }
-      this.fd = void 0;
-    }
-    if (this.tmp !== void 0) {
-      if (existsSync3(this.tmp)) try {
-        unlinkSync2(this.tmp);
-      } catch {
-      }
-      this.tmp = void 0;
-    }
-    if (this.created !== void 0) {
-      try {
-        rmdirSync2(this.created);
-      } catch {
-      }
-      this.created = void 0;
-    }
+  if (input.text !== void 0) {
+    manifest.text = input.text;
+    manifest.size = new TextEncoder().encode(input.text).length;
+    delete manifest.html;
+    if (manifest.title === void 0) manifest.name = noteName(input.text);
   }
-  /** A `ZasError` says what happened already. An errno does not, so it is kept
-   *  and turned into one sentence by the caller — recognised by the shape Node
-   *  puts on it (`syscall`/`errno`) rather than by `code`, which `ZasError`
-   *  also carries. */
-  remember(error) {
-    const failure = error;
-    if (typeof failure?.syscall === "string" || typeof failure?.errno === "number") this.failure = failure;
-    return error;
+  if (input.lang !== void 0) {
+    if (input.lang === "") delete manifest.code;
+    else manifest.code = { lang: input.lang, auto: false };
   }
-};
-async function receiveDirect(ctx, input, report2, deps = {}) {
-  const now = deps.now ?? (() => Date.now());
-  const sleep2 = deps.sleep ?? defaultSleep2;
-  const grant = await receiveGrantFor(ctx, input.channel);
-  const key = channelKeyOf(ctx.identity, grant);
-  const channelName = channelLabel(ctx, grant);
-  const cid = grant.channel_id;
-  const owner = ctx.identity.owner_uid;
-  const account = channelAccountOf(ctx.identity, grant);
-  const device = deps.device ?? newDeviceToken();
-  const { seal, open } = sealer(key, grant.key_version);
-  const stamp = { device, owner_uid: owner };
-  const startedAt = now();
-  const channelPath = `accounts/${account}/channels/${cid}`;
-  report2("waiting");
-  const waitUntil = startedAt + (deps.offerWaitMs ?? OFFER_WAIT_MS2);
-  let id;
-  let meta;
-  while (id === void 0) {
-    const rows = await ctx.client.firestoreRunQuery(channelPath, OPEN_OFFERS).catch(() => []);
-    for (const row of rows) {
-      if (stringField2(row, "state") !== "open") continue;
-      if (stringField2(row, "sender") === ctx.identity.agent_uid) continue;
-      const enc = stringField2(row, "meta_enc");
-      if (enc === void 0) continue;
-      let candidate;
-      try {
-        candidate = open(enc);
-      } catch {
-        continue;
-      }
-      if (typeof candidate?.name !== "string" || typeof candidate?.size !== "number") continue;
-      if (candidate.size > DIRECT_FILE_MAX_BYTES) throw new ZasError("file_too_big", 413);
-      const offerId2 = idOf(row);
-      if (offerId2 === "") continue;
-      try {
-        await ctx.client.api("POST", `/direct/${cid}/${offerId2}/claim`, { size_bytes: candidate.size, ...stamp });
-      } catch (error) {
-        const word = error instanceof ZasError ? error.serverCode ?? error.code : "";
-        if (word === "claimed") throw new ZasError("offer_taken", 409);
-        if (word === "expired" || word === "own_offer" || word === "not_found") continue;
-        throw error;
-      }
-      id = offerId2;
-      meta = candidate;
-      break;
-    }
-    if (id !== void 0) break;
-    if (now() >= waitUntil) throw new ZasError("no_offer", 0);
-    await sleep2(deps.offerPollMs ?? OFFER_POLL_MS2);
+  if (input.secret !== void 0) {
+    if (input.secret) manifest.sensitive = true;
+    else delete manifest.sensitive;
   }
-  const offered = meta;
-  const offerId = id;
-  const route = `/direct/${cid}/${offerId}`;
-  const offerPath = `${channelPath}/direct/${offerId}`;
-  const setState = (state) => ctx.client.api("POST", `${route}/state`, { state, ...stamp }).then(() => void 0, () => void 0);
-  await (deps.installWebRtc ?? installWebRtc)();
-  const fetchIce = async () => {
-    try {
-      const r = await ctx.client.api("POST", `${route}/ice`, stamp);
-      return Array.isArray(r.ice) ? r.ice : [];
-    } catch {
-      return [];
+  const answer = await ctx.client.api(
+    "PATCH",
+    `/links/${grant.channel_id}/${row.id}`,
+    {
+      manifest_enc: sealedFor(item, manifest),
+      // The caller is changing what the item says: the server records it.
+      edit: true,
+      ...guardOf(item)
     }
-  };
-  const turn = await fetchIce();
-  report2("connecting");
-  const sink = new DiskSink(input.dest, offerId);
-  let resolveOutcome;
-  const outcome = new Promise((resolve2) => {
-    resolveOutcome = resolve2;
+  );
+  forgetLink(ctx.profile, row.id);
+  return done(typeof answer.update_time === "number" ? answer.update_time : Date.now());
+}
+async function replaceFile(ctx, input, onPhase) {
+  await checkFilePath(input.path);
+  const item = await ownItem(ctx, input.channel, input.id);
+  const { grant, row, manifest } = item;
+  if (manifest.kind === "text") throw new ZasError("not_a_file", 400);
+  const { bytes, name } = await readFileChecked(input.path);
+  const title = input.title ?? manifest.title;
+  const contentHash = await blake3Hex(bytes);
+  const placed = await placeFile(ctx, bytes, onPhase);
+  onPhase?.("finishing");
+  const mime = mimeFor(input.path);
+  const thumb = await thumbnailFor(bytes, mime);
+  const next = newManifest({
+    kind: "file",
+    name,
+    ...title !== void 0 ? { title } : {},
+    mime,
+    size: bytes.length,
+    // The item's own time: a replace changes what the item holds, not when the
+    // owner got it, and the row keeps its place in the channel either way.
+    created_at: manifest.created_at || (/* @__PURE__ */ new Date()).toISOString(),
+    ...thumb ? { thumb_data: thumb } : {},
+    chunks: placed.map((p) => p.entry)
   });
-  let diag;
-  let via;
-  const handle = (deps.engine ?? startReceiver)({
-    ice: [...DIRECT_ICE, ...turn],
-    refreshIce: async () => [...DIRECT_ICE, ...await fetchIce()],
-    // The name and size this end read off the offer. The engine refuses a
-    // sender that announces anything else.
-    expectedMeta: offered,
-    send: (msg) => ctx.client.api("POST", `${route}/signal`, { payload_enc: seal(msg), for: "sender", ...stamp }).then(() => void 0),
-    onPhase: (phase2) => {
-      if (phase2 === "flight") report2("flight");
-      if (phase2 === "done" || phase2 === "failed") resolveOutcome(phase2);
-    },
-    onPath: (p) => {
-      via = p;
-    },
-    onDiag: (d) => {
-      diag = d;
-      deps.onDiag?.(d);
-    },
-    sink: async (m) => {
-      sink.open(m);
-      return sink;
-    }
+  const release = manifest.chunks.map((c) => c.cap).filter((cap) => typeof cap === "string");
+  const answer = await ctx.client.api("POST", `/links/${grant.channel_id}/${row.id}/replace`, {
+    manifest_enc: sealedFor(item, next),
+    caps: placed.map((p) => p.entry.cap).filter((cap) => typeof cap === "string"),
+    release,
+    // Scoped to the link as well as the channel: the same bytes sent as a new
+    // item are a different request from these bytes replacing this one.
+    idempotency_key: agentSendIdempotencyKey(`${grant.channel_id}/${row.id}`, contentHash, title ?? name),
+    ...guardOf(item)
   });
-  let over = false;
-  const pump = (async () => {
-    const seen = /* @__PURE__ */ new Set();
-    while (!over) {
-      let rows = [];
-      try {
-        rows = await ctx.client.firestoreRunQuery(offerPath, SIGNALS_FOR_RECEIVER);
-      } catch {
-      }
-      for (const row of rows) {
-        if (!row?.name || seen.has(row.name)) continue;
-        seen.add(row.name);
-        const enc = stringField2(row, "payload_enc");
-        if (!enc) continue;
-        try {
-          handle.accept(open(enc));
-        } catch {
-        }
-      }
-      if (!over) await Promise.race([outcome, sleep2(deps.signalPollMs ?? SIGNAL_POLL_MS2)]);
-    }
-  })();
-  const phase = await outcome;
-  over = true;
-  await pump;
-  report2("finishing");
-  if (phase === "done") {
-    await setState("done");
-    return {
-      offer_id: offerId,
-      channel_id: cid,
-      channel_name: channelName,
-      name: offered.name,
-      bytes: sink.written,
-      path: sink.target,
-      ...via ? { via } : {},
-      duration_ms: now() - startedAt
-    };
-  }
-  sink.abort();
-  const doc = await ctx.client.firestoreGet(offerPath).catch(() => null);
-  const withdrawn = doc === null || stringField2(doc, "state") === "cancelled";
-  await setState("failed");
-  if (sink.failure) throw new ZasError("write_failed", 0, sink.failure.message);
-  if (withdrawn) throw new ZasError("direct_cancelled", 0);
-  const reason = diag?.reason || "unknown";
-  deps.onFailed?.({
-    channel_id: cid,
-    channel_name: channelName,
-    offer_id: offerId,
-    owner_uid: owner,
-    channel_account: account,
-    device,
-    ...input.dest !== void 0 ? { dest: input.dest } : {},
-    meta: offered,
-    key,
-    key_version: grant.key_version,
-    reason
-  });
-  throw new ZasError("direct_failed", 0, reason);
-}
-async function receiveDirectFallback(ctx, record, report2, deps = {}) {
-  const now = deps.now ?? (() => Date.now());
-  const startedAt = now();
-  const { open } = sealer(record.key, record.key_version);
-  const stamp = { device: record.device, owner_uid: record.owner_uid };
-  const base = `/direct/${record.channel_id}/${record.offer_id}/fallback`;
-  const offerPath = `accounts/${record.channel_account}/channels/${record.channel_id}/direct/${record.offer_id}`;
-  const doc = await ctx.client.firestoreGet(offerPath);
-  const enc = stringField2(doc, "fallback_meta_enc");
-  let meta;
-  if (enc !== void 0) {
-    try {
-      meta = fallbackMetaOf(open(enc));
-    } catch {
-      meta = void 0;
-    }
-  }
-  if (!meta) throw new ZasError("fallback_unavailable", 409);
-  if (meta.name !== record.meta.name || meta.size !== record.meta.size || meta.mime !== record.meta.mime) {
-    throw new ZasError("file_changed", 0);
-  }
-  const sink = new DiskSink(record.dest, record.offer_id);
-  report2("downloading");
-  try {
-    sink.open(meta);
-    await downloadFallback({
-      offerId: record.offer_id,
-      meta,
-      sink,
-      getUrl: async () => (await ctx.client.api("POST", `${base}/download`, stamp)).url,
-      ...deps.fetcher ? { fetcher: deps.fetcher } : {}
-    });
-  } catch (error) {
-    sink.abort();
-    if (sink.failure) throw new ZasError("write_failed", 0, sink.failure.message);
-    if (error instanceof ZasError) throw error;
-    throw new ZasError("network", 0, error instanceof Error ? error.message : String(error));
-  }
-  report2("finishing");
-  await ctx.client.api("POST", `${base}/received`, stamp);
-  return {
-    offer_id: record.offer_id,
-    channel_id: record.channel_id,
-    channel_name: record.channel_name,
-    name: meta.name,
-    bytes: sink.written,
-    path: sink.target,
-    duration_ms: now() - startedAt
-  };
-}
-
-// src/jobs.ts
-import { randomUUID } from "node:crypto";
-var DEFAULT_WAIT_MS = 6e4;
-var HISTORY = 50;
-var JobRunner = class {
-  now;
-  waitMs;
-  /** Newest first, and trimmed. */
-  jobs = [];
-  /** Keyed on the job object, not its id, so a caller holding a job that has
-   *  already aged out of the list can still wait for it to finish. */
-  settled = /* @__PURE__ */ new WeakMap();
-  constructor(opts = {}) {
-    this.now = opts.now ?? (() => Date.now());
-    this.waitMs = opts.waitMs ?? DEFAULT_WAIT_MS;
-  }
-  start(kind, title, channel, work) {
-    const job = {
-      id: randomUUID(),
-      kind,
-      title,
-      channel,
-      started_at: this.now(),
-      phase: null,
-      status: "running"
-    };
-    this.jobs.unshift(job);
-    this.jobs.length = Math.min(this.jobs.length, HISTORY);
-    const report2 = (phase) => {
-      if (job.status === "running") job.phase = phase;
-    };
-    const note = (diag) => {
-      job.diag = diag;
-    };
-    this.settled.set(job, work(report2, note).then(
-      (result) => {
-        job.status = "done";
-        job.result = result;
-        return job;
-      },
-      (error) => {
-        job.status = "failed";
-        job.error = error instanceof ZasError ? {
-          code: error.code,
-          status: error.status,
-          sentence: humanSentence(error),
-          message: error.message,
-          ...error.retryAfterMs !== void 0 ? { retryAfterMs: error.retryAfterMs } : {},
-          ...error.serverCode !== void 0 ? { serverCode: error.serverCode } : {}
-        } : { code: "upload_failed", status: 0, sentence: humanSentence(new ZasError("upload_failed", 0)) };
-        return job;
-      }
-    ));
-    return job;
-  }
-  /** Resolves when the work settles, or when the wait runs out — the same job
-   *  object either way, so the caller reads `status` rather than guessing. */
-  async wait(job) {
-    const settled = this.settled.get(job);
-    if (!settled) return job;
-    let timer;
-    const deadline = new Promise((resolve2) => {
-      timer = setTimeout(() => resolve2(job), this.waitMs);
-    });
-    try {
-      return await Promise.race([settled, deadline]);
-    } finally {
-      clearTimeout(timer);
-    }
-  }
-  list() {
-    return this.jobs.slice(0, HISTORY);
-  }
-  get(id) {
-    return this.jobs.find((job) => job.id === id);
-  }
-};
-
-// src/shared/product-analytics.ts
-var PRODUCT_EVENTS = [
-  "account_created",
-  "item.created",
-  "item.downloaded",
-  "item.copied",
-  "item.shared",
-  "item.pinned",
-  "item.unpinned",
-  "item.deleted",
-  "item.departed",
-  "channel_shared",
-  "channel_mode_set",
-  "invite_created",
-  "invite_link_copied",
-  "invite_qr_shown",
-  "invite_system_sheet_opened",
-  "invite_joined",
-  "invite_converted",
-  "channel.invite_preview",
-  "channel.invite_accept",
-  "channel.invite_signin",
-  "enterprise.invite_preview",
-  "enterprise.invite_identity",
-  "enterprise.invite_signin",
-  "enterprise.invite_account_switch",
-  "enterprise.invite_attach",
-  "enterprise.invite_accept",
-  "enterprise.invite_admin",
-  "enterprise.workspace_opened",
-  "enterprise.workspace_switched",
-  "enterprise.channel_created",
-  "enterprise.channel_members_added",
-  "share_link_copied",
-  "share_qr_shown",
-  "share_system_sheet_opened",
-  "share_opened",
-  "share_content_copied",
-  "share_downloaded",
-  "share_signin_click",
-  "share.saved",
-  "share_bar_on",
-  "share_bar_off",
-  "upload.phase_timing",
-  "auth.signin_started",
-  "auth.signin_result",
-  "auth.session_started",
-  "auth.signed_out",
-  "auth.session_lost",
-  "auth.token_refresh_failed",
-  "account_switch.started",
-  "account_switch.completed",
-  "account_switch.failed",
-  "bootstrap.result",
-  "direct_mode_set",
-  "direct.offered",
-  "direct.claimed",
-  "direct.connected",
-  "direct.completed",
-  "direct.received",
-  "direct.failed",
-  "direct.fallback_started",
-  "direct.fallback_ready",
-  "direct.fallback_received",
-  "direct.fallback_failed",
-  "direct.fallback_aborted",
-  "direct.too_big",
-  "agent.pair_opened",
-  "agent.pair_approved",
-  "agent.pair_refused",
-  "agent.paired",
-  "agent.revoked",
-  "agent.send",
-  "agent.tool_call"
-];
-var SERVER_OWNED_PRODUCT_EVENTS = [
-  "account_created",
-  "item.departed",
-  "invite_created",
-  "invite_joined",
-  "invite_converted",
-  "share_opened",
-  "share_content_copied",
-  "share_downloaded",
-  "share_signin_click",
-  "agent.send",
-  "agent.tool_call"
-];
-var SERVER_OWNED_PRODUCT_EVENT_SET = new Set(SERVER_OWNED_PRODUCT_EVENTS);
-var CLIENT_PRODUCT_EVENTS = PRODUCT_EVENTS.filter(
-  (event) => !SERVER_OWNED_PRODUCT_EVENT_SET.has(event)
-);
-var bool = { type: "boolean" };
-var count = { type: "number", min: 0 };
-var oneOf = (...values) => ({ type: "string", values: new Set(values) });
-var sizeBucket = oneOf("lt_1mb", "1_10mb", "10_100mb", "100_512mb", "512mb_5gb", "gt_5gb");
-var itemKind = oneOf("file", "text");
-var itemKindOrUnknown = oneOf("file", "text", "unknown");
-var role = oneOf("sender", "receiver");
-var candidateType = oneOf("", "host", "srflx", "relay", "prflx", "other");
-var enterpriseRole = oneOf("owner", "admin", "billing_admin", "member", "guest");
-var agentKind = oneOf("claude_code", "codex", "other");
-var pairHandoff = oneOf("loopback", "manual", "unknown");
-var AGENT_TOOL_NAMES = [
-  "status",
-  "pair",
-  "send_file",
-  "send_note",
-  "send_direct",
-  "send_direct_fallback",
-  "receive_direct",
-  "receive_direct_fallback",
-  "list_items",
-  "get_item",
-  "jobs"
-];
-var AGENT_ERROR_CODES = [
-  "none",
-  "other",
-  "identity_corrupt",
-  "not_paired",
-  "internal",
-  "agent_forbidden",
-  "agent_revoked",
-  "grant_missing",
-  "not_found",
-  "invalid_cap",
-  "write_failed",
-  "send_forbidden",
-  "read_forbidden",
-  "direct_mode",
-  "not_direct_mode",
-  "not_claimed",
-  "no_offer",
-  "offer_taken",
-  "direct_cancelled",
-  "direct_failed",
-  "direct_not_failed",
-  "file_changed",
-  "webrtc_unavailable",
-  "fallback_unavailable",
-  "key_stale",
-  "quota_exceeded",
-  "rate_limited",
-  "file_too_big",
-  "duplicate",
-  "pairing_expired",
-  "pairing_cancelled",
-  "claim_mismatch",
-  "pairing_not_approved",
-  "pairing_claimed",
-  "agent_limit",
-  "grant_limit",
-  "feature_disabled",
-  "upload_failed",
-  "oprf_failed",
-  "network",
-  "sign_in_failed",
-  "bad_signature",
-  "missing_token"
-];
-function agentDurationBucket(ms) {
-  if (ms < 1e3) return "lt_1s";
-  if (ms < 1e4) return "1_10s";
-  if (ms < 6e4) return "10_60s";
-  return "gt_60s";
-}
-var EVENT_PROPERTY_RULES = {
-  account_created: {},
-  "item.created": { kind: itemKind, size_bytes: count, size_bucket: sizeBucket },
-  "item.downloaded": { size_bytes: count, size_bucket: sizeBucket },
-  "item.copied": {},
-  "item.shared": { kind: itemKind },
-  "item.pinned": { age_ms: count },
-  "item.unpinned": {},
-  "item.deleted": { age_ms: count, was_pinned: bool, kind: itemKindOrUnknown },
-  "item.departed": {},
-  channel_shared: {},
-  channel_mode_set: { mode: oneOf("edit", "view") },
-  invite_created: {},
-  invite_link_copied: {},
-  invite_qr_shown: {},
-  invite_system_sheet_opened: {},
-  invite_joined: {},
-  invite_converted: {},
-  "channel.invite_preview": {
-    outcome: oneOf("ready", "unavailable", "missing_key"),
-    signed_in: bool
-  },
-  "channel.invite_accept": {
-    outcome: oneOf("started", "completed", "already_member", "unavailable", "failed")
-  },
-  "channel.invite_signin": {
-    stage: oneOf("link_requested", "link_sent", "link_completed", "failed")
-  },
-  "enterprise.invite_preview": {
-    outcome: oneOf("pending", "resumable", "unavailable"),
-    role: enterpriseRole
-  },
-  "enterprise.invite_identity": {
-    outcome: oneOf("matched", "mismatched", "unavailable", "failed")
-  },
-  "enterprise.invite_signin": {
-    stage: oneOf("link_requested", "link_sent", "link_completed", "failed")
-  },
-  "enterprise.invite_account_switch": { stage: oneOf("started", "completed", "failed") },
-  "enterprise.invite_attach": {
-    stage: oneOf("link_requested", "link_sent", "verify_started", "completed", "address_taken", "link_invalid", "failed")
-  },
-  "enterprise.invite_accept": {
-    outcome: oneOf("started", "completed", "recovered", "timeout", "unavailable", "email_mismatch", "seat_limit", "failed"),
-    role: enterpriseRole,
-    destination: oneOf("workspace", "admin_console"),
-    duration_ms: count
-  },
-  "enterprise.invite_admin": {
-    outcome: oneOf("created", "email_sent", "email_failed", "reissued", "revoked"),
-    role: enterpriseRole,
-    external: bool
-  },
-  "enterprise.workspace_opened": { role: enterpriseRole, first_visit: bool },
-  "enterprise.workspace_switched": { destination: oneOf("personal", "organization"), role: enterpriseRole },
-  "enterprise.channel_created": { member_count: count },
-  "enterprise.channel_members_added": { member_count: count },
-  share_link_copied: {},
-  share_qr_shown: {},
-  share_system_sheet_opened: {},
-  share_opened: {},
-  share_content_copied: {},
-  share_downloaded: {},
-  share_signin_click: {},
-  "share.saved": {},
-  share_bar_on: {},
-  share_bar_off: {},
-  "upload.phase_timing": {
-    stage: oneOf("staging", "bootstrap", "thumbnail", "encrypting", "uploading", "finishing"),
-    duration_ms: count,
-    size_bucket: sizeBucket,
-    outcome: oneOf("success", "failure", "cancelled"),
-    attempt: { type: "number", min: 1 }
-  },
-  "auth.signin_started": { provider: oneOf("google.com", "apple.com") },
-  "auth.signin_result": {
-    provider: oneOf("google.com", "apple.com"),
-    outcome: oneOf("signed_in", "cancelled", "taken", "failed", "needs_link"),
-    flow: oneOf("signin", "link", "connect")
-  },
-  "account_switch.started": { operation: oneOf("remember", "switch"), provider: oneOf("google.com", "apple.com", "email_link", "qr", "code") },
-  "account_switch.completed": { operation: oneOf("remember", "switch"), provider: oneOf("google.com", "apple.com", "email_link", "qr", "code") },
-  "account_switch.failed": { operation: oneOf("remember", "switch"), provider: oneOf("google.com", "apple.com", "email_link", "qr", "code") },
-  "auth.session_started": { cold: bool },
-  "auth.signed_out": { reason: oneOf("user", "account_switch", "abandoned_new_account", "account_deleted") },
-  "auth.session_lost": { session_age_ms: count, foreground: bool },
-  "auth.token_refresh_failed": {
-    code: oneOf("network", "token_invalid", "user_disabled", "user_missing", "rate_limited", "internal", "unknown")
-  },
-  "bootstrap.result": {
-    outcome: oneOf("offline", "ok", "timeout_warm", "timeout", "failed_warm", "failed"),
-    stage: oneOf("cached", "done", "unknown", "keyring", "account_init", "listeners"),
-    duration_ms: count,
-    fault: oneOf("intercepted", "offline", "unknown")
-  },
-  direct_mode_set: { on: bool },
-  "direct.offered": { size_bucket: sizeBucket },
-  // `via_agent`: the offer came from a paired agent's process, not from one
-  // of the person's devices. The claim and the two receiver outcomes carry it.
-  "direct.claimed": { size_bucket: sizeBucket, via_agent: bool },
-  "direct.connected": { role, ms: count },
-  "direct.completed": {
-    via: oneOf("lan", "wan", "relay", "unknown"),
-    pair_local: candidateType,
-    pair_remote: candidateType,
-    connect_ms: count,
-    duration_ms: count,
-    size_bucket: sizeBucket,
-    turn_urls_supplied: count,
-    turn_urls_configured: count,
-    restarts: count
-  },
-  "direct.received": {
-    via_agent: bool,
-    via: oneOf("lan", "wan", "relay", "unknown"),
-    pair_local: candidateType,
-    pair_remote: candidateType,
-    connect_ms: count,
-    duration_ms: count,
-    size_bucket: sizeBucket,
-    turn_urls_supplied: count,
-    turn_urls_configured: count,
-    restarts: count
-  },
-  "direct.failed": {
-    role,
-    via_agent: bool,
-    reason: oneOf(
-      "peer_silent",
-      "connect_timeout",
-      "ice_failed",
-      "disconnected",
-      "peer_closed",
-      "peer_abort",
-      "signaling",
-      "signal_send",
-      "protocol",
-      "sink",
-      "transfer",
-      "integrity",
-      "too_big",
-      "unknown"
-    ),
-    ms: count,
-    ice_state: oneOf("", "new", "checking", "connected", "completed", "failed", "disconnected", "closed"),
-    gather_state: oneOf("", "new", "gathering", "complete"),
-    had_remote: bool,
-    local_host: count,
-    local_srflx: count,
-    local_relay: count,
-    remote_host: count,
-    remote_srflx: count,
-    remote_relay: count,
-    turn_urls_supplied: count,
-    turn_urls_configured: count,
-    moved_bucket: sizeBucket,
-    size_bucket: sizeBucket,
-    restarts: count,
-    // Whether the reporting tab was on screen when the run died — the lead a
-    // slept machine or a frozen background tab leaves behind.
-    visibility: oneOf("visible", "hidden", "prerender")
-  },
-  "direct.fallback_started": { size_bucket: sizeBucket },
-  "direct.fallback_ready": { size_bucket: sizeBucket, duration_ms: count, retries: count },
-  "direct.fallback_received": { size_bucket: sizeBucket, duration_ms: count, retries: count },
-  "direct.fallback_failed": {
-    stage: oneOf("upload", "download"),
-    size_bucket: sizeBucket,
-    retries: count
-  },
-  "direct.fallback_aborted": {},
-  "direct.too_big": { size_bucket: sizeBucket },
-  "agent.pair_opened": { agent_kind: agentKind, protocol: count, replaces: bool },
-  "agent.pair_approved": {
-    agent_kind: agentKind,
-    destination: oneOf("new_channel", "existing"),
-    channels: count,
-    handoff: pairHandoff
-  },
-  "agent.pair_refused": {
-    agent_kind: agentKind,
-    step: oneOf("open", "approve", "claim"),
-    reason: oneOf(
-      "agent_limit",
-      "grant_limit",
-      "channel_limit",
-      "code_mismatch",
-      "pairing_expired",
-      "pairing_cancelled",
-      "pairing_claimed",
-      "feature_disabled",
-      "rate_limited",
-      "network",
-      "other"
-    )
-  },
-  "agent.paired": {
-    agent_kind: agentKind,
-    destination: oneOf("new_channel", "existing"),
-    channels: count,
-    handoff: pairHandoff,
-    protocol: count
-  },
-  "agent.revoked": { agent_kind: agentKind },
-  "agent.send": { size_bucket: sizeBucket, agent_kind: agentKind },
-  // What the CLI reports after every tool call: the tool, whether it worked,
-  // the code when it did not, and the version that answered. No path, no file
-  // name, no channel, no sentence.
-  "agent.tool_call": {
-    tool: oneOf(...AGENT_TOOL_NAMES),
-    result: oneOf("ok", "error"),
-    code: oneOf(...AGENT_ERROR_CODES),
-    agent_kind: agentKind,
-    duration_bucket: oneOf("lt_1s", "1_10s", "10_60s", "gt_60s"),
-    version_major: count,
-    version_minor: count,
-    version_patch: count
+  const bound = answer.caps ?? {};
+  let patched = false;
+  for (const p of placed) {
+    const cap = bound[p.entry.blob_id];
+    if (cap) {
+      p.entry.cap = cap;
+      patched = true;
+    }
+  }
+  if (patched) {
+    await ctx.client.api("PATCH", `/links/${grant.channel_id}/${row.id}`, { manifest_enc: sealedFor(item, next) });
   }
+  forgetLink(ctx.profile, row.id);
+  return {
+    link_id: row.id,
+    channel_id: grant.channel_id,
+    channel_name: channelNameOf(ctx.identity, grant),
+    bytes: bytes.length,
+    chunks: placed.length,
+    deduplicated: placed.filter((p) => p.proven).length,
+    replayed: answer.replayed === true
+  };
+}
+
+// src/receive.ts
+import { randomBytes as randomBytes3 } from "node:crypto";
+import {
+  closeSync as closeSync2,
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync3,
+  openSync as openSync2,
+  renameSync as renameSync3,
+  rmdirSync as rmdirSync2,
+  unlinkSync as unlinkSync2,
+  writeSync as writeSync2
+} from "node:fs";
+import { dirname as dirname2 } from "node:path";
+var OFFER_WAIT_MS2 = 9.5 * 60 * 1e3;
+var OFFER_POLL_MS2 = 1e3;
+var SIGNAL_POLL_MS2 = 400;
+var OFFER_PAGE = 10;
+var OPEN_OFFERS = {
+  from: [{ collectionId: "direct" }],
+  orderBy: [{ field: { fieldPath: "created_at" }, direction: "DESCENDING" }],
+  limit: OFFER_PAGE
 };
-var platformRule = oneOf("web", "android", "ios", "agent", "unknown");
-var PERSON_PROPERTY_RULES = {
-  plan: oneOf("anon", "free", "pro", "max"),
-  locale: oneOf("es-AR", "pt-BR", "en"),
-  storage_bytes: count
+var SIGNALS_FOR_RECEIVER = {
+  from: [{ collectionId: "signals" }],
+  where: { fieldFilter: { field: { fieldPath: "for" }, op: "EQUAL", value: { stringValue: "receiver" } } }
 };
-
-// src/telemetry.ts
-var OFF_WORDS = /* @__PURE__ */ new Set(["0", "off", "false", "no"]);
-var ON_WORDS = /* @__PURE__ */ new Set(["1", "on", "true", "yes"]);
-function telemetryState() {
-  const env = (process.env.ZAS_AGENT_TELEMETRY ?? "").toLowerCase();
-  if (OFF_WORDS.has(env)) return { on: false, source: "env" };
-  if (ON_WORDS.has(env)) return { on: true, source: "env" };
-  if (process.env.DO_NOT_TRACK === "1") return { on: false, source: "do_not_track" };
-  const stored = loadSettings();
-  if (stored && typeof stored.telemetry === "boolean") return { on: stored.telemetry, source: "file" };
-  return { on: true, source: "default" };
-}
-function setTelemetry(on) {
-  const stored = loadSettings();
-  saveSettings({ ...stored ?? {}, version: 1, telemetry: on, decided_at: Date.now() });
-}
-function noticeShown() {
-  return typeof loadSettings()?.notified_at === "number";
-}
-function markNoticeShown() {
-  const stored = loadSettings();
-  saveSettings({ ...stored ?? {}, version: 1, notified_at: Date.now() });
+var stringField2 = (doc, key) => doc?.fields?.[key]?.stringValue;
+var idOf = (doc) => (doc.name ?? "").split("/").pop() ?? "";
+async function receiveGrantFor(ctx, channel) {
+  const grant = resolveChannel(ctx.identity, await grantsFor(ctx.client, ctx.profile), channel);
+  if (!grant.read) throw new ZasError("read_forbidden", 403);
+  if (!grant.direct_mode) throw new ZasError("not_direct_mode", 409);
+  return grant;
 }
-var TELEMETRY_NOTICE = [
-  "Zas collects usage data from this agent to improve the product: which tool",
-  "ran, whether it worked, the error code when it did not, how long it took,",
-  "and the version. Never file names, file contents, paths or channel names.",
-  "The data is linked to your Zas account.",
-  "Turn it off with: npx -y zas-agent telemetry off"
-].join("\n");
-var SOURCE_WORDS = {
-  env: "ZAS_AGENT_TELEMETRY",
-  do_not_track: "DO_NOT_TRACK",
-  file: "zas-agent telemetry",
-  default: "default"
+var DiskSink = class {
+  constructor(dest, fallbackName) {
+    this.dest = dest;
+    this.fallbackName = fallbackName;
+  }
+  /** Where the bytes will be once `close` has run. */
+  target;
+  written = 0;
+  /** A filesystem refusal, kept so the run can answer `write_failed` rather
+   *  than reporting the engine's generic sink failure. */
+  failure;
+  created;
+  tmp;
+  fd;
+  open(meta) {
+    try {
+      const chosen = destinationOf(this.dest, meta.name, this.fallbackName);
+      this.target = chosen.target;
+      this.created = chosen.created;
+      mkdirSync3(dirname2(this.target), { recursive: true, mode: 448 });
+      this.tmp = `${this.target}.${randomBytes3(6).toString("hex")}.tmp`;
+      this.fd = openSync2(this.tmp, "wx", 384);
+    } catch (error) {
+      throw this.remember(error);
+    }
+  }
+  write(bytes) {
+    try {
+      if (this.fd === void 0) throw new Error("sink_closed");
+      this.written += writeSync2(this.fd, bytes);
+    } catch (error) {
+      throw this.remember(error);
+    }
+  }
+  close() {
+    try {
+      if (this.fd === void 0) return;
+      closeSync2(this.fd);
+      this.fd = void 0;
+      renameSync3(this.tmp, this.target);
+      this.tmp = void 0;
+    } catch (error) {
+      throw this.remember(error);
+    }
+  }
+  /** Best effort, and safe to call twice: the engine aborts on every failure
+   *  path of its own, and the job aborts again on the way out. */
+  abort() {
+    if (this.fd !== void 0) {
+      try {
+        closeSync2(this.fd);
+      } catch {
+      }
+      this.fd = void 0;
+    }
+    if (this.tmp !== void 0) {
+      if (existsSync3(this.tmp)) try {
+        unlinkSync2(this.tmp);
+      } catch {
+      }
+      this.tmp = void 0;
+    }
+    if (this.created !== void 0) {
+      try {
+        rmdirSync2(this.created);
+      } catch {
+      }
+      this.created = void 0;
+    }
+  }
+  /** A `ZasError` says what happened already. An errno does not, so it is kept
+   *  and turned into one sentence by the caller — recognised by the shape Node
+   *  puts on it (`syscall`/`errno`) rather than by `code`, which `ZasError`
+   *  also carries. */
+  remember(error) {
+    const failure = error;
+    if (typeof failure?.syscall === "string" || typeof failure?.errno === "number") this.failure = failure;
+    return error;
+  }
 };
-function telemetryLine() {
-  const state = telemetryState();
-  return `telemetry: ${state.on ? "on" : "off"} (${SOURCE_WORDS[state.source]})`;
-}
-var TOOL_NAMES = new Set(AGENT_TOOL_NAMES);
-function versionParts(version) {
-  const [major = 0, minor = 0, patch = 0] = version.split("-")[0].split(".").map((part) => {
-    const value = Number.parseInt(part, 10);
-    return Number.isFinite(value) && value >= 0 ? value : 0;
+async function receiveDirectMeasured(ctx, input, report2, deps = {}) {
+  const now = deps.now ?? (() => Date.now());
+  const sleep2 = deps.sleep ?? defaultSleep2;
+  const grant = await receiveGrantFor(ctx, input.channel);
+  const key = channelKeyOf(ctx.identity, grant);
+  const channelName = channelLabel(ctx, grant);
+  const cid = grant.channel_id;
+  const owner = ctx.identity.owner_uid;
+  const account = channelAccountOf(ctx.identity, grant);
+  const device = deps.device ?? newDeviceToken();
+  const { seal, open } = sealer(key, grant.key_version);
+  const stamp = { device, owner_uid: owner };
+  const startedAt = now();
+  const channelPath = `accounts/${account}/channels/${cid}`;
+  report2("waiting");
+  const waitUntil = startedAt + (deps.offerWaitMs ?? OFFER_WAIT_MS2);
+  let id;
+  let meta;
+  while (id === void 0) {
+    const rows = await ctx.client.firestoreRunQuery(channelPath, OPEN_OFFERS).catch(() => []);
+    for (const row of rows) {
+      if (stringField2(row, "state") !== "open") continue;
+      if (stringField2(row, "sender") === ctx.identity.agent_uid) continue;
+      const enc = stringField2(row, "meta_enc");
+      if (enc === void 0) continue;
+      let candidate;
+      try {
+        candidate = open(enc);
+      } catch {
+        continue;
+      }
+      if (typeof candidate?.name !== "string" || typeof candidate?.size !== "number") continue;
+      if (candidate.size > DIRECT_FILE_MAX_BYTES) throw new ZasError("file_too_big", 413);
+      const offerId2 = idOf(row);
+      if (offerId2 === "") continue;
+      try {
+        await ctx.client.api("POST", `/direct/${cid}/${offerId2}/claim`, { size_bytes: candidate.size, ...stamp });
+      } catch (error) {
+        const word = error instanceof ZasError ? error.serverCode ?? error.code : "";
+        if (word === "claimed") throw new ZasError("offer_taken", 409);
+        if (word === "expired" || word === "own_offer" || word === "not_found") continue;
+        throw error;
+      }
+      id = offerId2;
+      meta = candidate;
+      break;
+    }
+    if (id !== void 0) break;
+    if (now() >= waitUntil) throw new ZasError("no_offer", 0);
+    await sleep2(deps.offerPollMs ?? OFFER_POLL_MS2);
+  }
+  const offered = meta;
+  ctx.transferTelemetry?.describe(offered.size);
+  const offerId = id;
+  const route = `/direct/${cid}/${offerId}`;
+  const offerPath = `${channelPath}/direct/${offerId}`;
+  const setState = (state) => ctx.client.api("POST", `${route}/state`, { state, ...stamp }).then(() => void 0, () => void 0);
+  await (deps.installWebRtc ?? installWebRtc)();
+  const fetchIce = async () => {
+    try {
+      const r = await ctx.client.api("POST", `${route}/ice`, stamp);
+      return Array.isArray(r.ice) ? r.ice : [];
+    } catch {
+      return [];
+    }
+  };
+  const turn = await fetchIce();
+  report2("connecting");
+  const sink = new DiskSink(input.dest, offerId);
+  let resolveOutcome;
+  const outcome = new Promise((resolve2) => {
+    resolveOutcome = resolve2;
+  });
+  let diag;
+  let via;
+  const handle = (deps.engine ?? startReceiver)({
+    ice: [...DIRECT_ICE, ...turn],
+    refreshIce: async () => [...DIRECT_ICE, ...await fetchIce()],
+    // The name and size this end read off the offer. The engine refuses a
+    // sender that announces anything else.
+    expectedMeta: offered,
+    send: (msg) => ctx.client.api("POST", `${route}/signal`, { payload_enc: seal(msg), for: "sender", ...stamp }).then(() => void 0),
+    onPhase: (phase2) => {
+      if (phase2 === "flight") report2("flight");
+      if (phase2 === "done" || phase2 === "failed") resolveOutcome(phase2);
+    },
+    onPath: (p) => {
+      via = p;
+    },
+    onDiag: (d) => {
+      diag = d;
+      deps.onDiag?.(d);
+    },
+    sink: async (m) => {
+      sink.open(m);
+      return sink;
+    }
   });
-  return { major, minor, patch };
+  let over = false;
+  const pump = (async () => {
+    const seen = /* @__PURE__ */ new Set();
+    while (!over) {
+      let rows = [];
+      try {
+        rows = await ctx.client.firestoreRunQuery(offerPath, SIGNALS_FOR_RECEIVER);
+      } catch {
+      }
+      for (const row of rows) {
+        if (!row?.name || seen.has(row.name)) continue;
+        seen.add(row.name);
+        const enc = stringField2(row, "payload_enc");
+        if (!enc) continue;
+        try {
+          handle.accept(open(enc));
+        } catch {
+        }
+      }
+      if (!over) await Promise.race([outcome, sleep2(deps.signalPollMs ?? SIGNAL_POLL_MS2)]);
+    }
+  })();
+  const phase = await outcome;
+  over = true;
+  await pump;
+  report2("finishing");
+  if (phase === "done") {
+    await setState("done");
+    return {
+      offer_id: offerId,
+      channel_id: cid,
+      channel_name: channelName,
+      name: offered.name,
+      bytes: sink.written,
+      path: sink.target,
+      ...via ? { via } : {},
+      duration_ms: now() - startedAt
+    };
+  }
+  sink.abort();
+  const doc = await ctx.client.firestoreGet(offerPath).catch(() => null);
+  const withdrawn = doc === null || stringField2(doc, "state") === "cancelled";
+  await setState("failed");
+  if (sink.failure) throw new ZasError("write_failed", 0, sink.failure.message);
+  if (withdrawn) throw new ZasError("direct_cancelled", 0);
+  const reason = diag?.reason || "unknown";
+  deps.onFailed?.({
+    channel_id: cid,
+    channel_name: channelName,
+    offer_id: offerId,
+    owner_uid: owner,
+    channel_account: account,
+    device,
+    ...input.dest !== void 0 ? { dest: input.dest } : {},
+    meta: offered,
+    key,
+    key_version: grant.key_version,
+    reason
+  });
+  throw new ZasError("direct_failed", 0, reason);
 }
-function toolCallProperties(input) {
-  const tool = input.tool.startsWith("zas_") ? input.tool.slice(4) : input.tool;
-  if (!TOOL_NAMES.has(tool)) return null;
-  const version = versionParts(input.version);
+async function receiveDirectFallbackMeasured(ctx, record, report2, deps = {}) {
+  const now = deps.now ?? (() => Date.now());
+  const startedAt = now();
+  const { open } = sealer(record.key, record.key_version);
+  const stamp = { device: record.device, owner_uid: record.owner_uid };
+  const base = `/direct/${record.channel_id}/${record.offer_id}/fallback`;
+  const offerPath = `accounts/${record.channel_account}/channels/${record.channel_id}/direct/${record.offer_id}`;
+  const doc = await ctx.client.firestoreGet(offerPath);
+  const enc = stringField2(doc, "fallback_meta_enc");
+  let meta;
+  if (enc !== void 0) {
+    try {
+      meta = fallbackMetaOf(open(enc));
+    } catch {
+      meta = void 0;
+    }
+  }
+  if (!meta) throw new ZasError("fallback_unavailable", 409);
+  if (meta.name !== record.meta.name || meta.size !== record.meta.size || meta.mime !== record.meta.mime) {
+    throw new ZasError("file_changed", 0);
+  }
+  const sink = new DiskSink(record.dest, record.offer_id);
+  report2("downloading");
+  try {
+    sink.open(meta);
+    await downloadFallback({
+      offerId: record.offer_id,
+      meta,
+      sink,
+      getUrl: async () => (await ctx.client.api("POST", `${base}/download`, stamp)).url,
+      ...deps.fetcher ? { fetcher: deps.fetcher } : {}
+    });
+  } catch (error) {
+    sink.abort();
+    if (sink.failure) throw new ZasError("write_failed", 0, sink.failure.message);
+    if (error instanceof ZasError) throw error;
+    throw new ZasError("network", 0, error instanceof Error ? error.message : String(error));
+  }
+  report2("finishing");
+  await ctx.client.api("POST", `${base}/received`, stamp);
   return {
-    tool,
-    result: input.code === null ? "ok" : "error",
-    // `other` is the server's word for a code outside the vocabulary. The
-    // shared list is the one that decides, and it drops anything else.
-    code: input.code ?? "none",
-    duration_bucket: agentDurationBucket(input.ms),
-    version_major: version.major,
-    version_minor: version.minor,
-    version_patch: version.patch
+    offer_id: record.offer_id,
+    channel_id: record.channel_id,
+    channel_name: record.channel_name,
+    name: meta.name,
+    bytes: sink.written,
+    path: sink.target,
+    duration_ms: now() - startedAt
   };
 }
-var REPORT_TIMEOUT_MS = 5e3;
-async function report(client, properties) {
-  if (properties === null || !telemetryState().on) return;
-  const timeout = new Promise((resolve2) => {
-    const timer = setTimeout(resolve2, REPORT_TIMEOUT_MS);
-    timer.unref?.();
-  });
-  const sent = client.api("POST", "/agents/telemetry", { event: "agent.tool_call", properties }).then(() => void 0).catch(() => void 0);
-  await Promise.race([sent, timeout]);
+async function receiveDirect(...args) {
+  const telemetry = new TransferTelemetry(args[0].client, "download", "file", "direct");
+  try {
+    const report2 = args[2];
+    const result = await receiveDirectMeasured({ ...args[0], transferTelemetry: telemetry }, args[1], (phase) => {
+      telemetry.mark(phase);
+      report2?.(phase);
+    }, args[3]);
+    telemetry.describe(result.bytes);
+    telemetry.finish("success", "none", false);
+    return result;
+  } catch (error) {
+    telemetry.failed(error);
+    throw error;
+  }
+}
+async function receiveDirectFallback(...args) {
+  const telemetry = new TransferTelemetry(args[0].client, "download", "file", "fallback");
+  try {
+    const report2 = args[2];
+    const result = await receiveDirectFallbackMeasured({ ...args[0], transferTelemetry: telemetry }, args[1], (phase) => {
+      telemetry.mark(phase);
+      report2?.(phase);
+    }, args[3]);
+    telemetry.describe(result.bytes);
+    telemetry.finish("success", "none", false);
+    return result;
+  } catch (error) {
+    telemetry.failed(error);
+    throw error;
+  }
 }
 
+// src/jobs.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+var DEFAULT_WAIT_MS = 6e4;
+var HISTORY = 50;
+var JobRunner = class {
+  now;
+  waitMs;
+  /** Newest first, and trimmed. */
+  jobs = [];
+  /** Keyed on the job object, not its id, so a caller holding a job that has
+   *  already aged out of the list can still wait for it to finish. */
+  settled = /* @__PURE__ */ new WeakMap();
+  constructor(opts = {}) {
+    this.now = opts.now ?? (() => Date.now());
+    this.waitMs = opts.waitMs ?? DEFAULT_WAIT_MS;
+  }
+  start(kind, title, channel, work) {
+    const job = {
+      id: randomUUID2(),
+      kind,
+      title,
+      channel,
+      started_at: this.now(),
+      phase: null,
+      status: "running"
+    };
+    this.jobs.unshift(job);
+    this.jobs.length = Math.min(this.jobs.length, HISTORY);
+    const report2 = (phase) => {
+      if (job.status === "running") job.phase = phase;
+    };
+    const note = (diag) => {
+      job.diag = diag;
+    };
+    this.settled.set(job, work(report2, note).then(
+      (result) => {
+        job.status = "done";
+        job.result = result;
+        return job;
+      },
+      (error) => {
+        job.status = "failed";
+        job.error = error instanceof ZasError ? {
+          code: error.code,
+          status: error.status,
+          sentence: humanSentence(error),
+          message: error.message,
+          ...error.retryAfterMs !== void 0 ? { retryAfterMs: error.retryAfterMs } : {},
+          ...error.serverCode !== void 0 ? { serverCode: error.serverCode } : {}
+        } : { code: "upload_failed", status: 0, sentence: humanSentence(new ZasError("upload_failed", 0)) };
+        return job;
+      }
+    ));
+    return job;
+  }
+  /** Resolves when the work settles, or when the wait runs out — the same job
+   *  object either way, so the caller reads `status` rather than guessing. */
+  async wait(job) {
+    const settled = this.settled.get(job);
+    if (!settled) return job;
+    let timer;
+    const deadline = new Promise((resolve2) => {
+      timer = setTimeout(() => resolve2(job), this.waitMs);
+    });
+    try {
+      return await Promise.race([settled, deadline]);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  list() {
+    return this.jobs.slice(0, HISTORY);
+  }
+  get(id) {
+    return this.jobs.find((job) => job.id === id);
+  }
+};
+
 // src/server.ts
 function agentVersion() {
-  return true ? "0.8.0" : "0.0.0-dev";
+  return true ? "0.10.0" : "0.0.0-dev";
 }
 var AGENT_CUE = " The owner sees every item this agent sends with the >_ agent mark and this agent's name, on every device.";
 var PAIR_ANNOUNCE_MS = 15e3;
@@ -4135,10 +4704,12 @@ function buildServer(profile, deps = {}) {
     const started = Date.now();
     try {
       const answer = await handler(...args);
-      void reportCall(name, Date.now() - started, answeredCode(answer));
+      const elapsed = Date.now() - started;
+      setImmediate(() => void reportCall(name, elapsed, answeredCode(answer))).unref();
       return answer;
     } catch (e) {
-      void reportCall(name, Date.now() - started, e instanceof ZasError ? e.code : "internal");
+      const elapsed = Date.now() - started;
+      setImmediate(() => void reportCall(name, elapsed, e instanceof ZasError ? e.code : "internal")).unref();
       throw e;
     }
   });
@@ -4456,6 +5027,45 @@ ${formatDirectDiagLines(job.diag).join("\n")}`) };
       return failed(e);
     }
   });
+  server.registerTool("zas_edit_item", {
+    description: "Change an item this agent sent, keeping its id: the title of a file or a note, or a note's text, language and secret cover. Refuses items sent by anyone else. A file's bytes change with zas_replace_file. Needs a grant that includes reading and sending. Pass only the fields to change; an empty title clears it." + AGENT_CUE,
+    inputSchema: {
+      id: z.string().describe("Item id, as `zas_list_items` reports it."),
+      channel: z.string().optional().describe("Channel name or id. Optional when the agent holds exactly one channel."),
+      title: z.string().optional().describe("New label. An empty string clears it, so the file name or the first line shows again."),
+      text: z.string().optional().describe("New body, for a note."),
+      lang: z.string().optional().describe('Language of the snippet, for highlighting (for example "ts", "py"). An empty string makes it plain text.'),
+      secret: z.boolean().optional().describe("Hide the body behind a cover until the reader opens it. False removes the cover.")
+    }
+  }, async (input) => {
+    try {
+      return text2(await editItem(ctx(), input));
+    } catch (e) {
+      return failed(e);
+    }
+  });
+  server.registerTool("zas_replace_file", {
+    description: "Replace the bytes of a file this agent sent with a file from this machine, keeping the item id, its place in the channel and its pin. Refuses items sent by anyone else, notes, and an item with a public share. Returns the item id, or a job id when the upload takes longer than a minute. Sends any file this process can read; confirm with the owner before sending secrets, keys or credentials." + AGENT_CUE,
+    inputSchema: {
+      id: z.string().describe("Item id, as `zas_list_items` reports it."),
+      path: z.string().describe("Absolute or relative path of the new file."),
+      channel: z.string().optional().describe("Channel name or id. Optional when the agent holds exactly one channel."),
+      title: z.string().optional().describe("New label. Defaults to the label the item has.")
+    }
+  }, async (input) => {
+    try {
+      const c = ctx();
+      const job = runner.start(
+        "replace",
+        input.title ?? input.path,
+        input.channel ?? "",
+        (report2) => replaceFile(c, input, report2)
+      );
+      return settled(await runner.wait(job));
+    } catch (e) {
+      return failed(e);
+    }
+  });
   server.registerTool("zas_jobs", {
     description: "List the sends and Directo transfers this server started, newest first, with the phase each one reached and how it ended \u2014 including any `job_id` a send returned; a finished job keeps its result here." + AGENT_CUE
   }, async () => text2(runner.list()));
@@ -4509,6 +5119,15 @@ var USAGE = [
   "  zas-agent telemetry [on|off]                say what this machine reports, or change it",
   "  zas-agent --version"
 ].join("\n");
+function noticeOnServe(log) {
+  try {
+    if (noticeShown()) return;
+    log(TELEMETRY_NOTICE);
+    markNoticeShown();
+  } catch (e) {
+    log(`Could not record that the notice was shown (${String(e?.message ?? e)}). Serving anyway.`);
+  }
+}
 async function main(argv, log = (l) => console.error(l)) {
   const args = parseArgs(argv);
   if (args.command === "version") {
@@ -4563,10 +5182,7 @@ async function main(argv, log = (l) => console.error(l)) {
     }
     return 0;
   }
-  if (!noticeShown()) {
-    log(TELEMETRY_NOTICE);
-    markNoticeShown();
-  }
+  noticeOnServe(log);
   await buildServer(args.profile).connect(new StdioServerTransport());
   return 0;
 }
@@ -4603,5 +5219,6 @@ if (isInvokedDirectly(process.argv[1], import.meta.url)) {
 export {
   isInvokedDirectly,
   main,
+  noticeOnServe,
   parseArgs
 };