conduyt-mcp 4.105.4 → 4.105.6

package/README.md

@@ -2,7 +2,7 @@
 
 MCP server for [Conduyt CRM](https://conduyt.app) — expose your CRM as AI-accessible tools. Covers the core CRM surface (contacts, deals, pipelines, custom fields, automations, messaging, and more); use `conduyt_api_catalog` to discover the full set of 600+ REST endpoints.
 
-## 385 Tools
+## 392 Tools
 
 ### Discovery
 | Tool | Description |
@@ -258,6 +258,8 @@ The Mailchimp OAuth connect and callback are browser-only: connect Mailchimp in
 | `conduyt_react_chat_message` | React to a Team Chat message as the authenticated user/agent; an AI teammate passes `claimToken` (the turn prompt's reply claim token, plus `sourceMessageId` when it reacts to another message of the thread) and the reaction ENDS that turn (outcome reacted); 409 `reaction_stale_claim` / `turn_finished` write nothing |
 | `conduyt_stay_silent` | (#802) the turn prompt's stay_silent: ends an AI teammate's turn with no response (`POST /chat/agents/me/inbox/claim` action `silent` for the turn's `messageId`, generation and listener id read from `claimToken`); 409 `turn_finished` when it already replied or reacted |
 | `conduyt_get_chat_linked_record` | (#802) the turn prompt's linked_record: `GET /chat/channels/{id}/linked-record`, the channel's linked deal or contact as a read-only summary `{ kind, record }` under the caller's visibility; one 404 for not a member / no link / not visible |
+| `conduyt_get_chat_thread` | (#684, thread view on) `GET /chat/channels/{id}/messages/{messageId}/thread`: one thread by its ROOT, `{ root, replies (oldest first), total, earlierCount, hasEarlier, earlierCursor, aiReactions, replying }`; `limit` 1-50 (default 20, the latest page), `before` = `earlierCursor`; an AI teammate reads the thread it answers in with the turn prompt's Reply parent id |
+| `conduyt_list_chat_thread_files` | (#684, thread view on) `GET /chat/channels/{id}/messages/{messageId}/files`: the files shared in one thread, oldest first, `{ data, hasMore }` (200 per read) |
 | `conduyt_mark_chat_read` | Acknowledge read up to one message (`readUpTo` = message UUID; the marker only moves forward, an older or foreign message is a no-op; same one-retry membership bootstrap) |
 | `conduyt_get_chat_realtime_token` | `GET /realtime/token`: a signed Ably token request for the realtime pipe (`channelIds` up to 10, sent as repeated `channel=`); `{ enabled: false, reason }` when the account switch is off; returns `accountId` / `userId` |
 | `conduyt_get_chat_notifications` | `GET /chat/channels/{id}/notifications`: your level `{ level, isDefault, notify, updatedAt, membershipId, membershipSince, membershipSeq }` |
@@ -266,8 +268,21 @@ The Mailchimp OAuth connect and callback are browser-only: connect Mailchimp in
 
 `conduyt_list_chat_messages` also takes `afterSeq` (messages committed after that seq; once, a whole number, never with `cursor`) and every message carries `version` (a counter bumped on each update). `conduyt_get_chat_unread` rows carry `mentions`, `notify`, `updatedAt`, `membershipId` (null = no membership), `membershipSince`, `membershipSeq`, and the response `teamChatRealtime` and `membershipSeqHigh`; `conduyt_list_chat_channels` rows carry `mentionCount` and the same membership fields.
 
+The thread view (#684): `conduyt_list_chat_messages` takes `topLevel: true` (top-level messages with their reply chip `thread`, and the replies shown in the channel with `threadReply` `{ reason: aiFirstAnswer | alsoInChannel, root }`; never with `afterSeq`) and `conduyt_reply_chat_message` takes `alsoInChannel: true` ("Also send to #channel" on a person's reply). Both are sent only when true. They and the two thread tools work only while the workspace's switch is on (`conduyt_list_chat_channels` then carries `teamChatThreads: true`); while it is off each answers an error result with `code: team_chat_threads_off` and the sentence "The thread view is not switched on for this workspace (account setting teamChatThreads)." Against a server that predates the thread view: the two thread tools answer a 404 error result that says so, `topLevel` is reported as not applied (an error result, never a page of every reply), and an `alsoInChannel` reply is posted in the thread only, with a note saying so (never re-sent).
+
 AI teammate turns (#802, the app listener's #655 phase 1): a turn run through Codex (`conduyt agent listen --adapter codex`) carries the thread so far and, when the channel is linked, "This channel is linked to deal <id>" (read it with `conduyt_get_chat_linked_record`), and ends with exactly ONE of `conduyt_reply_chat_message` (with `idempotencyKey` + `claimToken`), `conduyt_react_chat_message` (with `claimToken`) or `conduyt_stay_silent`; a second, different one is refused 409 `turn_finished`. The inbox itself (`/chat/agents/me/*`: the event's `context.recent`, `channel.dealId` / `contactId` and the page's `budget`) is the listener's protocol and has no tool; `GET /chat/agents` (with each teammate's `turnsToday` / `dailyBudget`) is session-only, refused to every API key, so it has no tool either: the daily budget is visible in Settings > AI and in the listener's log.
 
+### A Grok Bot as an AI teammate (#1140)
+| Tool | Description |
+|------|-------------|
+| `conduyt_connect_ai_teammate` | Step 1 (`POST /chat/agents/{id}/connect`): the message to paste into Grok Bot and the teammate's token, returned ONCE (`{ token, tokenPrefix, message, toolsUrl, agent }`); the token goes into Grok Bot's masked connector field, never into a chat. Every call revokes the earlier tokens. The calling key needs the write tier and the chat and deals scopes |
+| `conduyt_set_ai_teammate_webhook` | Step 3 (`PUT /chat/agents/{id}/webhook`): `paste` (the block Grok Bot shows) OR `address` + `key`; checked, stored (the key encrypted), tested at once: `{ stored, test, status }`. The key is write-only: never returned, and any returned text has it replaced by `[hidden]`. A test that was not accepted is an error result with its one sentence (`key_refused`, `routine_gone`, `unreachable`, `not_accepted`, `rate_limited`; `teammate_not_live` is a 409 before any test) |
+| `conduyt_test_ai_teammate_webhook` | The card's Test button (`POST /chat/agents/{id}/webhook/test`): the hello again to the stored routine; `{ test, status }` |
+| `conduyt_get_ai_teammate_webhook` | The status the card polls (`GET /chat/agents/{id}/webhook`): `state` not_connected / waiting_for_hello / listening / not_listening, `problem { code, message }`, the address masked; poll it after a test until listening |
+| `conduyt_disconnect_ai_teammate` | `DELETE /chat/agents/{id}/webhook`: tokens revoked, the routine's key cleared, pending deliveries cancelled; the teammate and its messages stay; never blocked by billing |
+
+Owners and admins, with a person's API key; an AI teammate's own key is refused. The teammate is named by its id (a UUID): the teammate list is session-only, so an API key cannot look up a handle. Against a server without these routes (an HTML 404) each tool answers "This Conduyt server does not have the Grok Bot connection yet (it predates it); connect the teammate in Settings > AI instead."
+
 The remaining Team Chat mutations (edit/delete, pins, claim/handoff and typing/presence writes) are not wrapped yet; sends, thread replies, reactions and direct uploads are wrapped. `GET /chat/messages/{messageId}/location` is a UI deep-link helper and deliberately not wrapped. `GET /cron/team-chat-digest` is a CRON_SECRET-gated job and not key-callable.
 
 #### What the API publishes (realtime events, not tools)

package/dist/register-all.js

@@ -26,6 +26,7 @@ import { registerMailchimpTools } from "./tools/mailchimp.js";
 import { registerStatusMetadataTools } from "./tools/status-metadata.js";
 import { registerNotificationTools } from "./tools/notifications.js";
 import { registerChatTools } from "./tools/chat.js";
+import { registerAiTeammateConnectTools } from "./tools/ai-teammate-connect.js";
 import { registerCustomFieldTools } from "./tools/custom-fields.js";
 import { registerSmartListTools } from "./tools/smart-lists.js";
 import { registerUserTools } from "./tools/users.js";
@@ -90,6 +91,7 @@ export function registerAllTools(server, client) {
     registerStatusMetadataTools(server, client);
     registerNotificationTools(server, client);
     registerChatTools(server, client);
+    registerAiTeammateConnectTools(server, client);
     registerCustomFieldTools(server, client);
     registerSmartListTools(server, client);
     registerUserTools(server, client);

package/dist/tool-annotations.js

@@ -188,6 +188,16 @@ export const TOOL_ANNOTATIONS = {
     // (#802) ends an AI teammate's turn with outcome silent; a repeat on the claim it completed answers the same (like an acknowledgement)
     conduyt_stay_silent: update("Stay Silent on a Chat Turn"),
     conduyt_get_chat_linked_record: ro("Get Chat Linked Record"),
+    // (#684) the thread reads recover a first-use 403 through GET /chat/channels, which creates auto-channel memberships (as conduyt_list_chat_messages)
+    conduyt_get_chat_thread: update("Get Chat Thread"),
+    // (#1140 A3) the Grok Bot teammate connect tools: connect mints a token and revokes the earlier ones on every call; set stores the
+    // routine key (replacing the last) and sends a test each call; test sends one; disconnect revokes the tokens
+    conduyt_connect_ai_teammate: row("Connect AI Teammate", false, true, false),
+    conduyt_set_ai_teammate_webhook: row("Set AI Teammate Webhook", false, false, false),
+    conduyt_test_ai_teammate_webhook: create("Test AI Teammate Webhook"),
+    conduyt_get_ai_teammate_webhook: ro("Get AI Teammate Webhook"),
+    conduyt_disconnect_ai_teammate: destroy("Disconnect AI Teammate"),
+    conduyt_list_chat_thread_files: update("List Chat Thread Files"),
     conduyt_mark_chat_read: row("Mark Chat Read", false, false, false), // every call re-announces the read receipt to the reader's other tabs and devices, even when the marker did not move (chat/channels/[id]/messages/route.ts:126)
     conduyt_get_chat_realtime_token: ro("Get Chat Realtime Token"),
     conduyt_get_chat_notifications: update("Get Chat Notifications"),

package/dist/tools/ai-teammate-connect.d.ts

@@ -0,0 +1,26 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { ConduytApiError, ConduytClient } from "../client.js";
+export { hide } from "./routine-key-redaction.js";
+/**
+ * (#1140 lane A3) Connecting a Grok Bot routine as an AI teammate, the tri-surface twin of the Settings > AI card and of the CLI's
+ * `agent connect` / `agent webhook set|test|status` / `agent disconnect`. Built against conduyt-app lane A2b at 0c0088508
+ * (app/api/v1/chat/agents/[id]/connect, .../webhook, .../webhook/test; every sentence lives in lib/agent-webhook-connect.ts) and the
+ * concept page Cerebro domains/conduyt/wiki/concepts/grok-bot-teammate-webhook-and-remote-tools-2026-11-05.md (section S).
+ *
+ * The routine's key is WRITE-ONLY: it goes into the PUT body and nowhere else. The server never answers it, and every text these tools
+ * return (results and refusals) is passed through `hide`, which replaces it wherever it appears. Every refusal is an error result with
+ * ONE plain sentence: the server's own (the S.3 and input sentences are written for people) or ours where its text is not one (today's
+ * production answers these paths with an HTML 404; the switch answers "Not found").
+ */
+export declare const OLDER_SERVER_SENTENCE = "This Conduyt server does not have the Grok Bot connection yet (it predates it); connect the teammate in Settings > AI instead.";
+export declare const AI_OFF_SENTENCE = "AI teammates are switched off for this workspace; an owner or admin turns them on in Settings > AI.";
+export declare const NOT_FOUND_SENTENCE = "There is no AI teammate with that id in this workspace (it may have been revoked).";
+export declare const TEAMMATE_KEY_SENTENCE = "This is an AI teammate's own key; connect a Grok Bot with a person's API key (an owner or admin).";
+export declare const NO_CREDENTIALS_SENTENCE = "Give the routine's address and key: paste (the block Grok Bot shows), or address and key.";
+/** the one sentence for a refused call, and its code when the API sent one */
+export declare function refusalOf(err: ConduytApiError): {
+    status: number | null;
+    code: string | null;
+    sentence: string;
+};
+export declare function registerAiTeammateConnectTools(server: McpServer, client: ConduytClient): void;

package/dist/tools/ai-teammate-connect.js

@@ -0,0 +1,113 @@
+import { z } from "zod";
+import { ConduytApiError, formatToolError } from "../client.js";
+import { strictInput } from "./strict.js";
+import { hide, secretsInPaste, secretsOfKey } from "./routine-key-redaction.js";
+export { hide } from "./routine-key-redaction.js";
+/**
+ * (#1140 lane A3) Connecting a Grok Bot routine as an AI teammate, the tri-surface twin of the Settings > AI card and of the CLI's
+ * `agent connect` / `agent webhook set|test|status` / `agent disconnect`. Built against conduyt-app lane A2b at 0c0088508
+ * (app/api/v1/chat/agents/[id]/connect, .../webhook, .../webhook/test; every sentence lives in lib/agent-webhook-connect.ts) and the
+ * concept page Cerebro domains/conduyt/wiki/concepts/grok-bot-teammate-webhook-and-remote-tools-2026-11-05.md (section S).
+ *
+ * The routine's key is WRITE-ONLY: it goes into the PUT body and nowhere else. The server never answers it, and every text these tools
+ * return (results and refusals) is passed through `hide`, which replaces it wherever it appears. Every refusal is an error result with
+ * ONE plain sentence: the server's own (the S.3 and input sentences are written for people) or ours where its text is not one (today's
+ * production answers these paths with an HTML 404; the switch answers "Not found").
+ */
+export const OLDER_SERVER_SENTENCE = "This Conduyt server does not have the Grok Bot connection yet (it predates it); connect the teammate in Settings > AI instead.";
+export const AI_OFF_SENTENCE = "AI teammates are switched off for this workspace; an owner or admin turns them on in Settings > AI.";
+export const NOT_FOUND_SENTENCE = "There is no AI teammate with that id in this workspace (it may have been revoked).";
+export const TEAMMATE_KEY_SENTENCE = "This is an AI teammate's own key; connect a Grok Bot with a person's API key (an owner or admin).";
+export const NO_CREDENTIALS_SENTENCE = "Give the routine's address and key: paste (the block Grok Bot shows), or address and key.";
+function errorDetailsOf(message) {
+    for (let i = message.indexOf("{"); i !== -1; i = message.indexOf("{", i + 1)) {
+        try {
+            const v = JSON.parse(message.slice(i));
+            if (v && typeof v === "object" && !Array.isArray(v))
+                return v;
+        }
+        catch { /* not the details object */ }
+    }
+    return {};
+}
+/** the API's own error line (between "Conduyt API <status>: " and its Retry-After tag or details object) */
+function apiErrorText(message) {
+    const m = /^Conduyt API \d{3}: ([\s\S]*)$/.exec(message);
+    let t = m ? m[1] : message;
+    const brace = t.search(/ \[Retry-After: |\s\{/);
+    if (brace !== -1)
+        t = t.slice(0, brace);
+    return t.replace(/\s+/g, " ").trim();
+}
+/** the one sentence for a refused call, and its code when the API sent one */
+export function refusalOf(err) {
+    const details = errorDetailsOf(err.message);
+    const code = typeof details.code === "string" ? details.code : null;
+    const text = apiErrorText(err.message);
+    const status = err.status;
+    if (code === "ai_teammates_off")
+        return { status, code, sentence: AI_OFF_SENTENCE };
+    if (code === "agent_route_refused")
+        return { status, code, sentence: TEAMMATE_KEY_SENTENCE };
+    if (status === 404 && text === "Agent not found")
+        return { status, code, sentence: NOT_FOUND_SENTENCE };
+    // today's production: its HTML not-found page (404 text/html, before any auth); a 405: a route without this method
+    if (status === 404 || status === 405)
+        return { status, code, sentence: OLDER_SERVER_SENTENCE };
+    return { status, code, sentence: text.slice(0, 600) || `Conduyt answered ${status} without an explanation.` };
+}
+/** a structured, non-retried error result: { ok: false, status, code?, error: <one sentence>, ...extra } */
+function connectError(sentence, secrets, extra = {}) {
+    const base = formatToolError(hide(sentence, secrets));
+    return { ...base, content: [{ type: "text", text: hide(JSON.stringify({ ok: false, error: sentence, ...extra }, null, 2), secrets) }] };
+}
+/** a result whose text is redacted of the secrets */
+function connectResult(data, secrets) {
+    return { content: [{ type: "text", text: hide(JSON.stringify(data, null, 2), secrets) }] };
+}
+/** runs one call: an HTTP refusal becomes the one-sentence error result; any other failure is re-thrown with the secrets hidden */
+async function attempt(secrets, call, done) {
+    try {
+        return done(await call());
+    }
+    catch (err) {
+        if (err instanceof ConduytApiError && err.code === "http") {
+            const r = refusalOf(err);
+            return connectError(r.sentence, secrets, { status: r.status, ...(r.code ? { code: r.code } : {}) });
+        }
+        throw new Error(hide(err instanceof Error ? err.message : String(err), secrets));
+    }
+}
+const unwrap = (res) => (res && typeof res === "object" && "data" in res ? res.data : res);
+/** a test's answer: the data, or (the test was not accepted) an error result with the S.3 sentence and the whole answer beside it */
+function testOutcome(secrets) {
+    return (res) => {
+        const d = unwrap(res);
+        if (d?.test?.ok === true)
+            return connectResult(d, secrets);
+        const problem = d?.test?.problem;
+        return connectError(problem?.message ?? "Grok Bot did not accept the test.", secrets, { status: 200, ...(problem?.code ? { code: problem.code } : {}), answer: d });
+    };
+}
+const TEAMMATE_ID = z.string().uuid().describe("The Grok Bot teammate's id (a UUID: the agent.id of conduyt_connect_ai_teammate's answer, or the senderId of its messages). A handle cannot be looked up with an API key (the teammate list is session-only)");
+const WHO = "Owners and admins, with a person's API key (the chat scope); an AI teammate's own key is refused (403 agent_route_refused). The teammate must have the provider Grok Bot (409 agent_not_webhook_provider otherwise). Answers 404 ai_teammates_off while AI teammates are switched off and 402 plan_required when the workspace is not entitled. Against a server that predates these routes (an HTML 404) the error says so.";
+export function registerAiTeammateConnectTools(server, client) {
+    strictInput(server.tool("conduyt_connect_ai_teammate", `Step 1 of connecting a Grok Bot as an AI teammate (POST /api/v1/chat/agents/{id}/connect). Mints the teammate's token and returns it ONCE: { token, tokenPrefix, message, toolsUrl, agent }. Give the person the message to paste into Grok Bot and the token to paste into Grok Bot's masked connector field; NEVER post the token in Team Chat or any message, and never call this again just to read it: every call revokes the teammate's earlier tokens (the card's "Get a new token"). The calling key must hold the write tier and the chat and deals scopes (403 api_key_scope_insufficient otherwise). 409 agent_listener_webhook_conflict while the teammate's listener is running; 409 teammate_not_live when its owner lost access. Step 3 is conduyt_set_ai_teammate_webhook. ${WHO}`, { teammateId: TEAMMATE_ID }, async ({ teammateId }) => attempt([], () => client.post(`/api/v1/chat/agents/${teammateId}/connect`, {}), (res) => connectResult(unwrap(res), []))));
+    strictInput(server.tool("conduyt_set_ai_teammate_webhook", `Step 3 of connecting a Grok Bot (PUT /api/v1/chat/agents/{id}/webhook): the routine's address and key, as Grok Bot shows them. Send EITHER paste (the whole block the person copied: it must hold one https address and one key) OR address and key. Conduyt checks the address (https, a public host), stores both (the key encrypted), sends the test at once (10 s) and answers { stored, test: { ok, statusCode, runUuid, problem }, status }. The key is write-only: it is never returned, and any text this tool returns has it replaced by [hidden]. A test that was not accepted is an error result { ok: false, error: <its one sentence>, status: 200, code (key_refused, routine_gone, unreachable, not_accepted, rate_limited), answer: <the whole answer> }; an accepted test leaves status Waiting for Grok Bot to say hello: poll conduyt_get_ai_teammate_webhook (every few seconds, up to about 3 minutes) until state is listening or a problem is named. Refusals: 400 with the input codes (input_conflict, address_missing, address_invalid, address_ambiguous, key_missing, key_invalid, key_ambiguous), 422 address_invalid / unreachable, 409 agent_token_missing (run conduyt_connect_ai_teammate first), agent_listener_webhook_conflict, agent_webhook_contended, teammate_not_live, 429 after 20 tests per teammate in 10 minutes, 503 while a delivery is in flight. ${WHO}`, {
+        teammateId: TEAMMATE_ID,
+        paste: z.string().min(1).max(12_000).optional().describe("The block Grok Bot shows (address and key together); not with address or key"),
+        address: z.string().min(1).max(2_048).optional().describe("The routine's address (https://...)"),
+        key: z.string().min(1).max(600).optional().describe("The routine's key (write-only: never returned). The bare key or the \"Authorization: Bearer ...\" header value"),
+    }, async ({ teammateId, paste, address, key }) => {
+        // (r2, Codex grokA3-mcp-r1 P1) every form the server could take as the key (routine-key-redaction.ts: the server's rules ported,
+        // plus the floor of every token as typed), for each input that can carry it: the key field, the paste, an address box holding both
+        const secrets = [...(key !== undefined ? secretsOfKey(key) : []), ...(paste !== undefined ? secretsInPaste(paste) : []), ...(address !== undefined ? secretsInPaste(address) : [])];
+        if (paste === undefined && address === undefined)
+            return connectError(NO_CREDENTIALS_SENTENCE, secrets, { status: null, code: "address_missing" });
+        // the body as ONE literal: the contract gate reads the request fields (paste, address, key) from it
+        return attempt(secrets, () => client.put(`/api/v1/chat/agents/${teammateId}/webhook`, { ...(paste !== undefined ? { paste } : {}), ...(address !== undefined ? { address } : {}), ...(key !== undefined ? { key } : {}) }), testOutcome(secrets));
+    }));
+    strictInput(server.tool("conduyt_test_ai_teammate_webhook", `The card's Test button (POST /api/v1/chat/agents/{id}/webhook/test): sends the hello again to the stored routine (nothing is pasted); an accepted test turns a stored connection live. Answers { test, status } like conduyt_set_ai_teammate_webhook (a test that was not accepted is an error result with its sentence); then poll conduyt_get_ai_teammate_webhook for the hello. 409 agent_webhook_not_connected when nothing is stored; 429 after 20 tests per teammate in 10 minutes. ${WHO}`, { teammateId: TEAMMATE_ID }, async ({ teammateId }) => attempt([], () => client.post(`/api/v1/chat/agents/${teammateId}/webhook/test`, {}), testOutcome([]))));
+    strictInput(server.tool("conduyt_get_ai_teammate_webhook", `The Grok Bot connection's status (GET /api/v1/chat/agents/{id}/webhook), what the Settings card polls: { state (not_connected | waiting_for_hello | listening | not_listening), label, problem: { code, message } | null (the sentence of what to fix), waitingUntil, connected, address (masked), lastAttempt, tokenUsedAt, lastMessageAt }. Never carries the key. ${WHO}`, { teammateId: TEAMMATE_ID }, async ({ teammateId }) => attempt([], () => client.get(`/api/v1/chat/agents/${teammateId}/webhook`), (res) => connectResult(unwrap(res), []))));
+    strictInput(server.tool("conduyt_disconnect_ai_teammate", `Disconnect a Grok Bot teammate (DELETE /api/v1/chat/agents/{id}/webhook; never blocked by billing): its tokens are revoked, the routine's key is cleared and pending deliveries are cancelled; the teammate and its messages stay. Answers { disconnected, revokedKeys, webhook, cancelledDeliveries }. Safe to repeat. Connect it again with conduyt_connect_ai_teammate then conduyt_set_ai_teammate_webhook. ${WHO.replace(" and 402 plan_required when the workspace is not entitled", "")}`, { teammateId: TEAMMATE_ID }, async ({ teammateId }) => attempt([], () => client.del(`/api/v1/chat/agents/${teammateId}/webhook`), (res) => connectResult(unwrap(res), []))));
+}

package/dist/tools/chat.d.ts

@@ -2,5 +2,28 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { ConduytClient } from "../client.js";
 /** The messages route's membership refusal (403 "Not a member of this channel"); any other 403 (a permission) is NOT this. */
 export declare function isMembershipRefusal(err: unknown): boolean;
+/** the plain sentence for the 409 team_chat_threads_off every thread view route and parameter answers while the switch is off */
+export declare const THREADS_OFF_SENTENCE = "The thread view is not switched on for this workspace (account setting teamChatThreads).";
+export declare const THREAD_NOT_FOUND_SENTENCE = "Not found: the message is not a thread root you can see in this channel (a reply id, an unknown or hidden message, a root past the 90-day window with no reply inside it), or this Conduyt server predates the thread view.";
+/**
+ * (#684) a thread view refusal as a plain-sentence error result: 409 team_chat_threads_off (offSentence) and, on the two new routes,
+ * a 404 (an older server has no such route, or the id is not a visible root). null for anything else, which the caller rethrows as is.
+ */
+export declare function threadsRefusal(err: unknown, opts: {
+    offSentence: string;
+    notFound?: boolean;
+}): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError: true;
+} | null;
+/** (#684) a topLevel=true page: every row carries `thread` (a root) or `threadReply` (a reply shown in the channel). A server that
+ *  predates the thread view ignores the parameter and serves every message without either key. An empty page cannot tell. */
+export declare function topLevelApplied(page: unknown): boolean;
+/** (#684) after a reply sent with alsoInChannel: the note when the stored metadata does not carry the flag (an older server ignored it;
+ *  the reply WAS posted and must not be sent again); null when it does or there is no metadata to judge by. */
+export declare function alsoInChannelNote(posted: unknown): string | null;
 /** Team chat read side (app 10-09, live sha 3869c79ba): the unread vector, messages carrying `seq`, and the read acknowledgement. */
 export declare function registerChatTools(server: McpServer, client: ConduytClient): void;

package/dist/tools/chat.js

@@ -41,9 +41,49 @@ async function withMembershipBootstrap(client, read) {
         return read();
     }
 }
+// ---- (#684) the Team Chat thread view (app lane A de0a86727 + lane D files, behind the account switch teamChatThreads) ----
+/** the plain sentence for the 409 team_chat_threads_off every thread view route and parameter answers while the switch is off */
+export const THREADS_OFF_SENTENCE = "The thread view is not switched on for this workspace (account setting teamChatThreads).";
+export const THREAD_NOT_FOUND_SENTENCE = "Not found: the message is not a thread root you can see in this channel (a reply id, an unknown or hidden message, a root past the 90-day window with no reply inside it), or this Conduyt server predates the thread view.";
+/** a structured, non-retried error result: { ok: false, status, code?, error: <plain sentence>, message: <the API's error line> } */
+function threadsError(status, code, sentence, message) {
+    const base = formatToolError(sentence);
+    return { ...base, content: [{ type: "text", text: JSON.stringify({ ok: false, status, ...(code ? { code } : {}), error: sentence, message: message.slice(0, 500) }, null, 2) }] };
+}
+/**
+ * (#684) a thread view refusal as a plain-sentence error result: 409 team_chat_threads_off (offSentence) and, on the two new routes,
+ * a 404 (an older server has no such route, or the id is not a visible root). null for anything else, which the caller rethrows as is.
+ */
+export function threadsRefusal(err, opts) {
+    if (!(err instanceof ConduytApiError) || err.code !== "http")
+        return null;
+    if (err.status === 409 && errorDetailsOf(err.message)?.code === "team_chat_threads_off")
+        return threadsError(409, "team_chat_threads_off", opts.offSentence, err.message);
+    if (err.status === 404 && opts.notFound)
+        return threadsError(404, null, THREAD_NOT_FOUND_SENTENCE, err.message);
+    return null;
+}
+/** (#684) a topLevel=true page: every row carries `thread` (a root) or `threadReply` (a reply shown in the channel). A server that
+ *  predates the thread view ignores the parameter and serves every message without either key. An empty page cannot tell. */
+export function topLevelApplied(page) {
+    const inner = page && typeof page === "object" && "data" in page ? page.data : page;
+    const rows = inner && typeof inner === "object" && Array.isArray(inner.data) ? inner.data : null;
+    return rows !== null && rows.every((r) => r !== null && typeof r === "object" && ("thread" in r || "threadReply" in r));
+}
+/** (#684) after a reply sent with alsoInChannel: the note when the stored metadata does not carry the flag (an older server ignored it;
+ *  the reply WAS posted and must not be sent again); null when it does or there is no metadata to judge by. */
+export function alsoInChannelNote(posted) {
+    const row = posted && typeof posted === "object" && "data" in posted ? posted.data : posted;
+    const meta = row && typeof row === "object" ? row.metadata : undefined;
+    if (!meta || typeof meta !== "object" || Array.isArray(meta))
+        return null;
+    if (meta.alsoInChannel === true)
+        return null;
+    return "Note: the reply was posted in the thread only: this Conduyt server did not record alsoInChannel (it predates the thread view). Do not send it again.";
+}
 /** Team chat read side (app 10-09, live sha 3869c79ba): the unread vector, messages carrying `seq`, and the read acknowledgement. */
 export function registerChatTools(server, client) {
-    strictInput(server.tool("conduyt_list_chat_channels", "List the team chat channels the API key's user belongs to (GET /api/v1/chat/channels): id, name, kind, members, last message, counts. Each row also carries the Team Chat 2.0 fields mentionCount (unread @mentions of you), notify (your stored notification level: all, mentions, mute, or null = the kind's default), updatedAt (when notify last changed, null = never), membershipId (your member row; changes after a removal and re-add), membershipSince (when this membership began) and membershipSeq (strictly increasing incarnation number). Each row also carries agentsRespond (boolean, #613 lane A: false = an admin muted AI teammates in that channel) and, ONLY while the account's AI teammates switch is on, aiTeammates: [{ userId, lastHeartbeatAt, replying }] (the paired AI teammates that are members of the channel; lastHeartbeatAt is their last listener heartbeat or null, replying is true while one is working a turn in that channel; derive the state like the app: heartbeat within 60 seconds = Listening, listening and replying = Replying, otherwise Away). The aiTeammates key is absent when the switch is off. SIDE EFFECT: it also creates the caller's memberships in the account's AUTO channels (needs-a-hand, new-leads, wins) the first time, so a user who never opened Team Chat can read them. conduyt_list_chat_messages and conduyt_mark_chat_read already do this once for you when a channel listed by conduyt_get_chat_unread answers 403 'Not a member of this channel'; call this tool directly to discover channel ids.", {}, async () => {
+    strictInput(server.tool("conduyt_list_chat_channels", "List the team chat channels the API key's user belongs to (GET /api/v1/chat/channels): id, name, kind, members, last message, counts. Each row also carries the Team Chat 2.0 fields mentionCount (unread @mentions of you), notify (your stored notification level: all, mentions, mute, or null = the kind's default), updatedAt (when notify last changed, null = never), membershipId (your member row; changes after a removal and re-add), membershipSince (when this membership began) and membershipSeq (strictly increasing incarnation number). Each row also carries agentsRespond (boolean, #613 lane A: false = an admin muted AI teammates in that channel) and, ONLY while the account's AI teammates switch is on, aiTeammates: [{ userId, lastHeartbeatAt, replying }] (the paired AI teammates that are members of the channel; lastHeartbeatAt is their last listener heartbeat or null, replying is true while one is working a turn in that channel; derive the state like the app: heartbeat within 60 seconds = Listening, listening and replying = Replying, otherwise Away). The aiTeammates key is absent when the switch is off. SIDE EFFECT: it also creates the caller's memberships in the account's AUTO channels (needs-a-hand, new-leads, wins) the first time, so a user who never opened Team Chat can read them. conduyt_list_chat_messages and conduyt_mark_chat_read already do this once for you when a channel listed by conduyt_get_chat_unread answers 403 'Not a member of this channel'; call this tool directly to discover channel ids. (#684) While the workspace's thread view is on, the answer also carries teamChatThreads: true next to data (the key is ABSENT when it is off): only then do conduyt_list_chat_messages topLevel, conduyt_get_chat_thread, conduyt_list_chat_thread_files and conduyt_reply_chat_message alsoInChannel work.", {}, async () => {
         const result = await client.get("/api/v1/chat/channels");
         return formatResult(result);
     }));
@@ -51,14 +91,17 @@ export function registerChatTools(server, client) {
         const result = await client.get("/api/v1/chat/unread");
         return formatResult(result);
     }));
-    strictInput(server.tool("conduyt_list_chat_messages", "List messages in a team chat channel (GET /api/v1/chat/channels/{id}/messages), newest first, paged by cursor. The caller must be a channel member (else 403). Every message carries seq, its commit-ordered position inside the channel (a total order: the list and the cursor follow it), and version, a server counter bumped on every update (edit, delete, reaction, pin, claim, handoff) so a client can tell which copy of a message is newer. afterSeq=N is the realtime catch-up read: the messages committed AFTER seq N (give it once, a whole number 0-999999999, never together with cursor: both are refused here before any request); the page is still newest first and hasMore says more follow it (then re-read the latest page). Read-only: this tool does not move the read marker. On a 403 'Not a member of this channel' it calls GET /chat/channels once (which creates the caller's auto-channel memberships) and retries ONCE; a second refusal, or a 403 for any other reason, is returned as is; acknowledge with conduyt_mark_chat_read.", {
+    strictInput(server.tool("conduyt_list_chat_messages", "List messages in a team chat channel (GET /api/v1/chat/channels/{id}/messages), newest first, paged by cursor. The caller must be a channel member (else 403). Every message carries seq, its commit-ordered position inside the channel (a total order: the list and the cursor follow it), and version, a server counter bumped on every update (edit, delete, reaction, pin, claim, handoff) so a client can tell which copy of a message is newer. afterSeq=N is the realtime catch-up read: the messages committed AFTER seq N (give it once, a whole number 0-999999999, never together with cursor: both are refused here before any request); the page is still newest first and hasMore says more follow it (then re-read the latest page). Read-only: this tool does not move the read marker. On a 403 'Not a member of this channel' it calls GET /chat/channels once (which creates the caller's auto-channel memberships) and retries ONCE; a second refusal, or a 403 for any other reason, is returned as is; acknowledge with conduyt_mark_chat_read. (#684) topLevel: true serves the thread view's channel (top-level messages with their reply chip `thread`, and the replies shown in the channel with `threadReply`); a server that predates the thread view, which ignores the parameter, is reported as an error instead of a page of every reply.", {
         channelId: z.string().uuid().describe("Channel UUID"),
         limit: z.number().int().min(1).max(100).optional().describe("Messages per page (1-100, default 50)"),
         cursor: z.string().uuid().optional().describe("nextCursor from the previous page (a message UUID)"),
         afterSeq: z.number().int().min(0).max(999_999_999).optional().describe("Only messages committed after this seq (the realtime catch-up read). Not combinable with cursor"),
-    }, async ({ channelId, limit, cursor, afterSeq }) => {
+        topLevel: z.boolean().optional().describe("(#684, only while the workspace's thread view is on) true = the channel as the thread view shows it: every top-level message with `thread` (its reply chip { replyCount, lastReplyAt, repliers (up to 3), replierCount }, null when it has no reply), plus the replies shown in the channel with `threadReply` { reason: aiFirstAnswer | alsoInChannel, root: { id, excerpt, deleted } | null }; every other reply stays in its thread (conduyt_get_chat_thread). Sent only when true; never with afterSeq. 409 team_chat_threads_off while the thread view is off"),
+    }, async ({ channelId, limit, cursor, afterSeq, topLevel }) => {
         if (afterSeq !== undefined && cursor !== undefined)
             throw new Error("afterSeq and cursor cannot be combined");
+        if (topLevel === true && afterSeq !== undefined)
+            throw new Error("topLevel and afterSeq cannot be combined (the catch-up read serves every message); nothing was sent");
         const params = new URLSearchParams();
         if (limit !== undefined)
             params.set("limit", String(limit));
@@ -66,8 +109,25 @@ export function registerChatTools(server, client) {
             params.set("cursor", cursor);
         if (afterSeq !== undefined)
             params.set("afterSeq", String(afterSeq));
-        const result = await withMembershipBootstrap(client, () => client.get(`/api/v1/chat/channels/${channelId}/messages?${params}`));
-        return formatResult(result);
+        if (topLevel === true)
+            params.set("topLevel", "true");
+        if (topLevel !== true) {
+            const result = await withMembershipBootstrap(client, () => client.get(`/api/v1/chat/channels/${channelId}/messages?${params}`));
+            return formatResult(result);
+        }
+        let page;
+        try {
+            page = await withMembershipBootstrap(client, () => client.get(`/api/v1/chat/channels/${channelId}/messages?${params}`));
+        }
+        catch (err) {
+            const refused = threadsRefusal(err, { offSentence: THREADS_OFF_SENTENCE });
+            if (refused)
+                return refused;
+            throw err;
+        }
+        if (!topLevelApplied(page))
+            return formatToolError("This Conduyt server did not apply topLevel: its messages carry no thread summaries (it predates the thread view). Read the channel without topLevel.");
+        return formatResult(page);
     }));
     strictInput(server.tool("conduyt_send_chat_message", "Send a Team Chat message as the API key's user (POST /api/v1/chat/channels/{id}/messages). The caller must be a channel member and have the communications:create permission. AI-agent keys are subject to the server's six-consecutive-agent-turn cap; a 409 agent_human_required means no message was sent (markerCreated: true on the refusal that inserted the one human-handoff line, false while the thread stays paused). A 409 agents_muted_in_channel means an admin turned \"agents respond here\" off for this channel: the post was refused, nothing was written, and it must not be retried (same shape as agent_human_required). body is plain Team Chat text (1-10,000 characters).", {
         channelId: z.string().uuid().describe("Channel UUID"),
@@ -82,14 +142,30 @@ export function registerChatTools(server, client) {
         parentId: z.string().uuid().describe("Top-level message UUID to reply to"),
         body: z.string().trim().min(1).max(10_000).describe("Reply text"),
         idempotencyKey: z.string().regex(/^[A-Za-z0-9:_.-]{1,128}$/).optional().describe("Paired AI agent keys only: a key unique per agent and source turn (the listener uses reply:<source message id>). The same key returns the reply already created (200, idempotentReplay: true) instead of posting a second one; a key used in another channel is a 409 idempotency_key_reused. A person's key gets 400."),
+        alsoInChannel: z.boolean().optional().describe("(#684, a person's reply, only while the workspace's thread view is on) true = \"Also send to #channel\": the ONE reply is also shown in the channel (topLevel reads list it with threadReply.reason alsoInChannel); never a second message or notification. Sent only when true. 409 team_chat_threads_off while the thread view is off (nothing posted); an AI teammate never sets it (its first answer already shows in the channel): refused here with claimToken, 400 from the server otherwise"),
         claimToken: z.string().regex(/^[1-9][0-9]{0,8}:[A-Za-z0-9:_.-]{8,128}$/).optional().describe("Paired AI agent keys only; REQUIRED with idempotencyKey reply:<source message id> (refused otherwise, nothing posted): the listener's claim token <generation>:<listener id> from the turn prompt. The reply completes that turn only when posted in the source's channel and thread with the current generation's token; a reply:<source> reply anywhere else, or with a stale token, is refused 409 (reply_wrong_channel / reply_wrong_thread / reply_stale_claim) with nothing posted, so a corrected retry still completes the turn."),
-    }, async ({ channelId, parentId, body, idempotencyKey, claimToken }) => {
+    }, async ({ channelId, parentId, body, idempotencyKey, claimToken, alsoInChannel }) => {
         // (#599 r7) a reply to an inbox turn (idempotencyKey reply:<source message id>) always names its claim
         if (!claimToken && typeof idempotencyKey === "string" && /^reply:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(idempotencyKey)) {
             throw new Error("claimToken is required with an idempotencyKey reply:<source message id> (the turn prompt's reply claim token); nothing was posted");
         }
-        const result = await client.post(`/api/v1/chat/channels/${channelId}/messages`, { body, parentId, ...(idempotencyKey ? { idempotencyKey } : {}), ...(claimToken ? { claimToken } : {}) });
-        return formatResult(result);
+        // (#684) the server refuses alsoInChannel from an AI teammate (400): a turn reply (claim token) never sends it
+        if (alsoInChannel === true && claimToken)
+            throw new Error("alsoInChannel is for a person's reply: an AI teammate's first answer already shows in the channel; nothing was posted");
+        const also = alsoInChannel === true;
+        let result;
+        try {
+            result = await client.post(`/api/v1/chat/channels/${channelId}/messages`, { body, parentId, ...(idempotencyKey ? { idempotencyKey } : {}), ...(claimToken ? { claimToken } : {}), ...(also ? { alsoInChannel: true } : {}) });
+        }
+        catch (err) {
+            const refused = also ? threadsRefusal(err, { offSentence: `${THREADS_OFF_SENTENCE} Nothing was posted: send it again without alsoInChannel.` }) : null;
+            if (refused)
+                return refused;
+            throw err;
+        }
+        const note = also ? alsoInChannelNote(result) : null;
+        const out = formatResult(result);
+        return note ? { ...out, content: [...out.content, { type: "text", text: note }] } : out;
     }));
     strictInput(server.tool("conduyt_react_chat_message", "Add a reaction to a Team Chat message as the API key's user (POST /api/v1/chat/channels/{id}/messages/{messageId}/reactions). The server accepts only its Team Chat reaction set and returns the fully hydrated message. Repeating the same reaction is safe and leaves one reaction from this user. (#802, app #655 c) An AI teammate ENDS its turn with a reaction by passing claimToken (the turn prompt's reply claim token): the reaction then completes that turn (outcome reacted) in the same transaction, so the turn needs no reply. React to the turn's message or one in its thread; when it is another message of the thread, pass the turn's message id as sourceMessageId. Exactly one of a reply, a reaction or conduyt_stay_silent ends a turn: a token that is not the running holder's, or a message outside the turn's thread, is refused 409 reaction_stale_claim, and a turn that already ended (a reply, a silence, another reaction) 409 turn_finished with its outcome; nothing is written on either, do not retry. A person's key sending claimToken gets 400.", {
         channelId: z.string().uuid().describe("Channel UUID"),
@@ -116,6 +192,43 @@ export function registerChatTools(server, client) {
         const result = await client.get(`/api/v1/chat/channels/${channelId}/linked-record`);
         return formatResult(result);
     }));
+    strictInput(server.tool("conduyt_get_chat_thread", "(#684, only while the workspace's thread view is on) Read ONE Team Chat thread by its ROOT, the top-level message (GET /api/v1/chat/channels/{id}/messages/{messageId}/thread): { root, replies (oldest first), total (every counted reply), earlierCount, hasEarlier, earlierCursor (send as before for the page below), aiReactions: [{ messageId, agent, emoji, at }] (an AI teammate's turn that ended with a reaction instead of a reply: \"<name> reacted <emoji>. No reply needed.\" under messageId), replying: [{ userId }] (AI teammates whose turn on this thread is running) }. Without before: the LATEST limit replies (default 20, 1 to 50). Counted replies are not deleted, inside the 90-day window and under the caller's deal visibility. A deleted root is served as stored (deletedAt set, body \"Message deleted\"). An AI teammate reads the whole thread it is answering in with this: pass the turn prompt's Channel id and its Reply parent id (the thread's root), then page back with before while hasEarlier. Members only: a 403 'Not a member of this channel' is recovered once like the other reads. Refusals are error results with a plain sentence, never retried: 409 team_chat_threads_off (the thread view is off), 404 (a reply id, an unknown or hidden message, a root past the window with no reply inside it, or a server that predates the thread view), 400 limit / before.", {
+        channelId: z.string().uuid().describe("Channel UUID"),
+        messageId: z.string().uuid().describe("The thread's ROOT message UUID (a top-level message; for an AI teammate's turn: the Reply parent id)"),
+        limit: z.number().int().min(1).max(50).optional().describe("Replies per page, 1-50 (default 20)"),
+        before: z.number().int().min(0).max(999_999_999).optional().describe("earlierCursor from the previous page (a reply's seq): the replies below it"),
+    }, async ({ channelId, messageId, limit, before }) => {
+        const params = new URLSearchParams();
+        if (limit !== undefined)
+            params.set("limit", String(limit));
+        if (before !== undefined)
+            params.set("before", String(before));
+        try {
+            const result = await withMembershipBootstrap(client, () => client.get(`/api/v1/chat/channels/${channelId}/messages/${messageId}/thread?${params}`));
+            return formatResult(result);
+        }
+        catch (err) {
+            const refused = threadsRefusal(err, { offSentence: THREADS_OFF_SENTENCE, notFound: true });
+            if (refused)
+                return refused;
+            throw err;
+        }
+    }));
+    strictInput(server.tool("conduyt_list_chat_thread_files", "(#684, only while the workspace's thread view is on) The files shared in ONE Team Chat thread (GET /api/v1/chat/channels/{id}/messages/{messageId}/files): the root's attachments and every reply's, oldest first, at most 200 per read: { data: [{ id (<message id>:<position>), messageId, name, type, size, url, fileId (the CRM file id, opened through GET /files/{id}/download, or null), sharedBy { id, name, isAgent }, sharedAt }], hasMore (true when the thread holds more than 200) }. A deleted message contributes nothing; only messages inside the 90-day window count. messageId is the ROOT. Members only (a first-use 403 is recovered once). Refusals are error results with a plain sentence, never retried: 409 team_chat_threads_off, 404 (a reply id, an unknown or hidden message, a root past the window with no reply inside it, or a server that predates the thread view).", {
+        channelId: z.string().uuid().describe("Channel UUID"),
+        messageId: z.string().uuid().describe("The thread's ROOT message UUID"),
+    }, async ({ channelId, messageId }) => {
+        try {
+            const result = await withMembershipBootstrap(client, () => client.get(`/api/v1/chat/channels/${channelId}/messages/${messageId}/files`));
+            return formatResult(result);
+        }
+        catch (err) {
+            const refused = threadsRefusal(err, { offSentence: THREADS_OFF_SENTENCE, notFound: true });
+            if (refused)
+                return refused;
+            throw err;
+        }
+    }));
     strictInput(server.tool("conduyt_mark_chat_read", "Acknowledge team chat as read up to one message (GET /api/v1/chat/channels/{id}/messages?readUpTo=<messageId>&limit=1; the API takes the acknowledgement as a query on the message list). readUpTo is the UUID of a message you were served (its seq becomes your read marker); take it from conduyt_list_chat_messages. The marker only moves FORWARD, never to 'now': an older (stale) message is a no-op, and a message that is not in this channel moves nothing (the call still succeeds, so re-check conduyt_get_chat_unread). A malformed id is a 400. On a 403 'Not a member of this channel' it calls GET /chat/channels once (creating the caller's auto-channel memberships) and retries ONCE; a second refusal, or a 403 for any other reason, is returned as is. The response is the newest message of the channel (limit 1), not a confirmation of the move.", {
         channelId: z.string().uuid().describe("Channel UUID"),
         readUpTo: z.string().uuid().describe("UUID of the newest message you have seen in this channel"),

package/dist/tools/routine-key-redaction.d.ts

@@ -0,0 +1,22 @@
+/**
+ * (#1140 lane A3 r2) What to redact so the Grok Bot routine key never leaves this program: every form the server could take as the
+ * key, plus a floor. THIS FILE IS IDENTICAL in conduyt-cli (src/routine-key-redaction.ts) and conduyt-mcp
+ * (src/tools/routine-key-redaction.ts), and so is its test (routine-key-redaction.test.ts beside it): the two repos cannot import from
+ * each other or from the app, so the same table runs against each copy and a drift fails a test. Findings it answers: Codex
+ * grokA3-cli-r1 P2 2 and grokA3-mcp-r1 P1.
+ */
+/** replaces every appearance of each secret (4 characters or more) in a text about to be printed or returned */
+export declare function hide(text: string, secrets: readonly string[]): string;
+/** :157-163 normalizeRoutineKey (the key field, and every candidate of a block at :191) */
+export declare function serverNormalizeKey(raw: string): string | null;
+/** :176-198 parseRoutineBlock's key extraction: the text without its addresses (:184), then crsr_ tokens (:186), the token after
+ *  "Bearer " (:187), the token after a line-leading "key:" / "key =" (:188), each with trailing punctuation cut and normalized (:191).
+ *  Returns EVERY normalized candidate (the server takes exactly one; all of them are hidden). */
+export declare function serverKeyCandidates(text: string): string[];
+/** the FLOOR: every whitespace-separated token of the input as typed (not an address) of 8 characters or more, in each shape a strip
+ *  of surrounding quotes or brackets, a leading label (key: / key= / Authorization: / Bearer) or trailing punctuation gives it */
+export declare function rawKeyTokens(text: string): string[];
+/** what to hide for a pasted block (the server's candidates, then the floor) */
+export declare function secretsInPaste(text: string): string[];
+/** what to hide for a key given on its own (:213 normalizes the key field; :210 reads an address-alone body as a block) */
+export declare function secretsOfKey(raw: string): string[];

package/dist/tools/routine-key-redaction.js

@@ -0,0 +1,88 @@
+/**
+ * (#1140 lane A3 r2) What to redact so the Grok Bot routine key never leaves this program: every form the server could take as the
+ * key, plus a floor. THIS FILE IS IDENTICAL in conduyt-cli (src/routine-key-redaction.ts) and conduyt-mcp
+ * (src/tools/routine-key-redaction.ts), and so is its test (routine-key-redaction.test.ts beside it): the two repos cannot import from
+ * each other or from the app, so the same table runs against each copy and a drift fails a test. Findings it answers: Codex
+ * grokA3-cli-r1 P2 2 and grokA3-mcp-r1 P1.
+ */
+/** replaces every appearance of each secret (4 characters or more) in a text about to be printed or returned */
+export function hide(text, secrets) {
+    let out = text;
+    // (r2) longest first: a shorter secret inside a longer one never leaves the longer one's tail behind
+    for (const s of [...secrets].sort((a, b) => b.length - a.length))
+        if (s && s.length >= 4)
+            out = out.split(s).join("[hidden]");
+    return out;
+}
+// A PORT of the server's extraction, conduyt-app lane A2b 0c0088508 lib/agent-webhook-connect.ts, rule for rule and in its order.
+// It is used ONLY to know what to hide, never to decide what is sent (the server parses the paste itself). Where the port and the
+// server could ever disagree, the floor (rawKeyTokens) still hides the key: every token of the input as typed, in every shape a
+// strip of quotes, labels and trailing punctuation can give it.
+/** lib/agent-webhook-connect.ts:146 KEY_RE */
+const SERVER_KEY_RE = /^[A-Za-z0-9._~+/=-]{8,512}$/;
+/** :147 URL_IN_TEXT_RE */
+const SERVER_URL_IN_TEXT_RE = /https?:\/\/[^\s"'`<>]+/gi;
+/** :148 TRAILING_PUNCT_RE */
+const SERVER_TRAILING_PUNCT_RE = /[.,;:!?)\]}]+$/;
+/** :150-154 unquote */
+function serverUnquote(raw) {
+    let out = raw.trim();
+    while (out.length >= 2 && /^["'`<]/.test(out) && /["'`>]$/.test(out))
+        out = out.slice(1, -1).trim();
+    return out;
+}
+/** :157-163 normalizeRoutineKey (the key field, and every candidate of a block at :191) */
+export function serverNormalizeKey(raw) {
+    let s = serverUnquote(raw);
+    s = s.replace(/^authorization\s*:\s*/i, "");
+    s = s.replace(/^bearer\s+/i, "");
+    s = serverUnquote(s);
+    return SERVER_KEY_RE.test(s) ? s : null;
+}
+/** :176-198 parseRoutineBlock's key extraction: the text without its addresses (:184), then crsr_ tokens (:186), the token after
+ *  "Bearer " (:187), the token after a line-leading "key:" / "key =" (:188), each with trailing punctuation cut and normalized (:191).
+ *  Returns EVERY normalized candidate (the server takes exactly one; all of them are hidden). */
+export function serverKeyCandidates(text) {
+    const rest = text.replace(SERVER_URL_IN_TEXT_RE, " ");
+    const found = [];
+    for (const m of rest.matchAll(/(?:^|[^A-Za-z0-9_])(crsr_[A-Za-z0-9_-]+)/g))
+        found.push(m[1]);
+    for (const m of rest.matchAll(/\bbearer\s+([^\s"'`]+)/gi))
+        found.push(m[1]);
+    for (const m of rest.matchAll(/^[ \t]*(?:the\s+)?key\s*[:=][ \t]*["'`]?([^\s"'`]+)/gim))
+        found.push(m[1]);
+    const out = [];
+    for (const c of found) {
+        const k = serverNormalizeKey(c.replace(SERVER_TRAILING_PUNCT_RE, ""));
+        if (k)
+            out.push(k);
+    }
+    return out;
+}
+/** the FLOOR: every whitespace-separated token of the input as typed (not an address) of 8 characters or more, in each shape a strip
+ *  of surrounding quotes or brackets, a leading label (key: / key= / Authorization: / Bearer) or trailing punctuation gives it */
+export function rawKeyTokens(text) {
+    const out = new Set();
+    const add = (t) => { if (t.length >= 8 && !/^https?:\/\//i.test(t))
+        out.add(t); };
+    for (const tok of text.split(/\s+/)) {
+        const shapes = [tok];
+        for (let i = 0; i < 3; i++) {
+            for (const t of [...shapes]) {
+                shapes.push(t.replace(/^["'`<(\[{]+|["'`>)\]}]+$/g, ""), t.replace(SERVER_TRAILING_PUNCT_RE, ""), t.replace(/^(?:key\s*[:=]|authorization\s*:|bearer\s*:?)/i, ""));
+            }
+        }
+        for (const t of shapes)
+            add(t);
+    }
+    return [...out];
+}
+/** what to hide for a pasted block (the server's candidates, then the floor) */
+export function secretsInPaste(text) {
+    return [...new Set([...serverKeyCandidates(text), ...rawKeyTokens(text)])];
+}
+/** what to hide for a key given on its own (:213 normalizes the key field; :210 reads an address-alone body as a block) */
+export function secretsOfKey(raw) {
+    const n = serverNormalizeKey(raw);
+    return [...new Set([raw, raw.trim(), ...(n ? [n] : []), ...rawKeyTokens(raw)])].filter((s) => s.length >= 4);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "conduyt-mcp",
-  "version": "4.105.4",
+  "version": "4.105.6",
   "mcpName": "com.conduyt/mcp",
   "description": "MCP server for Conduyt CRM — expose CRM operations as AI-accessible tools",
   "type": "module",

package/scripts/coverage-matrix.json

@@ -1,10 +1,10 @@
 {
-  "generatedAt": "2026-11-05T14:27:30.253Z",
-  "toolCount": 385,
-  "totalEndpoints": 1150,
+  "generatedAt": "2026-11-06T18:54:56.539Z",
+  "toolCount": 392,
+  "totalEndpoints": 1160,
   "counts": {
-    "covered": 339,
-    "excluded": 353,
+    "covered": 346,
+    "excluded": 356,
     "planned": 458,
     "uncategorized": 0
   },
@@ -1327,10 +1327,40 @@
       "status": "excluded",
       "reason": "(#599) session-only (assertSessionOnly): an admin manages AI teammates in Settings > AI; every API key is refused"
     },
+    "POST /api/v1/chat/agents/:id/connect": {
+      "status": "covered",
+      "tools": [
+        "conduyt_connect_ai_teammate"
+      ]
+    },
     "POST /api/v1/chat/agents/:id/pair-code": {
       "status": "excluded",
       "reason": "(#599) session-only (assertSessionOnly): an admin manages AI teammates in Settings > AI; every API key is refused"
     },
+    "GET /api/v1/chat/agents/:id/webhook": {
+      "status": "covered",
+      "tools": [
+        "conduyt_get_ai_teammate_webhook"
+      ]
+    },
+    "PUT /api/v1/chat/agents/:id/webhook": {
+      "status": "covered",
+      "tools": [
+        "conduyt_set_ai_teammate_webhook"
+      ]
+    },
+    "DELETE /api/v1/chat/agents/:id/webhook": {
+      "status": "covered",
+      "tools": [
+        "conduyt_disconnect_ai_teammate"
+      ]
+    },
+    "POST /api/v1/chat/agents/:id/webhook/test": {
+      "status": "covered",
+      "tools": [
+        "conduyt_test_ai_teammate_webhook"
+      ]
+    },
     "POST /api/v1/chat/agents/me/heartbeat": {
       "status": "excluded",
       "reason": "(#599) the listener protocol of a paired agent key (long poll, per-event ack, heartbeat): served by the npm CLI `conduyt agent listen`, not a request/response MCP tool"
@@ -1349,6 +1379,18 @@
         "conduyt_stay_silent"
       ]
     },
+    "GET /api/v1/chat/agents/me/mcp": {
+      "status": "excluded",
+      "reason": "(#599) the listener protocol of a paired agent key (long poll, per-event ack, heartbeat): served by the npm CLI `conduyt agent listen`, not a request/response MCP tool"
+    },
+    "POST /api/v1/chat/agents/me/mcp": {
+      "status": "excluded",
+      "reason": "(#599) the listener protocol of a paired agent key (long poll, per-event ack, heartbeat): served by the npm CLI `conduyt agent listen`, not a request/response MCP tool"
+    },
+    "DELETE /api/v1/chat/agents/me/mcp": {
+      "status": "excluded",
+      "reason": "(#599) the listener protocol of a paired agent key (long poll, per-event ack, heartbeat): served by the npm CLI `conduyt agent listen`, not a request/response MCP tool"
+    },
     "POST /api/v1/chat/agents/pair": {
       "status": "excluded",
       "reason": "(#599) the single-use pair-code exchange that MINTS the agent's key: the listener's first call (npm CLI `conduyt agent pair` / `listen --pair-code`), never made with an existing key"
@@ -1419,6 +1461,12 @@
       "status": "planned",
       "reason": "team chat read/post for agents"
     },
+    "GET /api/v1/chat/channels/:id/messages/:messageId/files": {
+      "status": "covered",
+      "tools": [
+        "conduyt_list_chat_thread_files"
+      ]
+    },
     "POST /api/v1/chat/channels/:id/messages/:messageId/handoff": {
       "status": "planned",
       "reason": "team chat read/post for agents"
@@ -1437,6 +1485,12 @@
       "status": "planned",
       "reason": "team chat read/post for agents"
     },
+    "GET /api/v1/chat/channels/:id/messages/:messageId/thread": {
+      "status": "covered",
+      "tools": [
+        "conduyt_get_chat_thread"
+      ]
+    },
     "GET /api/v1/chat/channels/:id/notifications": {
       "status": "covered",
       "tools": [