airgate 0.1.6 → 0.1.8

package/dist/airgate.mjs

@@ -95,6 +95,26 @@ var PLANS = {
     concurrentPods: 5,
     blurb: "for agents that work every day.",
     features: ["160 active hours included every month", "5 pods at once, 50 GB of storage", "lower rate after that", "priority support"]
+  },
+  team: {
+    id: "team",
+    name: "team",
+    monthlyUsd: 30,
+    includedHours: 160,
+    hourlyUsd: 0.12,
+    storageGb: 50,
+    storageUsdPerGb: 0.2,
+    concurrentPods: 5,
+    perSeat: true,
+    blurb: "for teams that share pods, environments and what their agents learned.",
+    features: [
+      "everything in pro, per seat",
+      "160 hours per seat, pooled across the team",
+      "shared pods, snapshots, secrets and sign-ins",
+      "a team library: never pay twice for the same work",
+      "crews from GitHub, airlock approvers, audit log",
+      "join by work email"
+    ]
   }
 };
 function estimate(plan2, hours2) {
@@ -273,15 +293,15 @@ function parseDotenv(input) {
       value = rest.replace(/\s+#.*$/, "").trim();
     }
     let name = key;
-    let note;
+    let note2;
     if (!SECRET_NAME_RE.test(key)) {
       name = suggestSecretName(key);
-      note = name ? `saved as ${name}` : "not a usable name";
+      note2 = name ? `saved as ${name}` : "not a usable name";
     } else if (reservedSecretName(key)) {
       name = null;
-      note = "reserved (the pod sets it)";
+      note2 = "reserved (the pod sets it)";
     }
-    entries.push({ key, name, value, line: lineNo, ...note ? { note } : {} });
+    entries.push({ key, name, value, line: lineNo, ...note2 ? { note: note2 } : {} });
   }
   const values = {};
   for (const e of entries) if (e.name) values[e.name] = e.value;
@@ -489,6 +509,10 @@ var Api = class {
   pods() {
     return this.request("GET", "/v1/pods").then((r) => r.pods);
   }
+  /** your pods, and the ones teammates shared with your workspace */
+  podsWithTeam() {
+    return this.request("GET", "/v1/pods").then((r) => ({ pods: r.pods, team: r.team ?? [] }));
+  }
   pod(id) {
     return this.request("GET", `/v1/pods/${enc(id)}`).then((r) => r.pod);
   }
@@ -672,6 +696,110 @@ var Api = class {
   portal(returnUrl) {
     return this.request("POST", "/v1/billing/portal", { body: { returnUrl } });
   }
+  /* --- teams ------------------------------------------------------------------------- */
+  team() {
+    return this.request("GET", "/v1/workspace");
+  }
+  createTeam(name) {
+    return this.request("POST", "/v1/workspace", { body: { name } });
+  }
+  updateTeam(patch) {
+    return this.request("PATCH", "/v1/workspace", { body: patch });
+  }
+  deleteTeam() {
+    return this.request("DELETE", "/v1/workspace");
+  }
+  claimDomain(domain, autoJoin) {
+    return this.request("PUT", "/v1/workspace/domain", { body: { domain, ...autoJoin === void 0 ? {} : { autoJoin } } });
+  }
+  setMember(id, patch) {
+    return this.request("PATCH", `/v1/workspace/members/${enc(id)}`, { body: patch });
+  }
+  removeMember(id) {
+    return this.request("DELETE", `/v1/workspace/members/${enc(id)}`);
+  }
+  leaveTeam() {
+    return this.request("POST", "/v1/workspace/leave", { body: {} });
+  }
+  teamInvites() {
+    return this.request("GET", "/v1/workspace/invites").then((r) => r.invites);
+  }
+  invite(email, role) {
+    return this.request("POST", "/v1/workspace/invites", { body: { ...email ? { email } : {}, role } });
+  }
+  revokeInvite(code3) {
+    return this.request("DELETE", `/v1/workspace/invites/${enc(code3)}`);
+  }
+  peekInvite(code3) {
+    return this.request("GET", `/v1/workspace/join/${enc(code3)}`);
+  }
+  joinTeam(code3) {
+    return this.request("POST", "/v1/workspace/join", { body: { code: code3 } });
+  }
+  requestJoin() {
+    return this.request("POST", "/v1/workspace/requests", { body: {} });
+  }
+  decideRequest(id, accept) {
+    return this.request("POST", `/v1/workspace/requests/${enc(id)}/${accept ? "accept" : "decline"}`, { body: {} });
+  }
+  audit(before) {
+    return this.request("GET", `/v1/workspace/audit${before ? `?before=${before}` : ""}`).then((r) => r.entries);
+  }
+  auditCsv() {
+    return this.request("GET", "/v1/workspace/audit?format=csv", { text: true });
+  }
+  teamBilling() {
+    return this.request("GET", "/v1/workspace/billing");
+  }
+  teamCheckout(seats, returnUrl) {
+    return this.request("POST", "/v1/workspace/billing/checkout", { body: { seats, returnUrl } });
+  }
+  setSeats(seats) {
+    return this.request("POST", "/v1/workspace/billing/seats", { body: { seats } });
+  }
+  teamSecrets() {
+    return this.request("GET", "/v1/workspace/secrets").then((r) => r.secrets);
+  }
+  setTeamSecrets(values) {
+    return this.request("PUT", "/v1/workspace/secrets", { body: { values } });
+  }
+  deleteTeamSecret(name) {
+    return this.request("DELETE", `/v1/workspace/secrets/${enc(name)}`);
+  }
+  sharePod(id, shared) {
+    return this.request("PUT", `/v1/pods/${enc(id)}/share`, { body: { shared } }).then((r) => r.pod);
+  }
+  handover(id, to) {
+    return this.request("POST", `/v1/pods/${enc(id)}/handover`, { body: { to } });
+  }
+  library(q = "") {
+    return this.request("GET", `/v1/library${q.trim() ? `?q=${encodeURIComponent(q.trim())}` : ""}`).then((r) => r.entries);
+  }
+  /** the same work already done in your workspace (empty outside one) */
+  similar(task2) {
+    return this.request("POST", "/v1/library/similar", { body: { task: task2 } }).then((r) => r.similar);
+  }
+  libraryPatch(id) {
+    return this.request("GET", `/v1/library/${enc(id)}/patch`);
+  }
+  note(text2) {
+    return this.request("POST", "/v1/library/notes", { body: { text: text2 } });
+  }
+  triggers() {
+    return this.request("GET", "/v1/github/triggers").then((r) => r.triggers);
+  }
+  addTrigger(body) {
+    return this.request("POST", "/v1/github/triggers", { body }).then((r) => r.trigger);
+  }
+  removeTrigger(id) {
+    return this.request("DELETE", `/v1/github/triggers/${enc(id)}`);
+  }
+  sendVerification() {
+    return this.request("POST", "/v1/auth/verify/send", { body: {} });
+  }
+  reportBug(text2, expected, context) {
+    return this.request("POST", "/v1/bugs", { body: { text: text2, ...expected ? { expected } : {}, ...context ? { context } : {} } });
+  }
   terminalUrl(id, cols, rows2) {
     const q = new URLSearchParams({ token: this.tokenForUrl(), cols: String(cols), rows: String(rows2), client: this.client });
     return `${this.gateway.replace(/^http/, "ws")}/v1/pods/${enc(id)}/terminal?${q}`;
@@ -1956,9 +2084,9 @@ function stack(fn, all, given = {}) {
   });
 }
 function over(top, bottom, o = {}) {
-  const { name, note, ...opts2 } = object(o, "over()", [...LAYER.filter((k) => k !== "src"), "name", "note"]);
+  const { name, note: note2, ...opts2 } = object(o, "over()", [...LAYER.filter((k) => k !== "src"), "name", "note"]);
   const upper = isClip(top) ? { ...opts2, ...top } : { ...opts2, src: top };
-  return stack("over", [layerOf("over", bottom, "top-left"), layerOf("over", upper, "center")], naming("over", { name, note }));
+  return stack("over", [layerOf("over", bottom, "top-left"), layerOf("over", upper, "center")], naming("over", { name, note: note2 }));
 }
 var BOXES = { single: "\u250C\u2510\u2514\u2518\u2500\u2502", double: "\u2554\u2557\u255A\u255D\u2550\u2551", rounded: "\u256D\u256E\u2570\u256F\u2500\u2502", heavy: "\u250F\u2513\u2517\u251B\u2501\u2503", ascii: "++++-|" };
 function borderOf(name, v) {
@@ -2382,11 +2510,11 @@ function build2(fx, src, o, make, keep = true) {
   const own = periodOf(p, options ?? {});
   const loop = !e.moves ? own : e.period ? lcm(own ?? e.period, e.period) : void 0;
   const name = o.name === void 0 ? m.name : typeof o.name === "string" ? o.name : fail2(`${fx}.name takes a string, not ${show(o.name)}`);
-  const note = o.note ?? `${name}, ${e.what}`.slice(0, 72);
+  const note2 = o.note ?? `${name}, ${e.what}`.slice(0, 72);
   const still = e.still ?? m.still;
   const out = piece({
     name,
-    note,
+    note: note2,
     category: m.category,
     cols,
     rows: rows2,
@@ -3689,11 +3817,11 @@ function checkMeta(m) {
   return m;
 }
 var Chainable = class {
-  named(name, note) {
-    return named(this, name, note === void 0 ? {} : { note });
+  named(name, note2) {
+    return named(this, name, note2 === void 0 ? {} : { note: note2 });
   }
-  note(note) {
-    return named(this, this.meta.name, { note });
+  note(note2) {
+    return named(this, this.meta.name, { note: note2 });
   }
   over(bottom, o) {
     return over(this, bottom, o);
@@ -5050,7 +5178,7 @@ function tones(accent, more = []) {
   return { light: list2.map((c) => c.light), dark: list2.map((c) => c.dark) };
 }
 var WIDGET = ["color", ...NAMING];
-var naming2 = (o, name, note) => ({ name: o.name ?? name, note: (o.note ?? note).slice(0, 72) });
+var naming2 = (o, name, note2) => ({ name: o.name ?? name, note: (o.note ?? note2).slice(0, 72) });
 var framing = (p, framed) => framed ? Object.assign(p, { frames: true }) : p;
 function amountOf(what, v, min, max, share2) {
   if (v === void 0)
@@ -5094,8 +5222,8 @@ function progressBar(o) {
   const cols = label2.length + width + (percent ? 5 : 0);
   const share2 = (v) => (v - min) / (max - min);
   const timing = live ? { fps: 4, clock: true } : value === void 0 ? { fps: 24, loop, still: fill } : { fps: 0 };
-  const note = live ? "a progress bar, live" : value === void 0 ? "a progress bar filling" : `a progress bar at ${Math.round(share2(value) * 100)}%`;
-  return piece({ ...naming2(p, label2.trim() || "progress", note), category: "ui", cols, rows: 1, ...timing, palette: tones(themed2("progressBar's color", p.color)) }, (t, s2) => {
+  const note2 = live ? "a progress bar, live" : value === void 0 ? "a progress bar filling" : `a progress bar at ${Math.round(share2(value) * 100)}%`;
+  return piece({ ...naming2(p, label2.trim() || "progress", note2), category: "ui", cols, rows: 1, ...timing, palette: tones(themed2("progressBar's color", p.color)) }, (t, s2) => {
     const k = typeof value === "function" ? share2(value()) : value !== void 0 ? share2(value) : smooth(Math.min(1, (t % loop + loop) % loop / fill));
     const color = k >= 1 ? GOOD : ACCENT;
     s2.write(0, 0, label2);
@@ -5134,8 +5262,8 @@ function gauge(o) {
   const loop = 12;
   const wander = (t) => 0.15 + 0.8 * loopNoise(0.3, 0.7, t, loop, { radius: 0.9 });
   const timing = typeof value === "function" ? { fps: 4, clock: true } : value === void 0 ? { fps: 24, loop } : { fps: 0 };
-  const note = typeof value === "function" ? "a gauge, live" : value === void 0 ? "a gauge, its reading rising and falling" : `a gauge reading ${+value.toFixed(2)}${unit2}`;
-  const made = piece({ ...naming2(p, title || "gauge", note), category: "data", cols: 25, rows: 12, ...timing, palette: tones(own) }, (t, s2) => {
+  const note2 = typeof value === "function" ? "a gauge, live" : value === void 0 ? "a gauge, its reading rising and falling" : `a gauge reading ${+value.toFixed(2)}${unit2}`;
+  const made = piece({ ...naming2(p, title || "gauge", note2), category: "data", cols: 25, rows: 12, ...timing, palette: tones(own) }, (t, s2) => {
     const k = typeof value === "function" ? (value() - min) / (max - min) : value === void 0 ? wander(t) : (value - min) / (max - min);
     const color = own ? ACCENT : k > 0.85 ? BAD2 : k > 0.6 ? WARN : GOOD;
     if (framed)
@@ -5174,8 +5302,8 @@ function sparkline(data, o) {
   const last = list2 ? String(+list2[list2.length - 1].toFixed(2)) : live ? "100000" : "100";
   const cols = words2.length + width + 1 + last.length;
   const timing = live ? { fps: 4, clock: true } : { fps: 24, loop, ...list2 ? { still: 1.5 } : {} };
-  const note = live ? "a sparkline of live data" : list2 ? "a sparkline drawing itself in" : "a sparkline of a wandering reading";
-  return piece({ ...naming2(p, label2 || "sparkline", note), category: "data", cols, rows: height, ...timing, palette: tones(themed2("sparkline's color", p.color)) }, (t, s2) => {
+  const note2 = live ? "a sparkline of live data" : list2 ? "a sparkline drawing itself in" : "a sparkline of a wandering reading";
+  return piece({ ...naming2(p, label2 || "sparkline", note2), category: "data", cols, rows: height, ...timing, palette: tones(themed2("sparkline's color", p.color)) }, (t, s2) => {
     const u = (t % loop + loop) % loop;
     textAt(s2, words2, "left");
     const area2 = { x: words2.length, y: 0, cols: width, rows: height };
@@ -5717,10 +5845,19 @@ function matchOne(items, ref, keys, what, label2) {
   if (pre.length > 1) throw new CliError(`"${ref}" matches ${pre.length} ${what}s`, `be more specific: ${pre.map(label2).join(", ")}`);
   throw new CliError(`no ${what} "${ref}"`, what === "pod" ? "list them with: airgate pods" : void 0);
 }
-async function resolvePod(ctx, ref) {
+async function resolvePod(ctx, ref, opts2 = {}) {
   if (!ref) throw new UsageError("which pod? give its name or id");
-  const pods2 = await ctx.api.pods();
-  return matchOne(pods2, ref, (p) => [p.id, p.spec.name], "pod", (p) => `${p.spec.name} (${p.id})`);
+  if (!opts2.team) {
+    const pods3 = await ctx.api.pods();
+    return matchOne(pods3, ref, (p) => [p.id, p.spec.name], "pod", (p) => `${p.spec.name} (${p.id})`);
+  }
+  const { pods: pods2, team: team2 } = await ctx.api.podsWithTeam();
+  try {
+    return matchOne(pods2, ref, (p) => [p.id, p.spec.name], "pod", (p) => `${p.spec.name} (${p.id})`);
+  } catch (e) {
+    if (!team2.length || !(e instanceof CliError) || !e.message.startsWith("no pod")) throw e;
+    return matchOne(team2, ref, (p) => [p.id, p.spec.name], "pod", (p) => `${p.spec.name} (${p.id}, ${p.owner?.email ?? "a teammate"}'s)`);
+  }
 }
 function resolveCheckpoint(cps, ref) {
   if (/^#\d+$/.test(ref)) {
@@ -6755,8 +6892,8 @@ function approvalRows(ctx, items, names) {
   return items.map((a) => [
     ctx.ui.c(a.state === "pending" ? "warn" : a.state === "denied" || a.state === "failed" ? "bad" : "ok", a.state),
     a.kind,
-    names.get(a.podId) ?? a.podId,
-    a.summary,
+    names.get(a.podId) ?? (a.requestedBy ? `${a.requestedBy}'s pod` : a.podId),
+    a.summary + (a.requestedBy ? ctx.ui.c("dim", ` \xB7 from ${a.requestedBy}`) : "") + (a.needsApprover && a.state === "pending" && !a.requestedBy ? ctx.ui.c("warn", " \xB7 waits for an approver") : ""),
     ago(a.createdAt),
     ctx.ui.c("dim", a.id)
   ]);
@@ -7003,7 +7140,7 @@ var attach = {
     if (!io.stdin.isTTY || !io.stdout.isTTY) {
       throw new CliError("attach needs an interactive terminal", "for scripts use: airgate exec <pod> -- <command\u2026>", 2);
     }
-    const p = await resolvePod(ctx, ctx.args.positionals[0]);
+    const p = await resolvePod(ctx, ctx.args.positionals[0], { team: true });
     const url = ctx.api.terminalUrl(p.id, io.stdout.columns ?? 80, io.stdout.rows ?? 24);
     ui2.err(ui2.ce("dim", `attached to ${p.spec.name}. ctrl-] to detach.`));
     let ws;
@@ -7242,6 +7379,461 @@ var secrets = {
   }
 };
 
+// src/commands/team.ts
+import { spawnSync } from "node:child_process";
+import { rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { resolve as resolve4 } from "node:path";
+
+// src/version.ts
+var VERSION = "0.1.8";
+
+// src/commands/team.ts
+async function checkSimilar(ctx, task2) {
+  const similar = await ctx.api.similar(task2).catch(() => []);
+  if (!similar.length || ctx.json) return { go: true, similar };
+  const { ui: ui2 } = ctx;
+  for (const e of similar) {
+    ui2.err(`${ui2.ce("warn", "a teammate already did this")}: ${e.title} ${ui2.ce("dim", `by ${e.author}, ${ago(e.at)}${e.cost?.tokens ? ` \xB7 ${e.cost.tokens} tokens` : ""}`)}`);
+    ui2.err(ui2.ce("dim", `  reuse it: airgate recall --patch ${e.id}${e.summary ? ` \xB7 ${e.summary.split("\n")[0].slice(0, 100)}` : ""}`));
+  }
+  if (ctx.args.flags.yes === true || !ctx.io.stdin.isTTY) return { go: true, similar };
+  const a = await ctx.io.prompt("start anyway? [y/N] ").catch(() => "y");
+  return { go: /^y(es)?$/i.test(a.trim()), similar };
+}
+function notStarted(similar) {
+  throw new CliError("not started", similar[0] ? `reuse it: airgate recall --patch ${similar[0].id} --apply` : void 0);
+}
+async function mine(ctx) {
+  const v = await ctx.api.team();
+  if (!v.workspace) throw new CliError("you're not in a team workspace", 'start one: airgate team create "<name>" \xB7 or join: airgate team join <code>');
+  return v;
+}
+function member(v, ref) {
+  if (!ref) throw new UsageError("which member? their email");
+  return matchOne(v.members ?? [], ref.toLowerCase(), (m) => [m.id, m.email], "member", (m) => m.email);
+}
+var onOff = (v, what) => {
+  if (v === "on" || v === "yes" || v === "true") return true;
+  if (v === "off" || v === "no" || v === "false") return false;
+  throw new UsageError(`${what}: on or off`);
+};
+var csvList = (v) => v === "any" || v === "all" ? null : v.split(",").map((x) => x.trim()).filter(Boolean);
+var numOrNone = (v, what) => {
+  if (v === "none" || v === "off") return null;
+  const n2 = Number(v);
+  if (!Number.isFinite(n2) || n2 < 0) throw new UsageError(`${what}: a number, or none`);
+  return n2;
+};
+function printTeam(ctx, v) {
+  const { ui: ui2 } = ctx;
+  const ws = v.workspace;
+  ui2.out(`${ui2.c("ok", ws.name)} ${ui2.c("dim", `\xB7 you're ${v.me?.role ?? "member"}${v.me?.approver ? " and an approver" : ""}${ws.domain ? ` \xB7 ${ws.domain}${ws.autoJoin ? " (joins by work email)" : ""}` : ""}`)}`);
+  ui2.table(
+    (v.members ?? []).map((m) => [m.email, m.role === "member" ? ui2.c("dim", "member") : m.role, m.approver && m.role === "member" ? "approver" : "", ui2.c("dim", `joined ${ago(m.joinedAt)}`)]),
+    { indent: 2 }
+  );
+  if (v.requests?.length) {
+    ui2.out();
+    ui2.out(`${v.requests.length} asking to join:`);
+    ui2.table(v.requests.map((r) => [r.email, ui2.c("dim", ago(r.createdAt)), ui2.c("dim", `airgate team accept ${r.email}`)]), { indent: 2 });
+  }
+}
+var team = {
+  name: "team",
+  aliases: ["workspace"],
+  group: "account",
+  usage: "[create|invite|invites|join|leave|members|role|approver|remove|accept|decline|domain|rules|audit|billing|upgrade|seats|secrets|secret|triggers|trigger|delete] \u2026",
+  summary: "your team workspace: members, invites, rules, audit log, billing, team secrets, GitHub triggers",
+  example: "airgate team invite sam@acme.dev",
+  notes: [
+    "airgate team                         the workspace, your role, its members",
+    'airgate team create "<name>"         start one (you own it)',
+    "airgate team invite [email] [--admin]  an invite (emailed when you give an address); no email: a link anyone can use",
+    "airgate team invites \xB7 revoke <code> open invites",
+    "airgate team join <code|link>        join with an invite (your pods and snapshots come with you)",
+    "airgate team request                 ask to join the workspace at your email's domain",
+    "airgate team accept|decline <email>  answer someone asking to join",
+    "airgate team leave                   leave (your pods stay yours; shared ones stop being shared)",
+    "airgate team role <email> admin|member|owner \xB7 approver <email> on|off \xB7 remove <email>",
+    "airgate team domain <domain> [--no-auto-join] | --release   people with a confirmed email there join on their own",
+    "airgate team rules [--approvers on|off] [--kinds git-push,deploy] [--agents a,b|any] [--networks allowlist,off|any] [--max-pods n|none] [--cap usd|none] [--auto-seats on|off] [--hints on|off]",
+    "airgate team audit [--csv]           who did what (admins)",
+    "airgate team billing \xB7 upgrade [--seats n] \xB7 seats <n>   the team plan: seats and its pooled hours",
+    "airgate team secrets \xB7 secret set NAME (value from a hidden prompt or stdin) \xB7 secret rm NAME   reach every member's pods",
+    "airgate team triggers \xB7 trigger add <owner/repo> pr|issue [--label l] [--recipe r] \xB7 trigger rm <id>   crews started by GitHub"
+  ],
+  flags: {
+    admin: { type: "boolean", help: "invite: as an admin" },
+    "auto-join": { type: "boolean", default: true, help: "domain: people at it join on their own (--no-auto-join: they ask)" },
+    release: { type: "boolean", help: "domain: let the domain go" },
+    approvers: { type: "string", value: "on|off", help: "rules: an approver (not the requester) decides airlock requests" },
+    kinds: { type: "string", value: "kinds", help: "rules: which requests need an approver (git-push,pull-request,deploy,email,http)" },
+    agents: { type: "string", value: "list|any", help: "rules: agents members may launch" },
+    networks: { type: "string", value: "list|any", help: "rules: networks members may use (open,allowlist,off)" },
+    "max-pods": { type: "string", value: "n|none", help: "rules: awake pods per member" },
+    cap: { type: "string", value: "usd|none", help: "rules: monthly spend cap per member" },
+    "auto-seats": { type: "string", value: "on|off", help: "rules: buy a seat when someone joins past the count" },
+    hints: { type: "string", value: "on|off", help: "rules: offer the same work from the library before new work starts" },
+    csv: { type: "boolean", help: "audit: as CSV" },
+    seats: { type: "string", value: "n", help: "upgrade: how many seats (at least everyone in it)" },
+    label: { type: "string", value: "label", help: "trigger: the issue label that starts a crew (default airgate)" },
+    recipe: { type: "string", value: "recipe", help: "trigger: race, contest, council, squad or split" },
+    yes: { type: "boolean", short: "y", help: "don't ask" },
+    "no-open": { type: "boolean", help: "print the link instead of opening the browser" }
+  },
+  async run(ctx) {
+    const { ui: ui2 } = ctx;
+    const [action, a1, a2] = ctx.args.positionals;
+    if (!action) {
+      const v = await ctx.api.team();
+      if (ctx.json) return ui2.json(v);
+      if (!v.workspace) {
+        ui2.out(ui2.c("dim", "you're not in a team workspace."));
+        for (const i of v.invites) ui2.out(`invited to ${ui2.c("ok", i.workspace.name)} as ${i.role}: airgate team join ${i.code}`);
+        if (v.suggestion) ui2.out(`${v.suggestion.name} uses your email's domain (${v.suggestion.domain}): ${v.suggestion.requested ? "you asked to join; an admin decides" : "airgate team request"}`);
+        return void ui2.out(ui2.c("dim", 'start one: airgate team create "<name>"'));
+      }
+      return printTeam(ctx, v);
+    }
+    switch (action) {
+      case "create": {
+        if (!a1) throw new UsageError('airgate team create "<name>"');
+        const v = await ctx.api.createTeam(a1);
+        if (ctx.json) return ui2.json(v);
+        ui2.out(`${ui2.c("ok", "created")} ${v.workspace.name}. you own it.`);
+        return void ui2.out(ui2.c("dim", "next: airgate team invite <email> \xB7 airgate team domain <your domain> \xB7 airgate team upgrade"));
+      }
+      case "invite": {
+        const inv = await ctx.api.invite(a1 ?? null, bool(ctx.args, "admin") ? "admin" : "member");
+        if (ctx.json) return ui2.json(inv);
+        ui2.out(inv.url);
+        return void ui2.err(ui2.ce("dim", inv.email ? `emailed to ${inv.email} (as ${inv.role}); works for 14 days` : `anyone with this link can join as ${inv.role} for 14 days. revoke: airgate team revoke ${inv.code}`));
+      }
+      case "invites": {
+        const list2 = await ctx.api.teamInvites();
+        if (ctx.json) return ui2.json(list2);
+        if (!list2.length) return void ui2.out(ui2.c("dim", "no open invites. make one: airgate team invite [email]"));
+        return void ui2.table(list2.map((i) => [i.email ?? ui2.c("dim", "link"), i.role, ui2.c("dim", `expires ${new Date(i.expiresAt).toISOString().slice(0, 10)}`), ui2.c("dim", i.code)]), { head: ["for", "role", "", "code"] });
+      }
+      case "revoke": {
+        if (!a1) throw new UsageError("airgate team revoke <code>");
+        await ctx.api.revokeInvite(a1);
+        return ctx.json ? ui2.json({ ok: true }) : void ui2.out("revoked.");
+      }
+      case "join": {
+        if (!a1) throw new UsageError("airgate team join <code or link>");
+        const code3 = /code=([A-Za-z0-9_-]+)/.exec(a1)?.[1] ?? a1.trim();
+        const peek = await ctx.api.peekInvite(code3);
+        if (!ctx.json && !await confirm(ctx, `join ${peek.workspace.name} (${peek.members} people) as ${peek.role}? your pods and snapshots stay yours, your usage bills to the team`)) throw new CliError("not joined");
+        const v = await ctx.api.joinTeam(code3);
+        if (ctx.json) return ui2.json(v);
+        ui2.out(`${ui2.c("ok", "joined")} ${v.workspace.name}.`);
+        return void ui2.out(ui2.c("dim", "teammates' shared pods: airgate pods \xB7 the team library: airgate recall"));
+      }
+      case "request": {
+        const r = await ctx.api.requestJoin();
+        return ctx.json ? ui2.json(r) : void ui2.out("asked. an admin of the workspace at your domain decides.");
+      }
+      case "accept":
+      case "decline": {
+        const v = await mine(ctx);
+        const req = matchOne(v.requests ?? [], (a1 ?? "").toLowerCase(), (r) => [r.id, r.email], "request", (r) => r.email);
+        const out = await ctx.api.decideRequest(req.id, action === "accept");
+        return ctx.json ? ui2.json(out) : void ui2.out(`${action === "accept" ? "added" : "declined"} ${req.email}.`);
+      }
+      case "leave": {
+        const v = await mine(ctx);
+        if (!await confirm(ctx, `leave ${v.workspace.name}? your pods stay yours; shared ones stop being shared`)) throw new CliError("still in it");
+        await ctx.api.leaveTeam();
+        return ctx.json ? ui2.json({ ok: true }) : void ui2.out(`left ${v.workspace.name}.`);
+      }
+      case "delete": {
+        const v = await mine(ctx);
+        if (!await confirm(ctx, `delete the ${v.workspace.name} workspace? everyone in it becomes a personal account again (their pods stay theirs). cancel the team plan in billing too`)) throw new CliError("nothing deleted");
+        await ctx.api.deleteTeam();
+        return ctx.json ? ui2.json({ ok: true }) : void ui2.out("deleted. cancel the plan: airgate billing");
+      }
+      case "members": {
+        const v = await mine(ctx);
+        return ctx.json ? ui2.json(v.members) : printTeam(ctx, v);
+      }
+      case "role": {
+        const v = await mine(ctx);
+        const m = member(v, a1);
+        if (a2 !== "admin" && a2 !== "member" && a2 !== "owner") throw new UsageError("airgate team role <email> admin|member|owner");
+        if (a2 === "owner" && !await confirm(ctx, `make ${m.email} the owner? you stay an admin`)) throw new CliError("nothing changed");
+        const out = await ctx.api.setMember(m.id, { role: a2 });
+        return ctx.json ? ui2.json(out) : void ui2.out(`${m.email} is ${a2} now.`);
+      }
+      case "approver": {
+        const v = await mine(ctx);
+        const m = member(v, a1);
+        const on = onOff(a2, "approver");
+        const out = await ctx.api.setMember(m.id, { approver: on });
+        return ctx.json ? ui2.json(out) : void ui2.out(`${m.email} ${on ? "decides" : "no longer decides"} teammates' airlock requests.`);
+      }
+      case "remove": {
+        const v = await mine(ctx);
+        const m = member(v, a1);
+        if (!await confirm(ctx, `remove ${m.email} from ${v.workspace.name}? their pods stay theirs`)) throw new CliError("nothing changed");
+        const out = await ctx.api.removeMember(m.id);
+        return ctx.json ? ui2.json(out) : void ui2.out(`removed ${m.email}.`);
+      }
+      case "domain": {
+        if (bool(ctx.args, "release")) {
+          const out2 = await ctx.api.claimDomain(null);
+          return ctx.json ? ui2.json(out2) : void ui2.out("the domain is free again; nobody joins by email.");
+        }
+        if (!a1) throw new UsageError("airgate team domain <domain> [--no-auto-join]");
+        const out = await ctx.api.claimDomain(a1, bool(ctx.args, "auto-join"));
+        if (ctx.json) return ui2.json(out);
+        return void ui2.out(
+          out.workspace?.autoJoin ? `${out.workspace.domain}: people with a confirmed email there join ${out.workspace.name} on their own.` : `${out.workspace?.domain}: people there can ask to join (airgate team request); you decide.`
+        );
+      }
+      case "rules": {
+        const patch = {};
+        const f = (k) => str(ctx.args, k);
+        if (f("approvers") !== void 0) patch.approvals = onOff(f("approvers"), "--approvers") ? "approvers" : "self";
+        if (f("kinds") !== void 0) patch.approvalKinds = csvList(f("kinds")) ?? ["git-push", "pull-request", "deploy", "email", "http"];
+        if (f("agents") !== void 0) patch.agents = csvList(f("agents"));
+        if (f("networks") !== void 0) patch.networks = csvList(f("networks"));
+        if (f("max-pods") !== void 0) patch.maxPodsPerMember = numOrNone(f("max-pods"), "--max-pods");
+        if (f("cap") !== void 0) patch.capUsdPerMember = numOrNone(f("cap"), "--cap");
+        if (f("auto-seats") !== void 0) patch.autoSeats = onOff(f("auto-seats"), "--auto-seats");
+        if (f("hints") !== void 0) patch.libraryHints = onOff(f("hints"), "--hints");
+        const v = Object.keys(patch).length ? await ctx.api.updateTeam({ rules: patch }) : await mine(ctx);
+        const r = v.workspace.rules;
+        if (ctx.json) return ui2.json(r);
+        return void ui2.table(
+          [
+            ["airlock", r.approvals === "approvers" ? `an approver decides ${r.approvalKinds.join(", ")}` : "each member decides their own"],
+            ["agents", r.agents ? r.agents.join(", ") : "any"],
+            ["networks", r.networks ? r.networks.join(", ") : "any"],
+            ["pods awake", r.maxPodsPerMember == null ? "the plan's limit" : `${r.maxPodsPerMember} per member`],
+            ["spend cap", r.capUsdPerMember == null ? "none" : `$${r.capUsdPerMember} per member a month`],
+            ["seats", r.autoSeats ? "bought as people join" : "an admin adds them"],
+            ["library hints", r.libraryHints ? "on: the same work is offered before it starts" : "off"]
+          ].map(([k, val]) => [ui2.c("dim", k), val])
+        );
+      }
+      case "audit": {
+        if (bool(ctx.args, "csv")) return void ctx.io.stdout.write(await ctx.api.auditCsv());
+        const list2 = await ctx.api.audit();
+        if (ctx.json) return ui2.json(list2);
+        if (!list2.length) return void ui2.out(ui2.c("dim", "nothing yet."));
+        return void ui2.table(list2.slice(0, 50).map((e) => [ui2.c("dim", new Date(e.at).toISOString().slice(0, 16).replace("T", " ")), e.actor, e.action, e.target ?? ""]), { head: ["when (utc)", "who", "what", "on"] });
+      }
+      case "billing": {
+        const b2 = await ctx.api.teamBilling();
+        if (ctx.json) return ui2.json(b2);
+        if (b2.plan !== "team") {
+          ui2.out(`no team plan yet: everyone is on their own plan. ${ui2.c("dim", `team: $${b2.price.perSeatUsd} a seat a month, ${b2.price.hoursPerSeat} h per seat pooled, then $${b2.price.hourlyUsd.toFixed(2)}/h`)}`);
+          return void ui2.out(ui2.c("dim", "start it (the owner): airgate team upgrade --seats <n>"));
+        }
+        return void ui2.table(
+          [
+            ["plan", `team \xB7 ${b2.status ?? "active"}`],
+            ["seats", `${b2.seats.used} used of ${b2.seats.paid ?? b2.seats.used} paid`],
+            ["pooled hours", `${(b2.seats.paid ?? b2.seats.used) * b2.price.hoursPerSeat} h this month`],
+            ["renews", b2.periodEnd ? new Date(b2.periodEnd).toISOString().slice(0, 10) : "?"],
+            ["paid by", b2.payer?.you ? "you" : b2.payer?.email ?? "the owner"]
+          ].map(([k, val]) => [ui2.c("dim", k), val])
+        );
+      }
+      case "upgrade": {
+        const v = await mine(ctx);
+        const seats = Math.max((v.members ?? []).length, Number(str(ctx.args, "seats") ?? a1 ?? (v.members ?? []).length) || 1);
+        const { url } = await ctx.api.teamCheckout(seats, "https://airgate.sh/app/team");
+        return openOrPrint(ctx, url, `the team plan checkout (${seats} seats)`);
+      }
+      case "seats": {
+        const n2 = Number(a1);
+        if (!Number.isInteger(n2) || n2 < 1) throw new UsageError("airgate team seats <n>");
+        const r = await ctx.api.setSeats(n2);
+        return ctx.json ? ui2.json(r) : void ui2.out(`${r.seats.paid} seats from now on (prorated). ${r.seats.used} in use.`);
+      }
+      case "secrets": {
+        const list2 = await ctx.api.teamSecrets();
+        if (ctx.json) return ui2.json(list2);
+        if (!list2.length) return void ui2.out(ui2.c("dim", "no team secrets. add one (admins): airgate team secret set NAME"));
+        ui2.table(list2.map((x) => [x.name, ui2.c("dim", `updated ${ago(x.updatedAt)}`)]));
+        return void ui2.out(ui2.c("dim", "every member's pods get these (their own secrets win on a clash); values never come back out"));
+      }
+      case "secret": {
+        if (a1 === "set") {
+          if (!a2) throw new UsageError("airgate team secret set NAME (the value comes from a hidden prompt or stdin)");
+          const value = await readValue(ctx, a2, `printf %s "$VALUE" | airgate team secret set ${a2}`);
+          const r = await ctx.api.setTeamSecrets({ [a2]: value });
+          return ctx.json ? ui2.json(r) : void ui2.out(`${r.created.length ? "added" : "updated"} ${a2} for the team. pods pick it up on their next wake.`);
+        }
+        if (a1 === "rm" || a1 === "remove" || a1 === "delete") {
+          if (!a2) throw new UsageError("airgate team secret rm NAME");
+          await ctx.api.deleteTeamSecret(a2);
+          return ctx.json ? ui2.json({ ok: true }) : void ui2.out(`removed ${a2} from the team.`);
+        }
+        throw new UsageError("airgate team secret set NAME | rm NAME");
+      }
+      case "triggers": {
+        const list2 = await ctx.api.triggers();
+        if (ctx.json) return ui2.json(list2);
+        if (!list2.length) return void ui2.out(ui2.c("dim", "no triggers. add one: airgate team trigger add <owner/repo> pr|issue [--recipe squad]"));
+        return void ui2.table(list2.map((t) => [t.repo, t.event === "pr_opened" ? "a pull request opens" : `an issue gets "${t.label}"`, `${t.recipe} crew`, ui2.c("dim", t.id)]), { head: ["repo", "when", "starts", "id"] });
+      }
+      case "trigger": {
+        if (a1 === "add") {
+          const [, , repo, when] = ctx.args.positionals;
+          if (!repo || when !== "pr" && when !== "issue") throw new UsageError("airgate team trigger add <owner/repo> pr|issue [--label l] [--recipe r]");
+          const t = await ctx.api.addTrigger({ repo, event: when === "pr" ? "pr_opened" : "issue_labeled", ...str(ctx.args, "label") ? { label: str(ctx.args, "label") } : {}, ...str(ctx.args, "recipe") ? { recipe: str(ctx.args, "recipe") } : {} });
+          if (ctx.json) return ui2.json(t);
+          ui2.out(`${ui2.c("ok", "added")}: ${t.event === "pr_opened" ? "each pull request opened on" : `each issue labelled "${t.label}" on`} ${t.repo} starts a ${t.recipe} crew.`);
+          return void ui2.out(ui2.c("dim", "it runs as you; what it pushes or opens waits in the airlock. the GitHub App must be on the repo: airgate github"));
+        }
+        if (a1 === "rm" || a1 === "remove") {
+          if (!a2) throw new UsageError("airgate team trigger rm <id>");
+          await ctx.api.removeTrigger(a2);
+          return ctx.json ? ui2.json({ ok: true }) : void ui2.out("removed.");
+        }
+        throw new UsageError("airgate team trigger add \u2026 | rm <id>");
+      }
+      default:
+        throw new UsageError(`unknown "${action}"`, "see: airgate help team");
+    }
+  }
+};
+var handover = {
+  name: "handover",
+  group: "pods",
+  usage: "<pod> <email>",
+  summary: "give a pod to a teammate, with its checkpoints, conversation and pod secrets",
+  example: "airgate handover web sam@acme.dev",
+  flags: { yes: { type: "boolean", short: "y", help: "don't ask" } },
+  async run(ctx) {
+    const [ref, to] = ctx.args.positionals;
+    if (!ref || !to) throw new UsageError("airgate handover <pod> <email>");
+    const p = await resolvePod(ctx, ref, { team: true });
+    if (!await confirm(ctx, `give ${p.spec.name} to ${to}? it becomes theirs`)) throw new CliError("nothing changed");
+    const r = await ctx.api.handover(p.id, to);
+    return ctx.json ? ctx.ui.json(r) : void ctx.ui.out(`${p.spec.name} is ${r.to.email}'s now.`);
+  }
+};
+var recall = {
+  name: "recall",
+  aliases: ["library"],
+  group: "pods",
+  usage: '["query"] | --patch <id> [--apply]',
+  summary: "your team's library: work teammates already did (reuse it instead of paying again) and their notes",
+  example: 'airgate recall "rate limiting"',
+  notes: [
+    "every finished task, run and crew in a team workspace lands here, with what it cost.",
+    "--patch <id> prints that work as a patch; --apply puts it into this folder with git apply (after asking)."
+  ],
+  flags: {
+    patch: { type: "string", value: "id", help: "print an entry's work as a patch" },
+    apply: { type: "boolean", help: "with --patch: apply it here (git apply)" },
+    yes: { type: "boolean", short: "y", help: "don't ask" }
+  },
+  async run(ctx) {
+    const { ui: ui2 } = ctx;
+    const id = str(ctx.args, "patch");
+    if (id) {
+      const { patch, entry } = await ctx.api.libraryPatch(id);
+      if (!bool(ctx.args, "apply")) {
+        if (ctx.json) return ui2.json({ patch, entry });
+        return void ctx.io.stdout.write(patch);
+      }
+      if (!patch.trim()) throw new CliError("that work has no changes to apply");
+      const file = resolve4(ctx.io.cwd, `.airgate-recall-${id}.patch`);
+      writeFileSync2(file, patch);
+      try {
+        const check = spawnSync("git", ["apply", "--check", file], { cwd: ctx.io.cwd, encoding: "utf8" });
+        if (check.status !== 0) throw new CliError("it doesn't apply cleanly here", (check.stderr || "").trim().split("\n")[0] || "look at it first: airgate recall --patch " + id);
+        const files2 = (patch.match(/^\+\+\+ b\/(.+)$/gm) ?? []).map((l) => l.slice(6));
+        if (!await confirm(ctx, `apply "${entry.title}" by ${entry.author} here (${files2.length} file${files2.length === 1 ? "" : "s"})?`)) throw new CliError("nothing applied");
+        const r = spawnSync("git", ["apply", file], { cwd: ctx.io.cwd, encoding: "utf8" });
+        if (r.status !== 0) throw new CliError("git apply failed", (r.stderr || "").trim());
+        if (ctx.json) return ui2.json({ applied: true, files: files2 });
+        return void ui2.out(`${ui2.c("ok", "applied")} ${files2.length} file${files2.length === 1 ? "" : "s"}: ${files2.slice(0, 8).join(", ")}${files2.length > 8 ? ", \u2026" : ""}`);
+      } finally {
+        rmSync2(file, { force: true });
+      }
+    }
+    const q = ctx.args.positionals.join(" ");
+    let entries;
+    try {
+      entries = await ctx.api.library(q);
+    } catch (e) {
+      if (e instanceof ApiError && e.code === "no_workspace") throw new CliError("you're not in a team workspace", "the library is for teams: airgate team");
+      throw e;
+    }
+    if (ctx.json) return ui2.json(entries);
+    if (!entries.length) return void ui2.out(ui2.c("dim", q ? `nothing in the library matches "${q}"` : "the library is empty: finished team work lands here"));
+    for (const e of entries) {
+      const cost = e.cost?.tokens ? ` \xB7 ${e.cost.tokens} tokens` : e.cost?.activeSeconds ? ` \xB7 ${Math.round(e.cost.activeSeconds / 60)} min` : "";
+      ui2.out(`${ui2.c("ok", e.title)} ${ui2.c("dim", `${e.kind} by ${e.author}, ${ago(e.at)}${cost} \xB7 ${e.id}`)}`);
+      if (e.summary) ui2.out(`  ${e.summary.split("\n")[0].slice(0, 160)}`);
+      if (e.files?.length) ui2.out(ui2.c("dim", `  ${e.files.slice(0, 6).join(", ")}${e.files.length > 6 ? ", \u2026" : ""}`));
+    }
+    ui2.out(ui2.c("dim", "reuse one: airgate recall --patch <id> --apply"));
+  }
+};
+var note = {
+  name: "note",
+  group: "pods",
+  usage: '"<what the team should know>"',
+  summary: "save a note to your team library; every new pod in the team reads it",
+  example: 'airgate note "tests need DATABASE_URL=sqlite::memory:"',
+  async run(ctx) {
+    const text2 = ctx.args.positionals.join(" ").trim();
+    if (!text2) throw new UsageError('airgate note "<what the team should know>"');
+    const r = await ctx.api.note(text2);
+    return ctx.json ? ctx.ui.json(r) : void ctx.ui.out("saved for the team.");
+  }
+};
+var verify = {
+  name: "verify",
+  group: "account",
+  usage: "",
+  summary: "send the link that confirms your email again (it also adds you to your team at that domain)",
+  example: "airgate verify",
+  async run(ctx) {
+    const me = await ctx.api.me();
+    if (me.user.emailVerified) return ctx.json ? ctx.ui.json({ sent: false, verified: true }) : void ctx.ui.out(`${me.user.email} is confirmed already.`);
+    const r = await ctx.api.sendVerification();
+    if (ctx.json) return ctx.ui.json(r);
+    ctx.ui.out(r.sent ? `sent to ${me.user.email}. open the link in it.` : "this gateway can't send email; ask whoever runs it");
+  }
+};
+var bug = {
+  name: "bug",
+  aliases: ["report"],
+  group: "account",
+  usage: '"<what happened>" [--expected "<what you expected>"]',
+  summary: "report a bug: a person reads every report, and you get an email when it changes",
+  example: 'airgate bug "airgate down said the patch was empty after a crew"',
+  notes: [
+    "it sends your words plus the cli version, your OS and node version, and the folder name (never its contents). --no-context sends only your words.",
+    "or pipe a longer report in: airgate bug < report.txt"
+  ],
+  flags: {
+    expected: { type: "string", value: "text", help: "what you expected instead" },
+    "no-context": { type: "boolean", help: "don't send the cli version, OS and folder name" }
+  },
+  async run(ctx) {
+    let text2 = ctx.args.positionals.join(" ").trim();
+    if (!text2 && !ctx.io.stdin.isTTY) {
+      const chunks = [];
+      for await (const c of ctx.io.stdin) chunks.push(Buffer.from(c));
+      text2 = Buffer.concat(chunks).toString("utf8").trim();
+    }
+    if (text2.length < 5) throw new UsageError('airgate bug "<what happened>"', 'a sentence is enough; add --expected "<what you expected>"');
+    const context = bool(ctx.args, "no-context") ? void 0 : { cli: VERSION, os: `${process.platform} ${process.arch}`, node: process.version, folder: ctx.io.cwd.split("/").pop() ?? "" };
+    const r = await ctx.api.reportBug(text2.slice(0, 8e3), str(ctx.args, "expected"), context);
+    if (ctx.json) return ctx.ui.json(r);
+    ctx.ui.out(`${ctx.ui.c("ok", "reported")} ${r.bug.id}. a person reads it; you get an email when it changes.`);
+  }
+};
+
 // src/commands/pods.ts
 import { execFileSync } from "node:child_process";
 import { readFileSync as readFileSync3 } from "node:fs";
@@ -7308,19 +7900,35 @@ var pods = {
   aliases: ["ls"],
   group: "pods",
   usage: "",
-  summary: "list your pods",
+  summary: "list your pods, and the ones teammates shared with your team",
   example: "airgate ls --json",
+  notes: ["--json: your pods as a list (pods teammates shared are in airgate ls --team --json)."],
+  flags: { team: { type: "boolean", help: "with --json: { pods, team } including teammates' shared pods" } },
   async run(ctx) {
-    const all = await ctx.api.pods();
-    if (ctx.json) return ctx.ui.json(all);
-    if (!all.length) {
+    const { pods: all, team: team2 } = await ctx.api.podsWithTeam();
+    if (ctx.json) return ctx.ui.json(ctx.args.flags.team === true ? { pods: all, team: team2 } : all);
+    if (!all.length && !team2.length) {
       ctx.ui.out("no pods yet. launch one: airgate launch");
       return;
     }
-    ctx.ui.table(
-      all.map((p) => podRow(ctx, p)),
-      { head: ["name", "id", "state", "agent", "size", "template", "active", "created"] }
-    );
+    if (all.length) {
+      ctx.ui.table(
+        all.map((p) => {
+          const row = podRow(ctx, p);
+          if (p.shared) row[0] += ctx.ui.c("dim", " (team)");
+          return row;
+        }),
+        { head: ["name", "id", "state", "agent", "size", "template", "active", "created"] }
+      );
+    } else ctx.ui.out(ctx.ui.c("dim", "no pods of your own yet. launch one: airgate launch"));
+    if (team2.length) {
+      ctx.ui.out();
+      ctx.ui.out(ctx.ui.c("dim", "shared by teammates (open: airgate attach <name> \xB7 copy: airgate race <name>):"));
+      ctx.ui.table(
+        team2.map((p) => [ctx.ui.c("ok", p.spec.name), ctx.ui.c("dim", p.id), p.state, p.owner?.email ?? "", p.viewers?.length ? ctx.ui.c("warn", `${p.viewers.length} in it`) : ""]),
+        { indent: 2 }
+      );
+    }
   }
 };
 var launch = {
@@ -7476,7 +8084,7 @@ var info = {
   summary: "details of one pod",
   example: "airgate info fix-nav",
   async run(ctx) {
-    const p = await resolvePod(ctx, ctx.args.positionals[0]);
+    const p = await resolvePod(ctx, ctx.args.positionals[0], { team: true });
     if (ctx.json) return ctx.ui.json(p);
     const s2 = p.spec;
     const rows2 = [
@@ -7496,6 +8104,9 @@ var info = {
     for (const [i, j] of (s2.jobs ?? []).entries()) {
       rows2.push([i ? "" : "jobs", `${j.enabled === false ? ctx.ui.c("dim", "paused ") : ""}${j.name ? j.name + " \xB7 " : ""}${j.cron} \xB7 ${j.task.length > 60 ? j.task.slice(0, 59) + "\u2026" : j.task}`]);
     }
+    if (p.owner) rows2.push(["owner", `${p.owner.email} (shared with your team)`]);
+    else if (p.shared) rows2.push(["team", "shared with your workspace"]);
+    if (p.viewers?.length) rows2.push(["in it now", p.viewers.map((v) => v.email).join(", ")]);
     if (p.forkOf) rows2.push(["race of", `${p.forkOf.podId} @ ${p.forkOf.checkpointId}`]);
     rows2.push(["checkpoints", String(p.snapshots.length)]);
     rows2.push(["active", duration2(p.seconds)]);
@@ -7695,13 +8306,15 @@ var task = {
   usage: '<pod> "<task>" [--wait]',
   summary: "hand the pod's agent a task now; it runs headless and logs like a job",
   example: 'airgate task fix-nav "make the nav sticky on mobile, run the tests"',
-  flags: { wait: { type: "boolean", short: "w", help: "wait for it to finish and print the log" } },
+  flags: { wait: { type: "boolean", short: "w", help: "wait for it to finish and print the log" }, yes: { type: "boolean", short: "y", help: "don't ask" } },
   async run(ctx) {
     const [ref, ...words2] = ctx.args.positionals;
     const text2 = (ctx.args.dashdash ? ctx.args.rest : words2).join(" ").trim();
     if (!text2) throw new UsageError("what should the agent do?", 'airgate task <pod> "<task>"');
     if (text2.length > 4e3) throw new UsageError("the task is 4000 characters at most");
     const p = await resolvePod(ctx, ref);
+    const same = await checkSimilar(ctx, text2);
+    if (!same.go) notStarted(same.similar);
     let run2 = await ctx.ui.spin(`handing ${p.spec.name} the task`, ctx.api.startTask(p.id, text2));
     if (ctx.args.flags.wait === true) {
       run2 = await ctx.ui.spin(`${p.spec.name} is working`, () => waitRun(ctx, p.id, run2));
@@ -7776,16 +8389,13 @@ var log = {
 // src/commands/mcp.ts
 import { createInterface } from "node:readline";
 
-// src/version.ts
-var VERSION = "0.1.6";
-
 // src/commands/updown.ts
-import { appendFileSync, existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync5, realpathSync as realpathSync2, statSync as statSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { appendFileSync, existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync5, realpathSync as realpathSync2, statSync as statSync2, writeFileSync as writeFileSync4 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { basename, dirname as dirname2, isAbsolute, join as join4, relative as relative2, resolve as resolve4 } from "node:path";
+import { basename, dirname as dirname2, isAbsolute, join as join4, relative as relative2, resolve as resolve5 } from "node:path";
 
 // src/pack.ts
-import { spawn, spawnSync } from "node:child_process";
+import { spawn, spawnSync as spawnSync2 } from "node:child_process";
 import { existsSync, lstatSync, readdirSync } from "node:fs";
 import { join as join2 } from "node:path";
 var UPLOAD_LIMIT = 32 * 6 * 1024 * 1024;
@@ -7802,7 +8412,7 @@ function isEnvFile(path) {
 }
 var ENV_EXCLUDES = [".env", ".env.local", ".env.*.local", ".env.development", ".env.production", ".env.test", ".env.staging", ".envrc"].map((p) => `--exclude=${p}`);
 function git(cwd, args, input) {
-  const r = spawnSync("git", args, { cwd, input, maxBuffer: 256 * 1024 * 1024 });
+  const r = spawnSync2("git", args, { cwd, input, maxBuffer: 256 * 1024 * 1024 });
   return { status: r.status ?? (r.error ? 127 : 1), stdout: r.stdout?.toString("utf8") ?? "", stderr: r.stderr?.toString("utf8") ?? "", error: r.error };
 }
 function isGitRepo(dir) {
@@ -7829,7 +8439,7 @@ function gitFiles(dir) {
   return out;
 }
 function runTar(cwd, args, input, limit = UPLOAD_LIMIT) {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     const child = spawn("tar", args, { cwd, env: { ...process.env, COPYFILE_DISABLE: "1" }, stdio: ["pipe", "pipe", "pipe"] });
     const chunks = [];
     let size2 = 0;
@@ -7849,7 +8459,7 @@ function runTar(cwd, args, input, limit = UPLOAD_LIMIT) {
     child.on("close", (code3) => {
       if (over2) return reject(new TooLargeError(limit));
       if (code3 !== 0) return reject(new Error(`tar failed: ${err.trim().split("\n").slice(-3).join(" ")}`));
-      resolve8(Buffer.concat(chunks));
+      resolve9(Buffer.concat(chunks));
     });
     child.stdin.on("error", () => void 0);
     child.stdin.end(input ?? "");
@@ -7889,7 +8499,7 @@ import { gunzipSync } from "node:zlib";
 
 // src/sessions.ts
 import { createHash, randomUUID } from "node:crypto";
-import { closeSync, existsSync as existsSync2, mkdirSync as mkdirSync2, mkdtempSync, openSync, readdirSync as readdirSync2, readFileSync as readFileSync4, readSync, realpathSync, renameSync as renameSync2, rmSync as rmSync2, statSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { closeSync, existsSync as existsSync2, mkdirSync as mkdirSync2, mkdtempSync, openSync, readdirSync as readdirSync2, readFileSync as readFileSync4, readSync, realpathSync, renameSync as renameSync2, rmSync as rmSync3, statSync, writeFileSync as writeFileSync3 } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join as join3, relative } from "node:path";
 var POD_HOME = "/home/sprite";
@@ -7999,7 +8609,7 @@ async function packSession(s2, projectDir, podPath, limit = UPLOAD_LIMIT) {
     const names = [];
     if (s2.agent === "claude-code") {
       podDir = `.claude/projects/${claudeKey(podPath)}`;
-      writeFileSync2(join3(stage, `${s2.id}.jsonl`), rewriteAll(raw.toString("utf8"), froms, podPath));
+      writeFileSync3(join3(stage, `${s2.id}.jsonl`), rewriteAll(raw.toString("utf8"), froms, podPath));
       names.push(`${s2.id}.jsonl`);
       if (s2.sidecar) {
         const copy2 = (src, dst) => {
@@ -8011,7 +8621,7 @@ async function packSession(s2, projectDir, podPath, limit = UPLOAD_LIMIT) {
               copy2(a, b2);
             } else if (x.isFile()) {
               const body = readFileSync4(a);
-              writeFileSync2(b2, /\.(jsonl?|txt|md)$/.test(x.name) ? rewriteAll(body.toString("utf8"), froms, podPath) : body);
+              writeFileSync3(b2, /\.(jsonl?|txt|md)$/.test(x.name) ? rewriteAll(body.toString("utf8"), froms, podPath) : body);
             }
           }
         };
@@ -8023,7 +8633,7 @@ async function packSession(s2, projectDir, podPath, limit = UPLOAD_LIMIT) {
       const rel = relative(join3(dirname(s2.file), "..", "..", ".."), s2.file);
       podDir = `.codex/sessions/${dirname(rel)}`;
       const name = rel.split("/").pop();
-      writeFileSync2(join3(stage, name), rewriteAll(raw.toString("utf8"), froms, podPath));
+      writeFileSync3(join3(stage, name), rewriteAll(raw.toString("utf8"), froms, podPath));
       names.push(name);
     }
     const archive = await runTar(stage, ["-czf", "-", ...names], null, limit);
@@ -8034,7 +8644,7 @@ async function packSession(s2, projectDir, podPath, limit = UPLOAD_LIMIT) {
       sent: { agent: s2.agent, id: s2.id, file: s2.file, sha256: sha256(raw), localPath: projectDir, podPath }
     };
   } finally {
-    rmSync2(stage, { recursive: true, force: true });
+    rmSync3(stage, { recursive: true, force: true });
   }
 }
 var resumeCommand = (agent, id) => agent === "claude-code" ? `claude --resume ${id}` : `codex resume ${id}`;
@@ -8047,7 +8657,7 @@ function bringBack(sent, podContent, now = /* @__PURE__ */ new Date()) {
   const atomic = (file2, body2) => {
     mkdirSync2(dirname(file2), { recursive: true });
     const tmp = `${file2}.airgate-${process.pid}`;
-    writeFileSync2(tmp, body2, { mode: 384 });
+    writeFileSync3(tmp, body2, { mode: 384 });
     renameSync2(tmp, file2);
   };
   if (!local || sha256(local) === sent.sha256) {
@@ -8237,10 +8847,10 @@ var STATE_DIR = ".airgate";
 var statePath = (projectDir) => join4(projectDir, STATE_DIR, "state.json");
 function writeState(projectDir, s2) {
   mkdirSync3(join4(projectDir, STATE_DIR), { recursive: true });
-  writeFileSync3(statePath(projectDir), JSON.stringify(s2, null, 2) + "\n");
+  writeFileSync4(statePath(projectDir), JSON.stringify(s2, null, 2) + "\n");
 }
 function findState(from) {
-  let dir = resolve4(from);
+  let dir = resolve5(from);
   for (; ; ) {
     const p = statePath(dir);
     if (existsSync3(p)) {
@@ -8270,7 +8880,7 @@ function excludeStateDir(projectDir) {
   return true;
 }
 function podDirName(projectDir) {
-  const n2 = basename(resolve4(projectDir)).replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^[.-]+/, "");
+  const n2 = basename(resolve5(projectDir)).replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^[.-]+/, "");
   return n2 && n2 !== "." && n2 !== ".." ? n2.slice(0, 64) : "project";
 }
 var up = {
@@ -8304,7 +8914,7 @@ var up = {
     const noSession = bool(ctx.args, "no-session");
     const sessionId = str(ctx.args, "session");
     if (noSession && sessionId) throw new UsageError("--session and --no-session together?");
-    const projectDir = resolve4(ctx.io.cwd, ctx.args.positionals[0] ?? ".");
+    const projectDir = resolve5(ctx.io.cwd, ctx.args.positionals[0] ?? ".");
     if (!existsSync3(projectDir) || !statSync2(projectDir).isDirectory()) throw new CliError(`no directory ${projectDir}`);
     const name = podDirName(projectDir);
     const podDir = `workspace/${name}`;
@@ -8637,7 +9247,7 @@ var LineReader = class {
   }
 };
 function ttyPrompt(stdin, out) {
-  return (question, opts2 = {}) => new Promise((resolve8, reject) => {
+  return (question, opts2 = {}) => new Promise((resolve9, reject) => {
     out.write(question);
     const decoder = new StringDecoder2("utf8");
     let answer = "";
@@ -8650,7 +9260,7 @@ function ttyPrompt(stdin, out) {
       stdin.pause();
       out.write("\n");
       if (err) reject(err);
-      else resolve8(answer);
+      else resolve9(answer);
     };
     const onData = (d) => {
       for (const ch of decoder.write(d)) {
@@ -8677,16 +9287,16 @@ function ttyPrompt(stdin, out) {
 }
 function openInBrowser(url) {
   const [cmd, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", '""', url]] : ["xdg-open", [url]];
-  return new Promise((resolve8) => {
+  return new Promise((resolve9) => {
     try {
       const child = spawn2(cmd, args, { stdio: "ignore", detached: true });
-      child.on("error", () => resolve8(false));
+      child.on("error", () => resolve9(false));
       child.on("spawn", () => {
         child.unref();
-        resolve8(true);
+        resolve9(true);
       });
     } catch {
-      resolve8(false);
+      resolve9(false);
     }
   });
 }
@@ -8780,12 +9390,12 @@ async function runCommand(ctx, cmd, argv, cwd) {
 }
 
 // src/commands/run.ts
-import { existsSync as existsSync5, readFileSync as readFileSync8, rmSync as rmSync4, statSync as statSync3, writeFileSync as writeFileSync5 } from "node:fs";
-import { basename as basename2, resolve as resolve5 } from "node:path";
+import { existsSync as existsSync5, readFileSync as readFileSync8, rmSync as rmSync5, statSync as statSync3, writeFileSync as writeFileSync6 } from "node:fs";
+import { basename as basename2, resolve as resolve6 } from "node:path";
 import { randomBytes } from "node:crypto";
 
 // src/relay.ts
-import { chmodSync as chmodSync2, existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync6, renameSync as renameSync3, writeFileSync as writeFileSync4 } from "node:fs";
+import { chmodSync as chmodSync2, existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync6, renameSync as renameSync3, writeFileSync as writeFileSync5 } from "node:fs";
 import { join as join5 } from "node:path";
 function vendorOf(name) {
   const n2 = (name ?? "").toLowerCase();
@@ -8811,7 +9421,7 @@ function saveLocal(env, vendor, value, kind = value ? kindOf(vendor, value) : "a
   mkdirSync4(dir, { recursive: true, mode: 448 });
   const file = modelsPath(env);
   const tmp = `${file}.${process.pid}.tmp`;
-  writeFileSync4(tmp, JSON.stringify(all, null, 2) + "\n", { mode: 384 });
+  writeFileSync5(tmp, JSON.stringify(all, null, 2) + "\n", { mode: 384 });
   chmodSync2(tmp, 384);
   renameSync3(tmp, file);
   chmodSync2(file, 384);
@@ -8946,8 +9556,8 @@ function startRelay(o) {
 }
 
 // src/commands/models.ts
-import { spawnSync as spawnSync2 } from "node:child_process";
-import { mkdtempSync as mkdtempSync2, readFileSync as readFileSync7, rmSync as rmSync3 } from "node:fs";
+import { spawnSync as spawnSync3 } from "node:child_process";
+import { mkdtempSync as mkdtempSync2, readFileSync as readFileSync7, rmSync as rmSync4 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
 import { join as join6 } from "node:path";
 var HOW = {
@@ -8970,14 +9580,14 @@ async function connectChatgpt(ctx, laptop) {
   if (!ctx.io.stdin.isTTY) {
     text2 = await readValue(ctx, "a Codex auth.json", "cat auth.json | airgate models connect chatgpt");
   } else {
-    if (spawnSync2("codex", ["--version"], { stdio: "ignore" }).status !== 0) {
+    if (spawnSync3("codex", ["--version"], { stdio: "ignore" }).status !== 0) {
       throw new CliError("Codex is not installed on this laptop", "npm i -g @openai/codex, then: airgate models connect chatgpt");
     }
     const home = mkdtempSync2(join6(tmpdir2(), "airgate-codex-"));
     try {
       ui2.err(ui2.ce("dim", "signing in to ChatGPT for airgate: a separate Codex login, so the one on this laptop stays as it is."));
       const args = ["login", ...bool(ctx.args, "device") ? ["--device-auth"] : [], "-c", 'cli_auth_credentials_store="file"'];
-      const r2 = spawnSync2("codex", args, { stdio: "inherit", env: { ...process.env, ...ctx.io.env, CODEX_HOME: home } });
+      const r2 = spawnSync3("codex", args, { stdio: "inherit", env: { ...process.env, ...ctx.io.env, CODEX_HOME: home } });
       if (r2.status !== 0) throw new CliError("the ChatGPT sign-in did not finish", "try again, or with --device");
       try {
         text2 = readFileSync7(join6(home, "auth.json"), "utf8");
@@ -8985,7 +9595,7 @@ async function connectChatgpt(ctx, laptop) {
         throw new CliError("Codex didn't write a login file", "update Codex (npm i -g @openai/codex) and try again");
       }
     } finally {
-      rmSync3(home, { recursive: true, force: true });
+      rmSync4(home, { recursive: true, force: true });
     }
   }
   let tokens2;
@@ -9166,6 +9776,8 @@ var runTask = {
     const minutes = Number(str(ctx.args, "timeout") ?? "60");
     if (!Number.isFinite(minutes) || minutes <= 0) throw new UsageError("--timeout: minutes, e.g. 30");
     const repo = str(ctx.args, "repo");
+    const same = await checkSimilar(ctx, task2);
+    if (!same.go) notStarted(same.similar);
     const warnings = [];
     const relayer = relayIfSignedIn(ctx);
     if (relayer && !ctx.json) ui2.err(ui2.ce("dim", `this laptop signs the pod's ${relayer.vendors.map(vendorLabel).join(" / ")} calls while it runs (airgate holds nothing)`));
@@ -9211,7 +9823,7 @@ var runTask = {
         ui2.out(`${r2.ok ? ui2.c("ok", "done") : ui2.c("bad", "failed")} on ${name2}${r2.done ? " (asleep now, free)" : ""}. look: airgate attach ${name2}${bool(ctx.args, "pr") ? " \xB7 the pull request: airgate airlock" : ""}`);
         return r2.ok ? 0 : 1;
       }
-      const projectDir = resolve5(ctx.io.cwd, dirArg ?? ".");
+      const projectDir = resolve6(ctx.io.cwd, dirArg ?? ".");
       if (!existsSync5(projectDir) || !statSync3(projectDir).isDirectory()) throw new CliError(`no directory ${projectDir}`);
       const noApply = bool(ctx.args, "no-apply");
       if (!noApply && !gitTopLevel(projectDir)) {
@@ -9221,8 +9833,8 @@ var runTask = {
       const before = existsSync5(sp) ? readFileSync8(sp, "utf8") : null;
       const restoreState = () => {
         try {
-          if (before !== null) writeFileSync5(sp, before);
-          else rmSync4(sp, { force: true });
+          if (before !== null) writeFileSync6(sp, before);
+          else rmSync5(sp, { force: true });
         } catch {
         }
       };
@@ -9283,8 +9895,8 @@ When you are done, leave your changes in the files there (no need to commit or p
 };
 
 // src/commands/crews.ts
-import { existsSync as existsSync6, readFileSync as readFileSync9, realpathSync as realpathSync3, rmSync as rmSync5, statSync as statSync4, writeFileSync as writeFileSync6 } from "node:fs";
-import { relative as relative3, resolve as resolve6 } from "node:path";
+import { existsSync as existsSync6, readFileSync as readFileSync9, realpathSync as realpathSync3, rmSync as rmSync6, statSync as statSync4, writeFileSync as writeFileSync7 } from "node:fs";
+import { relative as relative3, resolve as resolve7 } from "node:path";
 var KINDS = ["race", "contest", "council", "squad", "split"];
 var ACTIONS = ["show", "say", "stop", "down", "rm", "list"];
 var AGENT_ALIAS = { claude: "claude-code", "claude-code": "claude-code", codex: "codex", opencode: "opencode", pi: "pi" };
@@ -9446,6 +10058,8 @@ var crew = {
     const task2 = (second ?? "").trim();
     if (!task2) throw new UsageError(`what should the crew do? airgate crew ${kind} "<task>"`);
     if (extra) throw new UsageError(`unexpected "${extra}" (put the task in quotes)`);
+    const same = await checkSimilar(ctx, task2);
+    if (!same.go) notStarted(same.similar);
     const sources = ["pod", "from", "repo"].filter((k) => str(ctx.args, k));
     if (sources.length > 1) throw new UsageError("one starting point: --pod, --from or --repo");
     if (sources.length && third) throw new UsageError("a folder or --pod / --from / --repo, not both");
@@ -9466,14 +10080,14 @@ var crew = {
       basePodId = (await ui2.spin(`starting the base pod on ${spec.repo}`, async () => waitReady(ctx, await ctx.api.launch(spec)))).id;
       temporaryBase = true;
     } else {
-      const projectDir = resolve6(ctx.io.cwd, third ?? ".");
+      const projectDir = resolve7(ctx.io.cwd, third ?? ".");
       if (!existsSync6(projectDir) || !statSync4(projectDir).isDirectory()) throw new CliError(`no directory ${projectDir}`);
       const sp = statePath(projectDir);
       const before = existsSync6(sp) ? readFileSync9(sp, "utf8") : null;
       restoreState = () => {
         try {
-          if (before !== null) writeFileSync6(sp, before);
-          else rmSync5(sp, { force: true });
+          if (before !== null) writeFileSync7(sp, before);
+          else rmSync6(sp, { force: true });
         } catch {
         }
       };
@@ -9536,6 +10150,7 @@ var jobSchema = obj(
 );
 var OWN = /* @__PURE__ */ new Map();
 var n = (description) => ({ type: "number", description });
+var sameWork = async (ctx, task2) => (await ctx.api.similar(task2).catch(() => [])).map((e) => ({ id: e.id, title: e.title, by: e.author, summary: e.summary, reuse: `team_patch id=${e.id}` }));
 var dirOf = (ctx, a) => typeof a.dir === "string" && a.dir ? a.dir : ctx.io.cwd;
 var TOOLS = [
   {
@@ -9745,9 +10360,10 @@ var TOOLS = [
       if (a.keep === true) argv.push("--keep");
       if (a.pr === true) argv.push("--pr");
       if (typeof a.timeoutMinutes === "number") argv.push("--timeout", String(a.timeoutMinutes));
+      const similar = await sameWork(ctx, String(a.task));
       const out = await runCommand(ctx, runTask, argv, dirOf(ctx, a));
       if (out.pod?.id && out.pod_state !== "deleted") OWN.set(out.pod.id, a.repo ? "launch" : "project");
-      return out;
+      return similar.length ? { ...out, similar } : out;
     }
   },
   {
@@ -9896,7 +10512,53 @@ var TOOLS = [
       if (typeof a.maxMinutes === "number") argv.push("--minutes", String(a.maxMinutes));
       if (a.build === true) argv.push("--build");
       if (a.pr === true) argv.push("--pr");
-      return runCommand(ctx, crew, argv, dirOf(ctx, a));
+      const similar = await sameWork(ctx, String(a.task));
+      const out = await runCommand(ctx, crew, argv, dirOf(ctx, a));
+      return similar.length ? { ...out, similar } : out;
+    }
+  },
+  {
+    name: "team_recall",
+    description: "Search the user's team library: work teammates already did (finished tasks, runs and crews, with a summary, the files and what it cost) and notes they wrote. Before a big task, search for it: reusing a teammate's result (team_patch) saves paying for the same work twice. Empty query: the newest entries. Only for people in a team workspace.",
+    inputSchema: obj({ query: s("a few words about the work") }),
+    async call(ctx, a) {
+      return (await ctx.api.library(typeof a.query === "string" ? a.query : "")).map((e) => ({ id: e.id, kind: e.kind, title: e.title, summary: e.summary, files: e.files, by: e.author, at: new Date(e.at).toISOString(), cost: e.cost }));
+    }
+  },
+  {
+    name: "team_patch",
+    description: "A team library entry's work as a unified diff (a crew's result, or a pod's changes). Apply it in the local repo with git apply after telling the user what it is and who made it.",
+    inputSchema: obj({ id: s("the entry id from team_recall") }, ["id"]),
+    async call(ctx, a) {
+      const r = await ctx.api.libraryPatch(need(a, "id"));
+      return { title: r.entry.title, by: r.entry.author, patch: r.patch };
+    }
+  },
+  {
+    name: "team_note",
+    description: "Save a short note to the team library for every teammate and every new pod in the team (how to run the tests, a gotcha, where things live). Only durable facts, never secrets.",
+    inputSchema: obj({ text: s("the note, one or two sentences") }, ["text"]),
+    async call(ctx, a) {
+      return ctx.api.note(need(a, "text"));
+    }
+  },
+  {
+    name: "pod_share",
+    description: "Share one of the user's pods with their team workspace (teammates can open its terminal, files and checkpoints and fork it; never delete it), or stop sharing. Only when the user asks for it.",
+    inputSchema: obj({ pod: POD, shared: b("true shares it, false makes it private again") }, ["pod", "shared"]),
+    async call(ctx, a) {
+      const p = await resolvePod(ctx, need(a, "pod"));
+      const pod = await ctx.api.sharePod(p.id, a.shared !== false);
+      return { pod: pod.spec.name, shared: Boolean(pod.shared) };
+    }
+  },
+  {
+    name: "pod_handover",
+    description: "Give one of the user's pods to a teammate (it becomes theirs, with its checkpoints and conversation). Only when the user explicitly asks for it, naming the teammate.",
+    inputSchema: obj({ pod: POD, email: s("the teammate's email") }, ["pod", "email"]),
+    async call(ctx, a) {
+      const p = await resolvePod(ctx, need(a, "pod"));
+      return ctx.api.handover(p.id, need(a, "email"));
     }
   },
   {
@@ -9977,7 +10639,7 @@ async function handle(ctx, msg) {
         protocolVersion: asked,
         capabilities: { tools: { listChanged: false } },
         serverInfo: { name: "airgate", title: "Airgate", version: VERSION },
-        instructions: "Airgate pods are private cloud computers for coding agents; crews put several agents (each in its own pod) on one task: crew_start, crew_status, crew_down. pod_run does one task in a fresh pod and brings the result back; pod_up / pod_down move the local project and conversation there and back; task_start hands an existing pod a task (run_status / run_log follow it). Sleep pods you are done with; delete only pods you launched (or the user asked). Outbound actions wait in the airlock for the user: never approve on your own initiative."
+        instructions: "Airgate pods are private cloud computers for coding agents; crews put several agents (each in its own pod) on one task: crew_start, crew_status, crew_down. pod_run does one task in a fresh pod and brings the result back; pod_up / pod_down move the local project and conversation there and back; task_start hands an existing pod a task (run_status / run_log follow it). Sleep pods you are done with; delete only pods you launched (or the user asked). Outbound actions wait in the airlock for the user: never approve on your own initiative. In a team workspace: search team_recall before big work and reuse a teammate's result with team_patch instead of paying for it again; save durable learnings with team_note; never touch teammates' pods beyond reading them."
       });
     }
     case "ping":
@@ -10045,7 +10707,7 @@ var mcp = {
 };
 
 // src/commands/misc.ts
-import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync7 } from "node:fs";
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync8 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
 import { join as join7 } from "node:path";
 var PAGES = ["pods", "airlock", "usage", "settings", "mask", "chat", "notes", "data", "status"];
@@ -10079,15 +10741,19 @@ var status = {
     const h = await ctx.ui.spin("checking the gateway", ctx.api.health());
     const ms = Date.now() - t0;
     let signedIn = null;
+    let verified = null;
     if (ctx.api.signedIn) {
-      signedIn = await ctx.api.me().then((m) => m.user.email).catch(() => null);
+      const m = await ctx.api.me().catch(() => null);
+      signedIn = m?.user.email ?? null;
+      const v = m?.user?.emailVerified;
+      verified = typeof v === "boolean" ? v : null;
     }
-    if (ctx.json) return ctx.ui.json({ gateway: ctx.cfg.gateway, ...h, latencyMs: ms, signedIn, version: VERSION });
+    if (ctx.json) return ctx.ui.json({ gateway: ctx.cfg.gateway, ...h, latencyMs: ms, signedIn, emailVerified: verified, version: VERSION });
     const rows2 = [
       ["gateway", `${ctx.cfg.gateway} ${h.ok ? ctx.ui.c("ok", "ok") : ctx.ui.c("bad", "down")} ${ctx.ui.c("dim", `${ms}ms`)}`],
       ["provider", h.provider === "simulator" ? ctx.ui.c("warn", "simulator") : h.provider],
       ["billing", h.billing ? "on" : "off"],
-      ["signed in", signedIn ?? (ctx.api.signedIn ? ctx.ui.c("bad", "token rejected \xB7 airgate login") : ctx.ui.c("warn", "no \xB7 airgate login"))],
+      ["signed in", (signedIn ?? (ctx.api.signedIn ? ctx.ui.c("bad", "token rejected \xB7 airgate login") : ctx.ui.c("warn", "no \xB7 airgate login"))) + (signedIn && verified === false ? ctx.ui.c("warn", " \xB7 email not confirmed (airgate verify)") : "")],
       ["config", configPath(ctx.io.env)]
     ];
     ctx.ui.table(rows2.map(([k, v]) => [ctx.ui.c("dim", k), v]));
@@ -10126,7 +10792,7 @@ var skill = {
     const base = bool(ctx.args, "project") ? join7(ctx.io.cwd, ".claude") : join7(ctx.io.env.HOME ?? homedir3(), ".claude");
     const dir = join7(base, "skills", "airgate");
     mkdirSync5(dir, { recursive: true });
-    writeFileSync7(join7(dir, "SKILL.md"), text2);
+    writeFileSync8(join7(dir, "SKILL.md"), text2);
     if (ctx.json) return ctx.ui.json({ installed: join7(dir, "SKILL.md") });
     ctx.ui.out(`${ctx.ui.c("ok", "installed")} the airgate skill: ${join7(dir, "SKILL.md")}`);
     ctx.ui.out(ctx.ui.c("dim", 'claude code picks it up in its next session. ask it to "move this to an airgate pod".'));
@@ -10190,11 +10856,22 @@ var preview = {
 var share = {
   name: "share",
   group: "pods",
-  usage: "<pod> <port> [--off]",
-  summary: "a public link to a port of a pod (anyone with it can open it); --off makes it private again",
-  example: "airgate share web 3000",
+  usage: "<pod> [port] [--off]",
+  summary: "share a pod with your team (teammates open, watch and fork it), or a port publicly by link; --off undoes it",
+  example: "airgate share web",
+  notes: [
+    "airgate share <pod>         your team workspace sees it: its terminal, files, checkpoints; they can fork it, never delete it",
+    "airgate share <pod> <port>  a public link to that port: anyone with the link can open it"
+  ],
   flags: { off: { type: "boolean", help: "stop sharing: private to you again" } },
   async run(ctx) {
+    if (ctx.args.positionals.length === 1) {
+      const p2 = await resolvePod(ctx, ctx.args.positionals[0]);
+      const off2 = bool(ctx.args, "off");
+      const out = await ctx.api.sharePod(p2.id, !off2);
+      if (ctx.json) return ctx.ui.json(out);
+      return void ctx.ui.out(off2 ? `${p2.spec.name} is private again.` : `${p2.spec.name} is shared with your team: they see it in airgate pods and can attach (you all share one terminal).`);
+    }
     const { pod, port } = await podAndPort(ctx);
     const off = bool(ctx.args, "off");
     const p = await ctx.api.ensurePreview(pod.id, { port, public: !off });
@@ -10217,7 +10894,7 @@ var checkpoints = {
   summary: "the pod's undo timeline, newest first",
   example: "airgate checkpoints fix-nav",
   async run(ctx) {
-    const p = await resolvePod(ctx, ctx.args.positionals[0]);
+    const p = await resolvePod(ctx, ctx.args.positionals[0], { team: true });
     const cps = newestFirst(await ctx.api.checkpoints(p.id));
     if (ctx.json) return ctx.ui.json(cps);
     if (!cps.length) {
@@ -10280,7 +10957,7 @@ var race = {
   },
   async run(ctx) {
     const [ref, cpRef = "current"] = ctx.args.positionals;
-    const p = await resolvePod(ctx, ref);
+    const p = await resolvePod(ctx, ref, { team: true });
     const checkpointId2 = cpRef === "current" ? "current" : resolveCheckpoint(await ctx.api.checkpoints(p.id), cpRef).id;
     const overrides = {};
     const agent = str(ctx.args, "agent");
@@ -11725,18 +12402,18 @@ function startTui(d) {
     d.stdout.write(LEAVE_ALT + `\x1B[2m attached to ${name}. ctrl-] comes back to airgate.\x1B[0m\r
 `);
     const { cols, rows: rows2 } = size2();
-    let note = `back from ${name}. the session keeps running.`;
+    let note2 = `back from ${name}. the session keeps running.`;
     let tone2 = "ok";
     try {
       const ws = d.websocket(d.api.terminalUrl(podId, cols, rows2));
       const end = await attachSession({ stdin: d.stdin, stdout: d.stdout, ws, signals: d.signals });
-      if (end.reason === "exit") note = `${name}: session ended (exit ${end.code})`;
+      if (end.reason === "exit") note2 = `${name}: session ended (exit ${end.code})`;
       else if (end.reason === "error" || end.reason === "closed" && end.code !== 1e3) {
-        note = `${name}: terminal ${end.reason === "error" ? end.message : "closed"}`;
+        note2 = `${name}: terminal ${end.reason === "error" ? end.message : "closed"}`;
         tone2 = "bad";
       }
     } catch (e) {
-      note = `couldn't attach: ${errText(e)}`;
+      note2 = `couldn't attach: ${errText(e)}`;
       tone2 = "bad";
     }
     if (finished) return;
@@ -11744,7 +12421,7 @@ function startTui(d) {
     shown2 = [];
     d.stdout.write(ENTER_ALT);
     listenKeys(true);
-    dispatch(tone2 === "ok" ? { type: "done", text: note } : { type: "failed", text: note });
+    dispatch(tone2 === "ok" ? { type: "done", text: note2 } : { type: "failed", text: note2 });
   }
   async function stream() {
     for (let attempt = 0; !controller.signal.aborted; attempt++) {
@@ -11852,8 +12529,8 @@ var ui = {
 };
 
 // src/commands/workspace.ts
-import { writeFileSync as writeFileSync8, existsSync as existsSync7, statSync as statSync5 } from "node:fs";
-import { basename as basename3, resolve as resolve7 } from "node:path";
+import { writeFileSync as writeFileSync9, existsSync as existsSync7, statSync as statSync5 } from "node:fs";
+import { basename as basename3, resolve as resolve8 } from "node:path";
 async function checkpointId(ctx, podId, ref) {
   if (!ref || ref === "current") return void 0;
   return resolveCheckpoint(await ctx.api.checkpoints(podId), ref).id;
@@ -11870,7 +12547,7 @@ var files = {
   async run(ctx) {
     const [ref, path = ""] = ctx.args.positionals;
     if (!ref) throw new UsageError("which pod? airgate files <pod> [path]");
-    const pod = await resolvePod(ctx, ref);
+    const pod = await resolvePod(ctx, ref, { team: true });
     const at3 = await checkpointId(ctx, pod.id, str(ctx.args, "at"));
     const r = await ctx.api.files(pod.id, path, at3);
     if (ctx.json) return ctx.ui.json(r);
@@ -11896,21 +12573,21 @@ var pull = {
   async run(ctx) {
     const [ref, path] = ctx.args.positionals;
     if (!ref || !path) throw new UsageError("airgate pull <pod> <path>");
-    const pod = await resolvePod(ctx, ref);
+    const pod = await resolvePod(ctx, ref, { team: true });
     const at3 = await checkpointId(ctx, pod.id, str(ctx.args, "at"));
     const body = await ctx.ui.spin(`reading ${path}`, ctx.api.fileRaw(pod.id, path, at3));
     const out = str(ctx.args, "out") ?? basename3(path);
     if (out === "-") return void ctx.io.stdout.write(body);
-    const dest = resolve7(ctx.io.cwd, out);
+    const dest = resolve8(ctx.io.cwd, out);
     if (existsSync7(dest) && !bool(ctx.args, "force")) {
-      if (statSync5(dest).isDirectory()) return void save2(ctx, resolve7(dest, basename3(path)), body);
+      if (statSync5(dest).isDirectory()) return void save2(ctx, resolve8(dest, basename3(path)), body);
       throw new CliError(`${out} exists here`, "pick another name with -o, or --force to overwrite");
     }
     save2(ctx, dest, body);
   }
 };
 function save2(ctx, dest, body) {
-  writeFileSync8(dest, body);
+  writeFileSync9(dest, body);
   if (ctx.json) return ctx.ui.json({ saved: dest, bytes: body.length });
   ctx.ui.out(`${ctx.ui.c("ok", "saved")} ${dest} (${bytes(body.length)})`);
 }
@@ -12040,6 +12717,9 @@ var COMMANDS = [
   forgot,
   reset,
   deleteAccount,
+  verify,
+  bug,
+  team,
   github,
   pods,
   launch,
@@ -12073,6 +12753,9 @@ var COMMANDS = [
   models,
   relay,
   crew,
+  handover,
+  recall,
+  note,
   files,
   pull,
   snapshot2,
@@ -12172,6 +12855,10 @@ function report(ui2, err, cmd, env) {
       line2(err.message.charAt(0).toLowerCase() + err.message.slice(1), "see what this gateway offers: airgate templates");
       return 1;
     }
+    if (err.code === "team_plan_required" || err.code === "no_seat") {
+      line2(err.message.charAt(0).toLowerCase() + err.message.slice(1), err.code === "no_seat" ? "add one: airgate team seats <n>" : "the owner starts it: airgate team upgrade --seats <n>");
+      return 1;
+    }
     if (err.status === 402 || err.code === "billing_required") {
       line2(`${err.message}`);
       const p = PLANS;