@cohortapp/agent-sdk 2.5.1 → 2.6.1

package/lib/org/tool-surface.test.mjs

@@ -24,7 +24,7 @@ import {
   executeOrgTool,
   DEFAULT_COHORT_BASE,
 } from "./tool-surface.mjs";
-import { methodDef, PROTOCOL_VERSION } from "./protocol.mjs";
+import { methodDef, PROTOCOL_VERSION, READS } from "./protocol.mjs";
 
 // ── env hygiene ────────────────────────────────────────────────────────────
 const ENV_KEYS = [
@@ -59,13 +59,32 @@ function fakeFetch(body = { ok: true, result: { fine: true } }, { status = 200,
 
 // ── table shape ────────────────────────────────────────────────────────────
 
-test("table: curated 29 + 5 email + 5 artifact + 69 desk tools, snake_case names, valid access + schemas", () => {
+test("table: curated 43 + 5 email + 5 artifact + 69 desk tools, snake_case names, valid access + schemas", () => {
   // 2026-08 mobile-parity delta: +5 mail (report_spam/react/move_mailbox/
   // summarise/ask) and +3 asks (files/calendar/crm) → desk 56 → 64; the
   // call-working-sessions delta adds the 5 calls-desk tools → 69.
   // The wire-contract fix adds task_assign: hq's editTaskSchema (board.updateTask)
   // has NO assignee field, so reassignment needs board.assignTask — curated 28 → 29.
-  assert.equal(ORG_TOOLS.length, 108, "29 curated + 5 email + 5 artifact + 69 desk");
+  // The conversation-parity delta adds the per-message actions the human
+  // long-press sheet ships (react/bookmark/delete/mark_unread_from) and the two
+  // huddle verbs the share tools presuppose (start/join) — curated 29 → 35.
+  // They are ALWAYS-ON, not desk-gated: the base messaging/channel/calling
+  // families have been vendored since SP3.
+  // The macro-parity delta adds org_pulse (GET ops?pulse=1 — the founder's
+  // attention surface, previously human-only), org_huddle_end (which closes the
+  // loop org_huddle_start opened) and memory_recall — hq built memory.recall
+  // explicitly because "an SDK-driven seat has been reasoning off a strictly
+  // smaller memory than the chat lane", then shipped no tool for it, so the
+  // reverse-parity fix never reached the plane it was built for.
+  // Curated 35 → 38.
+  // The ENGAGEMENT delta adds the four verbs an SDK seat needs to bring somebody
+  // in and had no binding for, despite all four sitting in the frozen protocol
+  // table since it was written: messaging_open_group (channel.createConversation),
+  // messaging_create_channel (channel.create), messaging_add_to_channel
+  // (channel.addMember), and engage_colleagues — the judged path that decides
+  // WHETHER anyone needs involving before it opens anything at all.
+  // Curated 38 → 42, +1 for work_track → 43.
+  assert.equal(ORG_TOOLS.length, 122, "43 curated + 5 email + 5 artifact + 69 desk");
   assert.equal(ORG_TOOLS.filter((t) => t.desk).length, 69, "exactly sixty-nine desk tools");
   assert.equal(ORG_TOOLS.filter((t) => t.email).length, 5, "exactly five email tools");
   assert.equal(ORG_TOOLS.filter((t) => t.artifact).length, 5, "exactly five artifact tools");
@@ -78,6 +97,21 @@ test("table: curated 29 + 5 email + 5 artifact + 69 desk tools, snake_case names
     if (t.binding.kind === "rpc") {
       assert.ok(methodDef(t.binding.method), `${t.name} binds a real protocol method (${t.binding.method})`);
     }
+    // The rpc side was already pinned to the frozen table; the READ side was
+    // not, so a curated tool could name a read path the server does not serve
+    // and only fail at runtime, as a bare 404 the model cannot interpret.
+    if (t.binding.kind === "read") {
+      assert.ok(
+        Object.prototype.hasOwnProperty.call(READS, t.binding.path),
+        `${t.name} binds a real protocol read (${t.binding.path})`,
+      );
+      if (t.binding.query !== undefined) {
+        assert.equal(typeof t.binding.query, "object", `${t.name} binding.query is an object`);
+        for (const [k, v] of Object.entries(t.binding.query)) {
+          assert.equal(typeof v, "string", `${t.name} binding.query.${k} is a string`);
+        }
+      }
+    }
   }
 });
 
@@ -90,19 +124,19 @@ test("OUTBOUND_METHODS is DERIVED from outbound:true tools (messaging/email/mail
 test("email gating: family present in the vendored protocol → tools active; override excludes", () => {
   // The email family landed in the vendored protocol (sync-protocol phase 1).
   assert.equal(emailFamilyAvailable(), true, "vendored protocol carries email.send");
-  assert.equal(getOrgTools().length, 108);
+  assert.equal(getOrgTools().length, 122);
   const without = getOrgTools({ emailAvailable: false });
-  assert.equal(without.length, 103);
+  assert.equal(without.length, 117);
   assert.ok(!without.some((t) => t.email), "email tools excluded when family absent");
 });
 
 test("artifact gating: family present → tools active; override excludes (email precedent)", () => {
   assert.equal(artifactFamilyAvailable(), true, "vendored protocol carries artifact.act");
   const without = getOrgTools({ artifactAvailable: false });
-  assert.equal(without.length, 103);
+  assert.equal(without.length, 117);
   assert.ok(!without.some((t) => t.artifact), "artifact tools excluded when family absent");
   const neither = getOrgTools({ emailAvailable: false, artifactAvailable: false, desksAvailable: false });
-  assert.equal(neither.length, 29, "all additive families off → the 29 always-on tools");
+  assert.equal(neither.length, 43, "all additive families off → the 43 always-on tools");
 });
 
 test("isOrgTool / orgToolDef cover the full table; unknown names rejected", () => {
@@ -188,6 +222,110 @@ test("read binding: board_ready GETs /api/v1/board.ready and normalises the bare
   assert.match(fetchImpl.calls[0].url, /\/api\/v1\/board\.ready$/);
 });
 
+// ── macro pulse (the founder's attention surface, previously human-only) ────
+
+test("org_pulse: the binding PINS ?pulse=1 — the agent never has to know the param", async () => {
+  const fetchImpl = fakeFetch({
+    chainHead: { seq: 42, rowHash: "abc" },
+    members: 9,
+    openAlerts: 2,
+    readyTasks: 5,
+    pulse: {
+      stats: { agentsRunning: 3, blocked: 1, decisionsToday: 2, needs: 2 },
+      needs: [{ id: "esc_1", severity: "high", what: "Blocked on pricing" }],
+      activity: [{ id: "ev_0", sentence: "Assigned a card in Growth" }],
+    },
+  });
+  const frame = await executeOrgTool("org_pulse", {}, { orgConfig: CFG, agentRoot: "/tmp/none", fetchImpl });
+  assert.equal(frame.ok, true);
+  assert.equal(fetchImpl.calls[0].init.method, "GET");
+  // Without a pinned query this GETs the bare probe and the pulse is null — the
+  // whole capability turns on this one param riding the binding.
+  assert.match(fetchImpl.calls[0].url, /\/api\/v1\/ops\?pulse=1$/);
+  assert.equal(frame.result.pulse.stats.blocked, 1);
+  assert.equal(frame.result.pulse.needs[0].severity, "high");
+});
+
+test("org_pulse is reachable at the READ tier — not another admin-only escape hatch", () => {
+  const pulse = orgToolDef("org_pulse");
+  assert.equal(pulse.access, "read", "an ordinary agent must be able to ask what needs attention");
+  assert.equal(pulse.desk, undefined, "always-on: `ops` has been in READS since the first protocol");
+  // The failure mode the description must pre-empt: reporting "nothing needs
+  // attention" when the derivation actually failed.
+  assert.match(pulse.description, /pulse: null/);
+  assert.match(pulse.description, /do not report zero/);
+});
+
+test("huddle lifecycle is CLOSED: a room an agent can open is a room it can enter and shut", async () => {
+  const names = ORG_TOOLS.filter((t) => t.name.startsWith("org_huddle_")).map((t) => t.name).sort();
+  assert.deepEqual(names, ["org_huddle_end", "org_huddle_join", "org_huddle_start"]);
+  for (const n of names) {
+    const def = orgToolDef(n);
+    assert.equal(def.desk, undefined, `${n} is always-on (the base calling family predates the desks)`);
+    assert.equal(def.access, "write");
+    assert.ok(def.binding.method.startsWith("calling."), `${n} rides the calling family`);
+  }
+  const fetchImpl = fakeFetch({ ok: true, result: { callId: "call_1", endedAt: "2026-08-12T10:00:00.000Z" } });
+  const frame = await executeOrgTool("org_huddle_end", { callId: "call_1" }, { orgConfig: CFG, agentRoot: "/tmp/none", fetchImpl });
+  assert.equal(frame.ok, true);
+  assert.equal(fetchImpl.calls[0].url, "https://org.example/api/v1/calling.end");
+  assert.deepEqual(JSON.parse(fetchImpl.calls[0].init.body), { callId: "call_1" });
+  // CONFLICT means "already closed", not "you failed" — the description must
+  // say so, or a model retries a call it successfully ended.
+  assert.match(orgToolDef("org_huddle_end").description, /CONFLICT/);
+});
+
+test("org_directory advertises the derived presence lane (a field nobody is told about is unreachable)", () => {
+  const dir = orgToolDef("org_directory");
+  for (const needle of ["presence", "lane", "detail", "indisposed"]) {
+    assert.match(dir.description, new RegExp(needle), `org_directory names ${needle}`);
+  }
+  // The two honest-reading rules: a human seat's null is not "offline", and the
+  // raw client-stamped `status.ts` is not the dot.
+  assert.match(dir.description, /presence: null/);
+  assert.match(dir.description, /client-stamped/);
+});
+
+test("memory_recall: the SDK seat gets the same memory the chat lane reasons off", async () => {
+  const recall = orgToolDef("memory_recall");
+  assert.equal(recall.access, "read", "recall is read-only — it must not need a write tier");
+  assert.equal(recall.binding.method, "memory.recall");
+  // knowledge.search is a NARROWED PROJECTION of the same index; if the model is
+  // not told that, it keeps reaching for the smaller one out of habit.
+  assert.match(orgToolDef("knowledge_search").description, /memory_recall/);
+  // The two contracts a model gets wrong without being told: the entity pin is
+  // a PAIR, and an empty index is a fact, not a failure to retry.
+  assert.match(recall.description, /TOGETHER/);
+  assert.match(recall.description, /found:false/);
+
+  const fetchImpl = fakeFetch({ ok: true, result: { found: true, items: [{ id: "m1" }] } });
+  const frame = await executeOrgTool(
+    "memory_recall",
+    { query: "what did we decide about pricing", scope: "self", depth: "specific", k: 5 },
+    { orgConfig: CFG, agentRoot: "/tmp/none", fetchImpl },
+  );
+  assert.equal(frame.ok, true);
+  assert.equal(fetchImpl.calls[0].url, "https://org.example/api/v1/memory.recall");
+  assert.deepEqual(JSON.parse(fetchImpl.calls[0].init.body), {
+    query: "what did we decide about pricing", scope: "self", depth: "specific", k: 5,
+  });
+  // A read carries no dispatcher idempotency key.
+  assert.equal(fetchImpl.calls[0].init.headers["x-idempotency-key"], undefined);
+});
+
+test("email_triage exposes every facet the server accepts (mark-unread-from, muted, done)", () => {
+  const triage = orgToolDef("email_triage");
+  const props = Object.keys(triage.input_schema.properties).sort();
+  assert.deepEqual(props, [
+    "assigneeMemberId", "category", "done", "muted", "priority",
+    "read", "starred", "tags", "threadId", "unreadFromMessageId",
+  ], "the schema matches email.triage's real param set — an undocumented param is an unreachable one");
+  // The exclusivity rules are the server's; a model that does not know them
+  // burns a turn on a BAD_REQUEST it cannot diagnose.
+  assert.match(triage.description, /mutually exclusive/);
+  assert.match(triage.description, /one-verb-per-call/);
+});
+
 test("org_events_tail: cursor + clamped limit ride the query string", async () => {
   const fetchImpl = fakeFetch({ events: [] });
   await executeOrgTool("org_events_tail", { cursor: 7, limit: 9999 }, { orgConfig: CFG, agentRoot: "/tmp/none", fetchImpl });
@@ -592,3 +730,49 @@ test("org_whoami: COHORT_AGENT_ID hint routes to the direct member GET", async (
   assert.equal(frame.ok, true);
   assert.match(fetchImpl.calls[0].url, /\/api\/v1\/org\/members\/astra\?orgId=acme/);
 });
+
+// ── engage_colleagues: the judged path through the tool plane ──────────────
+
+test("engage_colleagues returns an OK frame when it decides NOBODY needs involving", async () => {
+  // "Nobody needed involving" is an answer. Returning it as an error would teach
+  // the model to retry until it manages to interrupt somebody.
+  const f = fakeFetch({ ok: true, result: { members: [] } });
+  const res = await executeOrgTool(
+    "engage_colleagues",
+    { id: "W-1", title: "Refresh the digest", state: "in_progress", interestedParties: ["M-2"] },
+    { orgConfig: CFG, agentRoot: "/tmp/engage-tool-test", fetchImpl: f, env: {} },
+  );
+  assert.equal(res.ok, true);
+  assert.equal(res.result.engaged, false);
+  assert.equal(res.result.reasonCode, "self_contained");
+  assert.deepEqual(res.result.consideredNotEngaged, ["M-2"]);
+  assert.ok(res.result.why.length, "the reasoning comes back to the model, not just the verdict");
+  assert.ok(
+    !f.calls.some((c) => /messaging\.send/.test(c.url)),
+    "a self-contained decision must not put a message on the wire",
+  );
+});
+
+test("engage_colleagues refuses an unidentified piece of work rather than guessing", async () => {
+  const res = await executeOrgTool(
+    "engage_colleagues",
+    { title: "no id" },
+    { orgConfig: CFG, agentRoot: "/tmp/engage-tool-test", fetchImpl: fakeFetch(), env: {} },
+  );
+  assert.equal(res.ok, false);
+  assert.equal(res.error.code, "BAD_REQUEST");
+});
+
+test("messaging_send passes mentions straight through to the wire", async () => {
+  const f = fakeFetch({ ok: true, result: { id: "m1" } });
+  await executeOrgTool(
+    "messaging_send",
+    { channelId: "C-1", body: "Need a decision here.", mentions: ["M-2"] },
+    { orgConfig: CFG, agentRoot: "/tmp", fetchImpl: f, env: {}, screenImpl: async () => ({ allow: true }) },
+  );
+  const body = JSON.parse(f.calls[0].init.body);
+  // The model writes the obvious thing — an array of id strings — and the param
+  // contract coerces it at the one chokepoint. Sending the string form verbatim
+  // fails hq's zod and 400s the WHOLE message, tags and body alike.
+  assert.deepEqual(body.mentions, [{ memberId: "M-2" }]);
+});

package/lib/org/ui-parity.mjs

@@ -1,12 +1,40 @@
 /**
  * lib/org/ui-parity.mjs — Agent UI-parity helpers (full human-action mirror).
  *
- * A 1:1 mirror of the human Cohort UI: 328 named convenience wrappers over the
- * /v1 RPC binding, one per agent-facing org method the human app exposes (charter,
- * member, team, channel, persona, profile, sop, escalation, annotation, contact,
- * file, memory, compact, notification, decision, messaging, board, invitation,
- * user, settings, billing, org, integration, email + the Inbox app, artifact, and
- * the agent desks: books, calendar, crm, directory, files, meetings.recapFile).
+ * A 1:1 mirror of the human Cohort UI: 359 named convenience wrappers over the
+ * /v1 RPC binding, one per method behind a HUMAN SURFACE — the things a person
+ * can do by clicking (charter, member, team, channel, persona, profile, sop,
+ * escalation, annotation, contact, file, memory, compact, notification,
+ * decision, messaging, calling, board, invitation, user, settings, billing, org,
+ * integration, email + the Inbox app, artifact, and the agent desks: books,
+ * calendar, crm, directory, files, meetings.recapFile).
+ *
+ * "ONE PER HUMAN SURFACE", NOT "one per method in the family" — and the
+ * difference is load-bearing, because the flat family list above reads like the
+ * stronger claim. Six families are deliberately PARTIAL, because part of the
+ * family is not a human surface at all:
+ *
+ *   board        — the human kanban is mirrored whole (workstreams, tasks,
+ *                  comments, attachments). The AGENT WORK KERNEL that has no
+ *                  human control (create/claim/heartbeat/complete/block/comment/
+ *                  decompose/assign/link/requestReview/resolveReview) is the
+ *                  daemon's own loop and lives in the curated tool table.
+ *   decision     — the human ledger acts (comment/sign/reverse/requestAdjustment/
+ *                  listComments). propose/adopt/supersede are the §0.4
+ *                  control-plane acts; adopt + supersede are governance-gated.
+ *   escalation   — create/resolve/list (the escalation strip). ask/answer author
+ *                  and resolve an `OpenQuestion`, a different artifact.
+ *   memory       — the Cortex authoring lifecycle. `memory.recall` is semantic
+ *                  retrieval, exposed as the `memory_recall` curated tool.
+ *   integration  — connect/disconnect/list (the settings pane). toolsetVersion/
+ *                  listAgentTools/invokeTool are the runtime toolset plane a
+ *                  daemon polls, not a pane anyone clicks.
+ *   meetings     — recapFile (the desk verb). `meetings.record` is the knowledge
+ *                  plane's writer.
+ *
+ * `ui-parity.test.mjs` pins that list as a SELF-CLEANING ledger: an unlisted
+ * unwrapped method fails the build, and a listed one that later gets a wrapper
+ * forces its line out. So the docblock cannot quietly become aspirational again.
  * The `branding.*` (product section: Design) wrappers live in ./client.mjs beside
  * the rest of that family, not here. Every wrapper is a thin one-liner over
  * `call()` from ./client.mjs, so they inherit the SAME contract:
@@ -3234,3 +3262,302 @@ export function directoryRemoveFromList(params, o = {}) {
 export function directoryShareList(params, o = {}) {
   return call("directory.shareList", params || {}, o);
 }
+
+// ---------------------------------------------------------------------------
+// messaging (the rest) + calling — the conversation surfaces the human app
+// ships and this module previously did not mirror.
+//
+// This file's contract is "one wrapper per agent-facing org method the human
+// app exposes". Two families were exempt from it by accident rather than by
+// policy: `messaging` carried 6 of its 15 methods (the pin/bookmark/schedule/
+// delete half) and `calling` carried NONE of its 22, so the headphones huddle
+// control, the calendar Join, host mute/lock/remove, hand-raising and call
+// reactions had no named counterpart here at all. Both are ordinary
+// messaging.write / calling.write scope — nothing about them was privileged.
+// ---------------------------------------------------------------------------
+
+/**
+ * Post a message into a channel or DM (messaging.send). Idempotent — pass a stable `o.idempotencyKey`.
+ * @param {object} params - { channelId, body, parentId?, clientMsgId? }
+ * @param {object} o - { base, token, idempotencyKey?, fetchImpl? }
+ */
+export function messagingSend(params, o = {}) {
+  return call("messaging.send", params || {}, o);
+}
+
+/**
+ * A channel's message history, newest-first (messaging.history). READ-ONLY.
+ * @param {object} params - { channelId, limit?, before? }
+ * @param {object} o - { base, token, fetchImpl? }
+ */
+export function messagingHistory(params, o = {}) {
+  return call("messaging.history", params || {}, o);
+}
+
+/**
+ * Full-text search across the channels this seat can see (messaging.search). READ-ONLY.
+ * @param {object} params - { q, channelId?, limit? }
+ * @param {object} o - { base, token, fetchImpl? }
+ */
+export function messagingSearch(params, o = {}) {
+  return call("messaging.search", params || {}, o);
+}
+
+/**
+ * The channels this seat can see (messaging.channels). READ-ONLY.
+ * @param {object} params - { kind?, limit? }
+ * @param {object} o - { base, token, fetchImpl? }
+ */
+export function messagingChannels(params, o = {}) {
+  return call("messaging.channels", params || {}, o);
+}
+
+/**
+ * Raise/clear the "is composing" indicator (messaging.typing). Writes NOTHING — no
+ * row and no chain event; it is the one `/v1` method with no durable effect.
+ * @param {object} params - { channelId, state? }
+ * @param {object} o - { base, token, fetchImpl? }
+ */
+export function messagingTyping(params, o = {}) {
+  return call("messaging.typing", params || {}, o);
+}
+
+/**
+ * Add or remove YOUR reaction on a message (messaging.react). `op:add` upserts,
+ * `op:remove` deletes; both are no-ops when already in that state.
+ * @param {object} params - { messageId, emoji, op? }
+ * @param {object} o - { base, token, fetchImpl? }
+ */
+export function messagingReact(params, o = {}) {
+  return call("messaging.react", params || {}, o);
+}
+
+/**
+ * Edit a message you authored (messaging.edit; REDACTED audit — never the body).
+ * @param {object} params - { messageId, body }
+ * @param {object} o - { base, token, fetchImpl? }
+ */
+export function messagingEdit(params, o = {}) {
+  return call("messaging.edit", params || {}, o);
+}
+
+/**
+ * Post a poll into a channel (messaging.createPoll). Idempotent — pass a stable `o.idempotencyKey`.
+ * @param {object} params - { channelId, question, options[] }
+ * @param {object} o - { base, token, idempotencyKey?, fetchImpl? }
+ */
+export function messagingCreatePoll(params, o = {}) {
+  return call("messaging.createPoll", params || {}, o);
+}
+
+/**
+ * Cast/change your vote on a poll (messaging.votePoll). Idempotent — pass a stable `o.idempotencyKey`.
+ * @param {object} params - { pollId, optionIds[] }
+ * @param {object} o - { base, token, idempotencyKey?, fetchImpl? }
+ */
+export function messagingVotePoll(params, o = {}) {
+  return call("messaging.votePoll", params || {}, o);
+}
+
+/**
+ * Open a huddle/call (calling.start) — anchored to a channel (the starter must
+ * belong to it) or direct to `participantIds`. The server mints the LiveKit room
+ * and returns a room+identity-scoped join token; the caller NEVER supplies one.
+ * @param {object} params - { kind?, channelId?, participantIds? }
+ * @param {object} o - { base, token, fetchImpl? }
+ */
+export function callingStart(params, o = {}) {
+  return call("calling.start", params || {}, o);
+}
+
+/**
+ * Join a live call (calling.join). Refused when the host has LOCKED the floor,
+ * when you were removed, or when the call has ended.
+ * @param {object} params - { callId, audioOnly? }
+ * @param {object} o - { base, token, fetchImpl? }
+ */
+export function callingJoin(params, o = {}) {
+  return call("calling.join", params || {}, o);
+}
+
+/**
+ * End a call for everyone (calling.end).
+ * @param {object} params - { callId }
+ * @param {object} o - { base, token, fetchImpl? }
+ */
+export function callingEnd(params, o = {}) {
+  return call("calling.end", params || {}, o);
+}
+
+/**
+ * Invite members into a live call (calling.invite). Clears a prior removal.
+ * @param {object} params - { callId, memberIds, message? }
+ * @param {object} o - { base, token, fetchImpl? }
+ */
+export function callingInvite(params, o = {}) {
+  return call("calling.invite", params || {}, o);
+}
+
+/**
+ * Send an ephemeral in-call reaction (calling.react).
+ * @param {object} params - { callId, emoji }
+ * @param {object} o - { base, token, fetchImpl? }
+ */
+export function callingReact(params, o = {}) {
+  return call("calling.react", params || {}, o);
+}
+
+/**
+ * Raise your hand in a call (calling.raiseHand).
+ * @param {object} params - { callId }
+ * @param {object} o - { base, token, fetchImpl? }
+ */
+export function callingRaiseHand(params, o = {}) {
+  return call("calling.raiseHand", params || {}, o);
+}
+
+/**
+ * Lower your (or, as host, another participant's) hand (calling.lowerHand).
+ * @param {object} params - { callId, memberId? }
+ * @param {object} o - { base, token, fetchImpl? }
+ */
+export function callingLowerHand(params, o = {}) {
+  return call("calling.lowerHand", params || {}, o);
+}
+
+/**
+ * Mute/unmute yourself, or (as host) another participant (calling.setMute).
+ * @param {object} params - { callId, memberId?, muted }
+ * @param {object} o - { base, token, fetchImpl? }
+ */
+export function callingSetMute(params, o = {}) {
+  return call("calling.setMute", params || {}, o);
+}
+
+/**
+ * Lock/unlock the call floor (calling.setLock). A LOCKED floor refuses NEW joins;
+ * existing participants and reconnects are unaffected.
+ * @param {object} params - { callId, locked }
+ * @param {object} o - { base, token, fetchImpl? }
+ */
+export function callingSetLock(params, o = {}) {
+  return call("calling.setLock", params || {}, o);
+}
+
+/**
+ * Remove a participant from a call, host-only (calling.removeParticipant).
+ * @param {object} params - { callId, memberId }
+ * @param {object} o - { base, token, fetchImpl? }
+ */
+export function callingRemoveParticipant(params, o = {}) {
+  return call("calling.removeParticipant", params || {}, o);
+}
+
+/**
+ * Start recording a call (calling.recordingStart).
+ * @param {object} params - { callId }
+ * @param {object} o - { base, token, fetchImpl? }
+ */
+export function callingRecordingStart(params, o = {}) {
+  return call("calling.recordingStart", params || {}, o);
+}
+
+/**
+ * Stop recording a call (calling.recordingStop).
+ * @param {object} params - { callId }
+ * @param {object} o - { base, token, fetchImpl? }
+ */
+export function callingRecordingStop(params, o = {}) {
+  return call("calling.recordingStop", params || {}, o);
+}
+
+/**
+ * Append one transcript line to a live call (calling.addTranscriptLine).
+ * @param {object} params - { callId, at, text, speakerMemberId?, name? }
+ * @param {object} o - { base, token, fetchImpl? }
+ */
+export function callingAddTranscriptLine(params, o = {}) {
+  return call("calling.addTranscriptLine", params || {}, o);
+}
+
+/**
+ * Post a message into the in-call chat (calling.chat).
+ * @param {object} params - { callId, body }
+ * @param {object} o - { base, token, fetchImpl? }
+ */
+export function callingChat(params, o = {}) {
+  return call("calling.chat", params || {}, o);
+}
+
+/**
+ * A call's details + participant roster (calling.getDetails). READ-ONLY.
+ * @param {object} params - { callId }
+ * @param {object} o - { base, token, fetchImpl? }
+ */
+export function callingGetDetails(params, o = {}) {
+  return call("calling.getDetails", params || {}, o);
+}
+
+/**
+ * A call's transcript (calling.getTranscript). READ-ONLY.
+ * @param {object} params - { callId }
+ * @param {object} o - { base, token, fetchImpl? }
+ */
+export function callingGetTranscript(params, o = {}) {
+  return call("calling.getTranscript", params || {}, o);
+}
+
+/**
+ * Start presenting a Cohort surface on a call's stage (calling.appShareStart).
+ * @param {object} params - { callId, surface{ kind, ref, title? } }
+ * @param {object} o - { base, token, fetchImpl? }
+ */
+export function callingAppShareStart(params, o = {}) {
+  return call("calling.appShareStart", params || {}, o);
+}
+
+/**
+ * Drive an active share with a step batch (calling.appShareAct). The notes and
+ * typed text render on every participant's tile — screen them like any outbound.
+ * @param {object} params - { callId, sessionId, steps[] }
+ * @param {object} o - { base, token, fetchImpl? }
+ */
+export function callingAppShareAct(params, o = {}) {
+  return call("calling.appShareAct", params || {}, o);
+}
+
+/**
+ * End an active share (calling.appShareEnd).
+ * @param {object} params - { callId, sessionId }
+ * @param {object} o - { base, token, fetchImpl? }
+ */
+export function callingAppShareEnd(params, o = {}) {
+  return call("calling.appShareEnd", params || {}, o);
+}
+
+/**
+ * The call's current share session, if any (calling.getAppShare). READ-ONLY.
+ * @param {object} params - { callId }
+ * @param {object} o - { base, token, fetchImpl? }
+ */
+export function callingGetAppShare(params, o = {}) {
+  return call("calling.getAppShare", params || {}, o);
+}
+
+/**
+ * What is currently on the call's stage, for a joining agent (calling.getVisualContext). READ-ONLY.
+ * @param {object} params - { callId }
+ * @param {object} o - { base, token, fetchImpl? }
+ */
+export function callingGetVisualContext(params, o = {}) {
+  return call("calling.getVisualContext", params || {}, o);
+}
+
+/**
+ * The call's event stream — joins, shares, hands, reactions (calling.getCallEvents). READ-ONLY.
+ * @param {object} params - { callId, since? }
+ * @param {object} o - { base, token, fetchImpl? }
+ */
+export function callingGetCallEvents(params, o = {}) {
+  return call("calling.getCallEvents", params || {}, o);
+}