@webmcp-bridge/adapter-x 0.4.2 → 0.5.0

package/dist/adapter.js

@@ -2,28 +2,25 @@
  * This module implements the X site fallback adapter with robust auth checks and compose confirmation.
  * It depends on Playwright page evaluation and shared adapter contracts to execute browser-side tool actions.
  */
+import { buildRequestCaptureInitScript, captureRoutedResponseText, collectTextByTag, joinTextParts, parseNdjsonLines, TemplateCache, } from "@webmcp-bridge/adapter-utils";
+import { mkdtemp, rm, stat, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, extname, isAbsolute, join } from "node:path";
 const DEFAULT_TIMELINE_LIMIT = 10;
 const MAX_TIMELINE_LIMIT = 20;
 const MAX_READ_PAGE_CACHE_SIZE = 8;
 const DEFAULT_COMPOSE_CONFIRM_TIMEOUT_MS = 10_000;
+const DEFAULT_GROK_RESPONSE_TIMEOUT_MS = 90_000;
 const DEFAULT_MAX_POST_LENGTH = 280;
 const AUTH_STABILIZE_ATTEMPTS = 6;
 const AUTH_STABILIZE_DELAY_MS = 750;
 const AUTH_WARMUP_TIMEOUT_MS = 12_000;
-const CAPTURE_INJECT_SCRIPT = String.raw `
-(() => {
-  const globalAny = window;
-  if (globalAny.__WEBMCP_X_CAPTURE__) {
-    return;
-  }
-
-  const state = {
-    enabled: true,
-    entries: [],
-  };
-
-  const now = () => Date.now();
-  const isGraphQLTimelineUrl = (url) => {
+const GROK_ARTIFACT_DIR_PREFIX = "webmcp-bridge-grok-";
+const TWEET_MEDIA_ARTIFACT_DIR_PREFIX = "webmcp-bridge-x-media-";
+const ALLOWED_TWEET_MEDIA_HOSTS = new Set(["pbs.twimg.com", "video.twimg.com"]);
+const CAPTURE_INJECT_SCRIPT = buildRequestCaptureInitScript({
+    globalKey: "__WEBMCP_X_CAPTURE__",
+    shouldCaptureSource: String.raw `((url) => {
     if (typeof url !== "string") return false;
     return (
       url.includes("/i/api/graphql/") &&
@@ -38,144 +35,22 @@ const CAPTURE_INJECT_SCRIPT = String.raw `
         url.includes("/SearchTimeline")
       )
     );
-  };
-
-  const detectOperation = (url) => {
-    if (url.includes("/HomeTimeline")) return "HomeTimeline";
-    if (url.includes("/BookmarksAll")) return "BookmarksAll";
-    if (url.includes("/Bookmarks")) return "Bookmarks";
-    if (url.includes("/TweetDetail")) return "TweetDetail";
-    if (url.includes("/UserTweetsAndReplies")) return "UserTweetsAndReplies";
-    if (url.includes("/UserMedia")) return "UserMedia";
-    if (url.includes("/UserTweets")) return "UserTweets";
-    if (url.includes("/SearchTimeline")) return "SearchTimeline";
-    return "Unknown";
-  };
-
-  const pickHeaders = (headersLike) => {
-    const output = {};
-    if (!headersLike) return output;
-    try {
-      const headers = new Headers(headersLike);
-      headers.forEach((value, key) => {
-        output[String(key).toLowerCase()] = String(value);
-      });
-      return output;
-    } catch {
-      if (typeof headersLike === "object") {
-        for (const [k, v] of Object.entries(headersLike)) {
-          output[String(k).toLowerCase()] = String(v);
-        }
-      }
-      return output;
-    }
-  };
-
-  const appendEntry = (entry) => {
-    state.entries.push(entry);
-    if (state.entries.length > 80) {
-      state.entries.splice(0, state.entries.length - 80);
-    }
-  };
-
-  const originalFetch = globalAny.fetch?.bind(globalAny);
-  if (typeof originalFetch === "function") {
-    globalAny.fetch = async (...args) => {
-      const input = args[0];
-      const init = args[1] || {};
-      const url = typeof input === "string" ? input : input?.url || "";
-      const method = String(init.method || (typeof input !== "string" && input?.method) || "GET").toUpperCase();
-      const headers = pickHeaders(init.headers || (typeof input !== "string" ? input?.headers : undefined));
-      const body = typeof init.body === "string" ? init.body : undefined;
-      const shouldCapture = isGraphQLTimelineUrl(url);
-      const response = await originalFetch(...args);
-
-      if (shouldCapture) {
-        let responseJson;
-        try {
-          responseJson = await response.clone().json();
-        } catch {
-          responseJson = undefined;
-        }
-        appendEntry({
-          ts: now(),
-          op: detectOperation(url),
-          url,
-          method,
-          headers,
-          body,
-          ok: response.ok,
-          status: response.status,
-          responseJson,
-        });
-      }
-      return response;
-    };
-  }
-
-  const OriginalXMLHttpRequest = globalAny.XMLHttpRequest;
-  const xhrProto = OriginalXMLHttpRequest?.prototype;
-  if (xhrProto && !xhrProto.__webmcpCapturePatched) {
-    const originalOpen = xhrProto.open;
-    const originalSend = xhrProto.send;
-    const originalSetRequestHeader = xhrProto.setRequestHeader;
-
-    xhrProto.open = function(method, url, ...rest) {
-      this.__webmcpCapture = {
-        method: String(method || "GET").toUpperCase(),
-        url: String(url || ""),
-        headers: {},
-      };
-      return originalOpen.call(this, method, url, ...rest);
-    };
-
-    xhrProto.setRequestHeader = function(key, value) {
-      try {
-        const capture = this.__webmcpCapture;
-        if (capture && capture.headers && typeof key === "string") {
-          capture.headers[String(key).toLowerCase()] = String(value);
-        }
-      } catch {}
-      return originalSetRequestHeader.call(this, key, value);
-    };
-
-    xhrProto.send = function(body) {
-      try {
-        this.addEventListener("loadend", () => {
-          const capture = this.__webmcpCapture || {};
-          const url = typeof capture.url === "string" ? capture.url : "";
-          if (!isGraphQLTimelineUrl(url)) {
-            return;
-          }
-          let responseJson;
-          try {
-            const text = typeof this.responseText === "string" ? this.responseText : "";
-            responseJson = text ? JSON.parse(text) : undefined;
-          } catch {
-            responseJson = undefined;
-          }
-          appendEntry({
-            ts: now(),
-            op: detectOperation(url),
-            url,
-            method: typeof capture.method === "string" ? capture.method : "GET",
-            headers: capture.headers || {},
-            body: typeof body === "string" ? body : undefined,
-            ok: this.status >= 200 && this.status < 300,
-            status: Number(this.status || 0),
-            responseJson,
-          });
-        });
-      } catch {}
-      return originalSend.call(this, body);
-    };
-
-    xhrProto.__webmcpCapturePatched = true;
-  }
-
-  globalAny.__WEBMCP_X_CAPTURE__ = state;
-})();
-`;
+  })`,
+    enrichEntrySource: String.raw `((entry) => {
+    const url = typeof entry?.url === "string" ? entry.url : "";
+    let op = "Unknown";
+    if (url.includes("/HomeTimeline")) op = "HomeTimeline";
+    else if (url.includes("/BookmarksAll")) op = "BookmarksAll";
+    else if (url.includes("/Bookmarks")) op = "Bookmarks";
+    else if (url.includes("/TweetDetail")) op = "TweetDetail";
+    else if (url.includes("/UserTweetsAndReplies")) op = "UserTweetsAndReplies";
+    else if (url.includes("/UserMedia")) op = "UserMedia";
+    else if (url.includes("/UserTweets")) op = "UserTweets";
+    else if (url.includes("/SearchTimeline")) op = "SearchTimeline";
+    return { ...entry, op };
+  })`,
+    maxEntries: 80,
+});
 const TOOL_DEFINITIONS = [
     {
         name: "auth.get",
@@ -229,6 +104,101 @@ const TOOL_DEFINITIONS = [
             readOnlyHint: true,
         },
     },
+    {
+        name: "tweet.conversation.get",
+        description: "Read one tweet conversation by url or id",
+        inputSchema: {
+            type: "object",
+            description: "Fetch the focal tweet with its visible ancestors and replies from a tweet detail conversation.",
+            properties: {
+                url: { type: "string", description: "Tweet URL, for example https://x.com/<user>/status/<id>." },
+                id: { type: "string", description: "Tweet id. Used when url is not provided." },
+                limit: {
+                    type: "integer",
+                    description: `Maximum number of reply tweets to return. Default ${DEFAULT_TIMELINE_LIMIT}, max ${MAX_TIMELINE_LIMIT}.`,
+                    minimum: 1,
+                    maximum: MAX_TIMELINE_LIMIT,
+                },
+                cursor: {
+                    type: "string",
+                    description: "Pagination cursor returned by previous call as nextCursor.",
+                },
+            },
+            additionalProperties: false,
+        },
+        annotations: {
+            readOnlyHint: true,
+        },
+    },
+    {
+        name: "tweet.replies.list",
+        description: "List replies for one tweet by url or id",
+        inputSchema: {
+            type: "object",
+            description: "Fetch reply tweets for one focal tweet. Supports cursor pagination when the upstream detail response exposes a reply cursor.",
+            properties: {
+                url: { type: "string", description: "Tweet URL, for example https://x.com/<user>/status/<id>." },
+                id: { type: "string", description: "Tweet id. Used when url is not provided." },
+                limit: {
+                    type: "integer",
+                    description: `Maximum number of replies to return. Default ${DEFAULT_TIMELINE_LIMIT}, max ${MAX_TIMELINE_LIMIT}.`,
+                    minimum: 1,
+                    maximum: MAX_TIMELINE_LIMIT,
+                },
+                cursor: {
+                    type: "string",
+                    description: "Pagination cursor returned by previous call as nextCursor.",
+                },
+            },
+            additionalProperties: false,
+        },
+        annotations: {
+            readOnlyHint: true,
+        },
+    },
+    {
+        name: "tweet.thread.get",
+        description: "Read one tweet thread by url or id",
+        inputSchema: {
+            type: "object",
+            description: "Fetch the same-author thread chain around one focal tweet.",
+            properties: {
+                url: { type: "string", description: "Tweet URL, for example https://x.com/<user>/status/<id>." },
+                id: { type: "string", description: "Tweet id. Used when url is not provided." },
+                limit: {
+                    type: "integer",
+                    description: `Maximum number of thread tweets to return. Default ${DEFAULT_TIMELINE_LIMIT}, max ${MAX_TIMELINE_LIMIT}.`,
+                    minimum: 1,
+                    maximum: MAX_TIMELINE_LIMIT,
+                },
+            },
+            additionalProperties: false,
+        },
+        annotations: {
+            readOnlyHint: true,
+        },
+    },
+    {
+        name: "tweet.media.download",
+        description: "Download media for one tweet by url or id",
+        inputSchema: {
+            type: "object",
+            description: "Download one tweet's media to local artifact paths. Defaults to all media when mediaIndex is omitted.",
+            properties: {
+                url: { type: "string", description: "Tweet URL, for example https://x.com/<user>/status/<id>." },
+                id: { type: "string", description: "Tweet id. Used when url is not provided." },
+                mediaIndex: {
+                    type: "integer",
+                    description: "Optional zero-based media index to download. Omit to download all media items.",
+                    minimum: 0,
+                },
+            },
+            additionalProperties: false,
+        },
+        annotations: {
+            readOnlyHint: true,
+        },
+    },
     {
         name: "favorites.list",
         description: "Read bookmarks/favorites feed cards",
@@ -253,6 +223,46 @@ const TOOL_DEFINITIONS = [
             readOnlyHint: true,
         },
     },
+    {
+        name: "notifications.list",
+        description: "Read the main notifications feed",
+        inputSchema: {
+            type: "object",
+            description: "List recent notifications from the authenticated account.",
+            properties: {
+                limit: {
+                    type: "integer",
+                    description: `Maximum number of notifications to return. Default ${DEFAULT_TIMELINE_LIMIT}, max ${MAX_TIMELINE_LIMIT}.`,
+                    minimum: 1,
+                    maximum: MAX_TIMELINE_LIMIT,
+                },
+            },
+            additionalProperties: false,
+        },
+        annotations: {
+            readOnlyHint: true,
+        },
+    },
+    {
+        name: "mentions.list",
+        description: "Read the mentions tab from notifications",
+        inputSchema: {
+            type: "object",
+            description: "List recent mention notifications where the account is referenced.",
+            properties: {
+                limit: {
+                    type: "integer",
+                    description: `Maximum number of mentions to return. Default ${DEFAULT_TIMELINE_LIMIT}, max ${MAX_TIMELINE_LIMIT}.`,
+                    minimum: 1,
+                    maximum: MAX_TIMELINE_LIMIT,
+                },
+            },
+            additionalProperties: false,
+        },
+        annotations: {
+            readOnlyHint: true,
+        },
+    },
     {
         name: "timeline.user.list",
         description: "Read one user's timeline tweet cards",
@@ -356,6 +366,62 @@ const TOOL_DEFINITIONS = [
             additionalProperties: false,
         },
     },
+    {
+        name: "tweet.reply",
+        description: "Reply to one tweet by url or id",
+        inputSchema: {
+            type: "object",
+            description: "Open a tweet detail page, compose one reply, and optionally skip final submit with dryRun.",
+            properties: {
+                url: { type: "string", description: "Tweet URL, for example https://x.com/<user>/status/<id>." },
+                id: { type: "string", description: "Tweet id. Used when url is not provided." },
+                text: {
+                    type: "string",
+                    description: `Reply text content. Max length ${DEFAULT_MAX_POST_LENGTH}.`,
+                    minLength: 1,
+                    maxLength: DEFAULT_MAX_POST_LENGTH,
+                },
+                dryRun: {
+                    type: "boolean",
+                    description: "When true, validate the reply compose path without submitting.",
+                },
+            },
+            required: ["text"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "grok.chat",
+        description: "Send one prompt to Grok from the authenticated X session",
+        inputSchema: {
+            type: "object",
+            description: "Ask Grok from the authenticated X session. Starts a new chat by default; pass conversationId to continue an existing conversation.",
+            properties: {
+                prompt: {
+                    type: "string",
+                    description: "Prompt text to send to Grok.",
+                    minLength: 1,
+                },
+                conversationId: {
+                    type: "string",
+                    description: "Existing Grok conversation id. When omitted, the adapter starts a new chat before asking.",
+                    minLength: 1,
+                },
+                attachmentPaths: {
+                    type: "array",
+                    description: "Optional local files to upload with the prompt.",
+                    items: {
+                        type: "string",
+                        description: "Absolute local file path to upload through the browser session.",
+                        minLength: 1,
+                        "x-uxc-kind": "file-path",
+                    },
+                },
+            },
+            required: ["prompt"],
+            additionalProperties: false,
+        },
+    },
 ];
 function toRecord(value) {
     if (typeof value === "object" && value !== null && !Array.isArray(value)) {
@@ -373,104 +439,441 @@ function errorResult(code, message, details) {
     }
     return { error };
 }
-function normalizeTimelineLimit(input) {
-    const rawLimit = input.limit;
-    if (typeof rawLimit !== "number" || !Number.isFinite(rawLimit)) {
-        return DEFAULT_TIMELINE_LIMIT;
+function sanitizeArtifactName(name) {
+    const trimmed = name.trim();
+    const normalized = trimmed.replace(/[\\/:*?"<>|]+/g, "-").replace(/\s+/g, " ");
+    return normalized.length > 0 ? normalized : "artifact.bin";
+}
+function inferArtifactExtension(mimeType) {
+    switch ((mimeType ?? "").toLowerCase()) {
+        case "text/csv":
+            return ".csv";
+        case "application/json":
+            return ".json";
+        case "text/plain":
+            return ".txt";
+        case "text/markdown":
+            return ".md";
+        case "application/pdf":
+            return ".pdf";
+        case "image/png":
+            return ".png";
+        case "image/jpeg":
+            return ".jpg";
+        default:
+            return ".bin";
     }
-    return Math.max(1, Math.min(MAX_TIMELINE_LIMIT, Math.floor(rawLimit)));
 }
-async function ensureNetworkCaptureInstalled(page) {
-    await page.addInitScript(CAPTURE_INJECT_SCRIPT);
-    await page.evaluate(CAPTURE_INJECT_SCRIPT);
+function inferArtifactNameFromLabel(label, mimeType) {
+    const match = label.match(/([A-Za-z0-9._-]+\.[A-Za-z0-9]+)\b/);
+    const matchedName = match?.[1];
+    if (matchedName) {
+        return sanitizeArtifactName(matchedName);
+    }
+    const base = sanitizeArtifactName(label.replace(/\s+/g, " ").trim() || "artifact");
+    const extension = extname(base) || inferArtifactExtension(mimeType);
+    return extname(base) ? base : `${base}${extension}`;
 }
-async function hasCapturedTemplate(page, mode) {
-    const result = await page.evaluate(({ targetMode }) => {
-        const globalAny = window;
-        const entries = Array.isArray(globalAny.__WEBMCP_X_CAPTURE__?.entries)
-            ? globalAny.__WEBMCP_X_CAPTURE__?.entries ?? []
-            : [];
-        const ops = targetMode === "home"
-            ? ["HomeTimeline", "TweetDetail"]
-            : targetMode === "bookmarks"
-                ? ["BookmarksAll", "Bookmarks"]
-                : targetMode === "tweet"
-                    ? ["TweetDetail"]
-                    : targetMode === "user_timeline"
-                        ? ["UserTweets", "UserTweetsAndReplies", "UserMedia"]
-                        : ["SearchTimeline"];
-        for (let i = entries.length - 1; i >= 0; i -= 1) {
-            const entry = entries[i];
-            if (entry && typeof entry.op === "string" && ops.includes(entry.op)) {
-                return true;
+function inferArtifactNameFromUrl(url, fallbackBase, mimeType) {
+    try {
+        const parsed = new URL(url);
+        const pathnameName = basename(parsed.pathname);
+        const format = parsed.searchParams.get("format")?.trim();
+        if (pathnameName) {
+            const safePathName = sanitizeArtifactName(pathnameName);
+            if (extname(safePathName)) {
+                return safePathName;
+            }
+            if (format) {
+                return `${safePathName}.${sanitizeArtifactName(format).replace(/^\.+/, "")}`;
             }
         }
-        return false;
-    }, { targetMode: mode });
-    return result === true;
+        if (format) {
+            return `${sanitizeArtifactName(fallbackBase)}.${sanitizeArtifactName(format).replace(/^\.+/, "")}`;
+        }
+    }
+    catch {
+        // Fall through to MIME-based fallback.
+    }
+    return inferArtifactNameFromLabel(fallbackBase, mimeType);
 }
-async function warmupNetworkTemplate(page, mode) {
-    if (await hasCapturedTemplate(page, mode)) {
-        return;
+function parseDataUri(uri) {
+    if (!uri.startsWith("data:")) {
+        return undefined;
     }
-    await waitForTweetSurface(page);
-    await page
-        .evaluate(() => {
-        window.scrollTo(0, Math.max(document.body.scrollHeight * 0.8, 1200));
-    })
-        .catch(() => { });
-    await page.waitForTimeout(900);
-    if (await hasCapturedTemplate(page, mode)) {
-        return;
+    const commaIndex = uri.indexOf(",");
+    if (commaIndex < 0) {
+        return undefined;
     }
-    await page
-        .evaluate(() => {
-        window.scrollTo(0, 0);
-    })
-        .catch(() => { });
-    await page.waitForTimeout(700);
-    if (await hasCapturedTemplate(page, mode)) {
-        return;
+    const meta = uri.slice(5, commaIndex);
+    const payload = uri.slice(commaIndex + 1);
+    const parts = meta.split(";").filter((part) => part.length > 0);
+    const mimeType = parts[0] && !parts[0].includes("=") ? parts[0] : undefined;
+    const isBase64 = parts.includes("base64");
+    try {
+        const buffer = isBase64
+            ? Buffer.from(payload, "base64")
+            : Buffer.from(decodeURIComponent(payload), "utf8");
+        return mimeType ? { mimeType, buffer } : { buffer };
+    }
+    catch {
+        return undefined;
     }
-    await page.reload({ waitUntil: "domcontentloaded", timeout: 60_000 }).catch(() => { });
-    await waitForTweetSurface(page);
 }
-async function detectAuth(page) {
-    return await page.evaluate(({ op }) => {
-        void op;
-        const signals = [];
-        const challengeSelectors = [
-            "form[action*='account/access']",
-            "input[name='verification_string']",
-            "iframe[title*='challenge']",
-        ];
-        const loginSelectors = [
-            "input[name='text']",
-            "input[autocomplete='username']",
-            "a[href='/login']",
-            "a[href*='/i/flow/login']",
-        ];
-        const authenticatedSelectors = [
-            "[data-testid='AppTabBar_Home_Link']",
-            "[data-testid='SideNav_NewTweet_Button']",
-            "[data-testid='tweetTextarea_0']",
-            "nav[aria-label='Primary']",
-        ];
-        const hasSelector = (selectors) => {
-            return selectors.some((selector) => document.querySelector(selector) !== null);
-        };
-        const bodyText = (document.body?.innerText ?? "").toLowerCase();
-        const pathname = location.pathname.toLowerCase();
-        const hasChallengeUi = hasSelector(challengeSelectors) ||
-            pathname.includes("/account/access") ||
-            bodyText.includes("are you human") ||
-            bodyText.includes("unusual activity") ||
-            bodyText.includes("challenge");
-        if (hasChallengeUi) {
-            signals.push("challenge_ui");
-            return { state: "challenge_required", signals };
+function toTweetMediaArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const output = [];
+    for (const rawEntry of value) {
+        if (!rawEntry || typeof rawEntry !== "object" || Array.isArray(rawEntry)) {
+            continue;
         }
-        if (hasSelector(authenticatedSelectors)) {
+        const entry = rawEntry;
+        const type = entry.type;
+        const url = entry.url;
+        if ((type !== "photo" && type !== "video" && type !== "animated_gif")
+            || typeof url !== "string"
+            || url.trim().length === 0) {
+            continue;
+        }
+        const media = {
+            type,
+            url,
+        };
+        if (typeof entry.previewUrl === "string" && entry.previewUrl.trim()) {
+            media.previewUrl = entry.previewUrl;
+        }
+        if (typeof entry.width === "number" && Number.isFinite(entry.width)) {
+            media.width = entry.width;
+        }
+        if (typeof entry.height === "number" && Number.isFinite(entry.height)) {
+            media.height = entry.height;
+        }
+        if (typeof entry.durationMs === "number" && Number.isFinite(entry.durationMs)) {
+            media.durationMs = entry.durationMs;
+        }
+        if (Array.isArray(entry.variants)) {
+            const variants = entry.variants.flatMap((rawVariant) => {
+                if (!rawVariant || typeof rawVariant !== "object" || Array.isArray(rawVariant)) {
+                    return [];
+                }
+                const variantRecord = rawVariant;
+                if (typeof variantRecord.url !== "string" || !variantRecord.url.trim()) {
+                    return [];
+                }
+                const variant = { url: variantRecord.url };
+                if (typeof variantRecord.contentType === "string" && variantRecord.contentType.trim()) {
+                    variant.contentType = variantRecord.contentType;
+                }
+                if (typeof variantRecord.bitrate === "number" && Number.isFinite(variantRecord.bitrate)) {
+                    variant.bitrate = variantRecord.bitrate;
+                }
+                return [variant];
+            });
+            if (variants.length > 0) {
+                media.variants = variants;
+            }
+        }
+        output.push(media);
+    }
+    return output;
+}
+function normalizeTweetMediaForDownload(media) {
+    if (media.type !== "photo") {
+        return media;
+    }
+    try {
+        const parsed = new URL(media.url);
+        if (parsed.hostname.includes("pbs.twimg.com") && !parsed.searchParams.has("name")) {
+            parsed.searchParams.set("name", "orig");
+            return {
+                ...media,
+                url: parsed.toString(),
+            };
+        }
+    }
+    catch {
+        return media;
+    }
+    return media;
+}
+async function materializeGrokArtifacts(response) {
+    const matches = Array.from(response.matchAll(/\[([^\]]+)\]\((data:[^)]+)\)/g));
+    if (matches.length === 0) {
+        return { response };
+    }
+    const artifacts = [];
+    const reservedNames = new Set();
+    let artifactDir;
+    let cleanedResponse = response;
+    for (const match of matches) {
+        const label = match[1] ?? "artifact";
+        const dataUri = match[2] ?? "";
+        const parsed = parseDataUri(dataUri);
+        if (!parsed) {
+            continue;
+        }
+        let name = inferArtifactNameFromLabel(label, parsed.mimeType);
+        if (reservedNames.has(name)) {
+            const extension = extname(name);
+            const stem = extension ? name.slice(0, -extension.length) : name;
+            let suffix = 2;
+            do {
+                name = `${stem}-${suffix}${extension}`;
+                suffix += 1;
+            } while (reservedNames.has(name));
+        }
+        reservedNames.add(name);
+        if (!artifactDir) {
+            artifactDir = await mkdtemp(join(tmpdir(), GROK_ARTIFACT_DIR_PREFIX));
+        }
+        const path = join(artifactDir, name);
+        await writeFile(path, parsed.buffer);
+        const artifact = {
+            kind: "file",
+            name,
+            path,
+        };
+        if (parsed.mimeType) {
+            artifact.mimeType = parsed.mimeType;
+        }
+        artifacts.push(artifact);
+        cleanedResponse = cleanedResponse.replace(match[0], `${label.trim() || name} `);
+    }
+    const output = {
+        response: cleanedResponse.replace(/[ \t]+\n/g, "\n").replace(/\s{2,}/g, " ").replace(/\n{3,}/g, "\n\n").trim(),
+    };
+    if (artifacts.length > 0) {
+        output.artifacts = artifacts;
+    }
+    return output;
+}
+async function materializeTweetMediaArtifacts(tweet, mediaEntries) {
+    let artifactDir;
+    const reservedNames = new Set();
+    const artifacts = [];
+    try {
+        for (const entry of mediaEntries) {
+            const normalizedMedia = normalizeTweetMediaForDownload(entry.media);
+            let mediaUrl;
+            try {
+                mediaUrl = new URL(normalizedMedia.url);
+            }
+            catch {
+                throw new Error("invalid_media_url");
+            }
+            if (mediaUrl.protocol !== "https:" || !ALLOWED_TWEET_MEDIA_HOSTS.has(mediaUrl.hostname)) {
+                throw new Error(`unsupported_media_url:${mediaUrl.toString()}`);
+            }
+            const response = await fetch(mediaUrl.toString());
+            if (!response.ok) {
+                throw new Error(`media_download_http_${response.status}|${mediaUrl.toString()}`);
+            }
+            const arrayBuffer = await response.arrayBuffer();
+            const contentTypeHeader = response.headers.get("content-type")?.split(";")[0]?.trim() || undefined;
+            const fallbackBase = `${tweet.id}-media-${entry.mediaIndex + 1}`;
+            let name = inferArtifactNameFromUrl(normalizedMedia.url, fallbackBase, contentTypeHeader);
+            if (reservedNames.has(name)) {
+                const extension = extname(name);
+                const stem = extension ? name.slice(0, -extension.length) : name;
+                let suffix = 2;
+                do {
+                    name = `${stem}-${suffix}${extension}`;
+                    suffix += 1;
+                } while (reservedNames.has(name));
+            }
+            reservedNames.add(name);
+            if (!artifactDir) {
+                artifactDir = await mkdtemp(join(tmpdir(), TWEET_MEDIA_ARTIFACT_DIR_PREFIX));
+            }
+            const path = join(artifactDir, name);
+            await writeFile(path, Buffer.from(arrayBuffer));
+            const artifact = {
+                kind: "file",
+                name,
+                path,
+                mediaIndex: entry.mediaIndex,
+                sourceUrl: normalizedMedia.url,
+            };
+            if (contentTypeHeader) {
+                artifact.mimeType = contentTypeHeader;
+            }
+            artifacts.push(artifact);
+        }
+    }
+    catch (error) {
+        if (artifactDir) {
+            await rm(artifactDir, { recursive: true, force: true }).catch(() => { });
+        }
+        throw error;
+    }
+    return artifacts;
+}
+function mapTweetMediaDownloadError(error) {
+    const message = error instanceof Error && error.message ? error.message : "media download failed";
+    if (message.startsWith("media_download_http_")) {
+        const [statusPart = "", urlPart = ""] = message.replace("media_download_http_", "").split("|", 2);
+        const status = Number.parseInt(statusPart, 10);
+        return errorResult("HTTP_ERROR", Number.isFinite(status)
+            ? `media download returned HTTP ${status}`
+            : "media download returned an HTTP error", typeof urlPart === "string" && urlPart ? { url: urlPart } : undefined);
+    }
+    if (message.startsWith("unsupported_media_url:")) {
+        const url = message.slice("unsupported_media_url:".length);
+        return errorResult("VALIDATION_ERROR", "media URL is not on an allowed host", { url });
+    }
+    if (message === "invalid_media_url") {
+        return errorResult("UPSTREAM_CHANGED", "tweet media URL is invalid");
+    }
+    return errorResult("UPSTREAM_CHANGED", message);
+}
+async function resolveGrokAttachments(input) {
+    if (input === undefined) {
+        return { ok: true, attachments: [] };
+    }
+    if (!Array.isArray(input)) {
+        return {
+            ok: false,
+            result: errorResult("VALIDATION_ERROR", "attachmentPaths must be an array"),
+        };
+    }
+    const attachments = [];
+    for (const [index, rawPath] of input.entries()) {
+        const path = typeof rawPath === "string" ? rawPath.trim() : "";
+        if (!path) {
+            return {
+                ok: false,
+                result: errorResult("VALIDATION_ERROR", `attachmentPaths[${index}] must be a non-empty string`),
+            };
+        }
+        if (!isAbsolute(path)) {
+            return {
+                ok: false,
+                result: errorResult("VALIDATION_ERROR", `attachmentPaths[${index}] must be an absolute file path`),
+            };
+        }
+        try {
+            const fileStat = await stat(path);
+            if (!fileStat.isFile()) {
+                return {
+                    ok: false,
+                    result: errorResult("VALIDATION_ERROR", `attachmentPaths[${index}] must point to a file`),
+                };
+            }
+        }
+        catch {
+            return {
+                ok: false,
+                result: errorResult("VALIDATION_ERROR", `attachmentPaths[${index}] was not found`),
+            };
+        }
+        const resolvedAttachment = {
+            path,
+            name: basename(path),
+        };
+        attachments.push(resolvedAttachment);
+    }
+    return { ok: true, attachments };
+}
+function normalizeTimelineLimit(input) {
+    const rawLimit = input.limit;
+    if (typeof rawLimit !== "number" || !Number.isFinite(rawLimit)) {
+        return DEFAULT_TIMELINE_LIMIT;
+    }
+    return Math.max(1, Math.min(MAX_TIMELINE_LIMIT, Math.floor(rawLimit)));
+}
+async function ensureNetworkCaptureInstalled(page) {
+    await page.addInitScript(CAPTURE_INJECT_SCRIPT);
+    await page.evaluate(CAPTURE_INJECT_SCRIPT);
+}
+async function hasCapturedTemplate(page, mode) {
+    const result = await page.evaluate(({ targetMode }) => {
+        const globalAny = window;
+        const entries = Array.isArray(globalAny.__WEBMCP_X_CAPTURE__?.entries)
+            ? globalAny.__WEBMCP_X_CAPTURE__?.entries ?? []
+            : [];
+        const ops = targetMode === "home"
+            ? ["HomeTimeline", "TweetDetail"]
+            : targetMode === "bookmarks"
+                ? ["BookmarksAll", "Bookmarks"]
+                : targetMode === "tweet"
+                    ? ["TweetDetail"]
+                    : targetMode === "user_timeline"
+                        ? ["UserTweets", "UserTweetsAndReplies", "UserMedia"]
+                        : ["SearchTimeline"];
+        for (let i = entries.length - 1; i >= 0; i -= 1) {
+            const entry = entries[i];
+            if (entry && typeof entry.op === "string" && ops.includes(entry.op)) {
+                return true;
+            }
+        }
+        return false;
+    }, { targetMode: mode });
+    return result === true;
+}
+async function warmupNetworkTemplate(page, mode) {
+    if (await hasCapturedTemplate(page, mode)) {
+        return;
+    }
+    await waitForTweetSurface(page);
+    await page
+        .evaluate(() => {
+        window.scrollTo(0, Math.max(document.body.scrollHeight * 0.8, 1200));
+    })
+        .catch(() => { });
+    await page.waitForTimeout(900);
+    if (await hasCapturedTemplate(page, mode)) {
+        return;
+    }
+    await page
+        .evaluate(() => {
+        window.scrollTo(0, 0);
+    })
+        .catch(() => { });
+    await page.waitForTimeout(700);
+    if (await hasCapturedTemplate(page, mode)) {
+        return;
+    }
+    await page.reload({ waitUntil: "domcontentloaded", timeout: 60_000 }).catch(() => { });
+    await waitForTweetSurface(page);
+}
+async function detectAuth(page) {
+    return await page.evaluate(({ op }) => {
+        void op;
+        const signals = [];
+        const challengeSelectors = [
+            "form[action*='account/access']",
+            "input[name='verification_string']",
+            "iframe[title*='challenge']",
+        ];
+        const loginSelectors = [
+            "input[name='text']",
+            "input[autocomplete='username']",
+            "a[href='/login']",
+            "a[href*='/i/flow/login']",
+        ];
+        const authenticatedSelectors = [
+            "[data-testid='AppTabBar_Home_Link']",
+            "[data-testid='SideNav_NewTweet_Button']",
+            "[data-testid='tweetTextarea_0']",
+            "nav[aria-label='Primary']",
+        ];
+        const hasSelector = (selectors) => {
+            return selectors.some((selector) => document.querySelector(selector) !== null);
+        };
+        const bodyText = (document.body?.innerText ?? "").toLowerCase();
+        const pathname = location.pathname.toLowerCase();
+        const hasChallengeUi = hasSelector(challengeSelectors) ||
+            pathname.includes("/account/access") ||
+            bodyText.includes("are you human") ||
+            bodyText.includes("unusual activity") ||
+            bodyText.includes("challenge");
+        if (hasChallengeUi) {
+            signals.push("challenge_ui");
+            return { state: "challenge_required", signals };
+        }
+        if (hasSelector(authenticatedSelectors)) {
             signals.push("authenticated_ui");
             return { state: "authenticated", signals };
         }
@@ -505,8 +908,97 @@ async function warmupAuthProbe(page) {
         await page.waitForTimeout(AUTH_STABILIZE_DELAY_MS);
     }
 }
+function normalizeInlineText(value) {
+    return value.replace(/\s+/g, " ").trim();
+}
+function canonicalizeStatusUrl(input, fallbackId) {
+    if (!input) {
+        return undefined;
+    }
+    try {
+        const url = new URL(input);
+        const segments = url.pathname.split("/").filter(Boolean);
+        const statusIndex = segments.findIndex((segment) => segment === "status");
+        if (statusIndex < 0) {
+            return input;
+        }
+        const statusId = segments[statusIndex + 1] ?? fallbackId;
+        if (!statusId) {
+            return input;
+        }
+        if (segments[0] === "i" && segments[1] === "web") {
+            return `${url.origin}/i/web/status/${statusId}`;
+        }
+        const handle = segments[0];
+        if (!handle) {
+            return `${url.origin}/i/web/status/${statusId}`;
+        }
+        return `${url.origin}/${handle}/status/${statusId}`;
+    }
+    catch {
+        return input;
+    }
+}
+function enrichNotificationItem(item) {
+    const text = normalizeInlineText(item.text);
+    const summary = item.summary ? normalizeInlineText(item.summary) : undefined;
+    const tweetText = item.tweetText ? normalizeInlineText(item.tweetText) : undefined;
+    const next = {
+        id: item.id,
+        text,
+    };
+    if (item.url) {
+        next.url = item.url;
+    }
+    if (summary) {
+        next.summary = summary;
+    }
+    if (tweetText) {
+        next.tweetText = tweetText;
+    }
+    if (item.media && item.media.length > 0) {
+        next.media = item.media;
+    }
+    if (item.kind) {
+        next.kind = item.kind;
+    }
+    const likeMatch = text.match(/^(.+?liked your post·\s*\S+)\s+(?:Article\s+)?(.+)$/i);
+    if (likeMatch?.[1] && likeMatch[2]) {
+        next.kind = next.kind ?? "like";
+        next.summary = next.summary ?? normalizeInlineText(likeMatch[1]);
+        next.tweetText = next.tweetText ?? normalizeInlineText(likeMatch[2]);
+        next.text = next.tweetText;
+        return next;
+    }
+    const repostMatch = text.match(/^(.+?reposted(?: your post)?·\s*\S+)\s+(.+)$/i);
+    if (repostMatch?.[1] && repostMatch[2]) {
+        next.kind = next.kind ?? "repost";
+        next.summary = next.summary ?? normalizeInlineText(repostMatch[1]);
+        next.tweetText = next.tweetText ?? normalizeInlineText(repostMatch[2]);
+        next.text = next.tweetText;
+        return next;
+    }
+    const replyMatch = text.match(/^(.+?Replying to @\w+(?:.*?·\s*\S+)?)\s+(.+)$/i);
+    if (replyMatch?.[1] && replyMatch[2]) {
+        next.kind = next.kind ?? "reply";
+        next.summary = next.summary ?? normalizeInlineText(replyMatch[1]);
+        next.tweetText = next.tweetText ?? normalizeInlineText(replyMatch[2]);
+        next.text = next.tweetText;
+        return next;
+    }
+    const followMatch = text.match(/^(.+?followed you(?:·\s*\S+)?)$/i);
+    if (followMatch?.[1]) {
+        next.kind = next.kind ?? "follow";
+        next.summary = next.summary ?? normalizeInlineText(followMatch[1]);
+        return next;
+    }
+    if (!next.kind && next.url) {
+        next.kind = "mention";
+    }
+    return next;
+}
 const READ_PAGE_CACHE = new WeakMap();
-const PROCESS_TEMPLATE_CACHE = new Map();
+const PROCESS_TEMPLATE_CACHE = new TemplateCache();
 async function readTimelineViaNetwork(page, options) {
     const fallbackTemplate = PROCESS_TEMPLATE_CACHE.get(options.mode);
     const response = await page.evaluate(async ({ mode, limit, cursor: inputCursor, tweetId, cachedTemplate }) => {
@@ -560,6 +1052,82 @@ async function readTimelineViaNetwork(page, options) {
             }
         };
         const normalizeText = (value) => value.replace(/\s+/g, " ").trim();
+        const collectMedia = (value) => {
+            if (!Array.isArray(value)) {
+                return [];
+            }
+            const output = [];
+            for (const rawEntry of value) {
+                if (!rawEntry || typeof rawEntry !== "object" || Array.isArray(rawEntry)) {
+                    continue;
+                }
+                const entry = rawEntry;
+                const type = entry.type;
+                const mediaUrlHttps = typeof entry.media_url_https === "string" ? entry.media_url_https : "";
+                const mediaUrl = typeof entry.media_url === "string" ? entry.media_url : "";
+                const previewUrl = mediaUrlHttps || mediaUrl;
+                if (type !== "photo" && type !== "video" && type !== "animated_gif") {
+                    continue;
+                }
+                const originalInfo = entry.original_info ?? {};
+                const nextMedia = {
+                    type,
+                    url: previewUrl,
+                };
+                if (previewUrl) {
+                    nextMedia.previewUrl = previewUrl;
+                }
+                if (typeof originalInfo.w === "number" && Number.isFinite(originalInfo.w)) {
+                    nextMedia.width = originalInfo.w;
+                }
+                if (typeof originalInfo.h === "number" && Number.isFinite(originalInfo.h)) {
+                    nextMedia.height = originalInfo.h;
+                }
+                if (type === "video" || type === "animated_gif") {
+                    const videoInfo = entry.video_info ?? {};
+                    if (typeof videoInfo.duration_millis === "number" && Number.isFinite(videoInfo.duration_millis)) {
+                        nextMedia.durationMs = videoInfo.duration_millis;
+                    }
+                    const variants = Array.isArray(videoInfo.variants) ? videoInfo.variants : [];
+                    const normalizedVariants = variants.flatMap((rawVariant) => {
+                        if (!rawVariant || typeof rawVariant !== "object" || Array.isArray(rawVariant)) {
+                            return [];
+                        }
+                        const variant = rawVariant;
+                        const variantUrl = typeof variant.url === "string" ? variant.url : "";
+                        if (!variantUrl) {
+                            return [];
+                        }
+                        const nextVariant = { url: variantUrl };
+                        if (typeof variant.content_type === "string" && variant.content_type) {
+                            nextVariant.contentType = variant.content_type;
+                        }
+                        if (typeof variant.bitrate === "number" && Number.isFinite(variant.bitrate)) {
+                            nextVariant.bitrate = variant.bitrate;
+                        }
+                        return [nextVariant];
+                    });
+                    if (normalizedVariants.length > 0) {
+                        nextMedia.variants = normalizedVariants;
+                        const mp4Variants = normalizedVariants.filter((variant) => variant.contentType === "video/mp4");
+                        const preferredVariant = (mp4Variants.length > 0 ? mp4Variants : normalizedVariants)
+                            .slice()
+                            .sort((left, right) => {
+                            const leftBitrate = typeof left.bitrate === "number" ? left.bitrate : -1;
+                            const rightBitrate = typeof right.bitrate === "number" ? right.bitrate : -1;
+                            return rightBitrate - leftBitrate;
+                        })[0];
+                        if (preferredVariant && typeof preferredVariant.url === "string" && preferredVariant.url) {
+                            nextMedia.url = preferredVariant.url;
+                        }
+                    }
+                }
+                if (typeof nextMedia.url === "string" && nextMedia.url) {
+                    output.push(nextMedia);
+                }
+            }
+            return output;
+        };
         const collectFromResult = (input) => {
             const outputItems = [];
             const seen = new Set();
@@ -601,6 +1169,8 @@ async function readTimelineViaNetwork(page, options) {
                 }
                 const restId = typeof tweet?.rest_id === "string" ? tweet.rest_id : "";
                 const legacy = tweet?.legacy ?? {};
+                const entities = legacy.entities ?? {};
+                const extendedEntities = legacy.extended_entities ?? entities;
                 const fullText = typeof legacy.full_text === "string"
                     ? legacy.full_text
                     : typeof legacy.text === "string"
@@ -609,6 +1179,7 @@ async function readTimelineViaNetwork(page, options) {
                 const noteText = tweet?.note_tweet?.note_tweet_results
                     ?.result?.text;
                 const text = normalizeText(typeof noteText === "string" && noteText ? noteText : fullText);
+                const media = collectMedia(extendedEntities.media);
                 if (restId && text) {
                     const userResult = tweet?.core?.user_results
                         ?.result ?? {};
@@ -630,6 +1201,9 @@ async function readTimelineViaNetwork(page, options) {
                         if (createdAt) {
                             item.createdAt = createdAt;
                         }
+                        if (media.length > 0) {
+                            item.media = toTweetMediaArray(media);
+                        }
                         outputItems.push(item);
                     }
                 }
@@ -648,6 +1222,9 @@ async function readTimelineViaNetwork(page, options) {
             const blockedPrefixes = ["sec-", ":"];
             const blockedExact = new Set(["host", "content-length", "cookie", "origin", "referer", "connection"]);
             const output = {};
+            if (!headers) {
+                return output;
+            }
             for (const [key, value] of Object.entries(headers)) {
                 const k = key.toLowerCase();
                 if (blockedExact.has(k)) {
@@ -744,15 +1321,16 @@ async function readTimelineViaNetwork(page, options) {
     const selectedTemplate = typed.selectedTemplate;
     if (selectedTemplate &&
         typeof selectedTemplate.url === "string" &&
-        typeof selectedTemplate.method === "string" &&
-        typeof selectedTemplate.headers === "object" &&
-        selectedTemplate.headers !== null &&
-        !Array.isArray(selectedTemplate.headers)) {
+        typeof selectedTemplate.method === "string") {
         const cacheValue = {
             url: selectedTemplate.url,
             method: selectedTemplate.method,
-            headers: selectedTemplate.headers,
         };
+        if (typeof selectedTemplate.headers === "object" &&
+            selectedTemplate.headers !== null &&
+            !Array.isArray(selectedTemplate.headers)) {
+            cacheValue.headers = selectedTemplate.headers;
+        }
         if (typeof selectedTemplate.body === "string") {
             cacheValue.body = selectedTemplate.body;
         }
@@ -773,8 +1351,87 @@ async function readTimelineViaNetwork(page, options) {
 async function extractTweetCards(page, limit) {
     const cards = await page.evaluate(({ maxItems }) => {
         const normalize = (value) => value.replace(/\s+/g, " ").trim();
+        const cleanText = (value) => {
+            return normalize(value
+                .replace(/\bPromote\b/gi, " ")
+                .replace(/\bShow translation\b/gi, " ")
+                .replace(/\bRelevant View activity\b/gi, " ")
+                .replace(/\bPost your reply\b/gi, " ")
+                .replace(/\bReply\b$/gi, " ")
+                .replace(/\bShow more replies\b/gi, " "));
+        };
+        const canonicalizeStatusUrl = (input, fallbackId) => {
+            if (!input) {
+                return undefined;
+            }
+            try {
+                const url = new URL(input);
+                const segments = url.pathname.split("/").filter(Boolean);
+                const statusIndex = segments.findIndex((segment) => segment === "status");
+                if (statusIndex < 0) {
+                    return input;
+                }
+                const statusId = segments[statusIndex + 1] ?? fallbackId;
+                if (!statusId) {
+                    return input;
+                }
+                if (segments[0] === "i" && segments[1] === "web") {
+                    return `${url.origin}/i/web/status/${statusId}`;
+                }
+                const handle = segments[0];
+                if (!handle) {
+                    return `${url.origin}/i/web/status/${statusId}`;
+                }
+                return `${url.origin}/${handle}/status/${statusId}`;
+            }
+            catch {
+                return input;
+            }
+        };
         const dedupe = new Set();
         const items = [];
+        const collectDomMedia = (root) => {
+            const output = [];
+            const seen = new Set();
+            const pushMedia = (entry) => {
+                const key = `${String(entry.type ?? "")}:${String(entry.url ?? "")}`;
+                if (!entry.url || seen.has(key)) {
+                    return;
+                }
+                seen.add(key);
+                output.push(entry);
+            };
+            const imageNodes = Array.from(root.querySelectorAll("img[src*='pbs.twimg.com/media']"));
+            for (const image of imageNodes) {
+                const src = image.currentSrc || image.src || "";
+                if (!src) {
+                    continue;
+                }
+                const media = {
+                    type: "photo",
+                    url: src,
+                };
+                if (Number.isFinite(image.naturalWidth) && image.naturalWidth > 0) {
+                    media.width = image.naturalWidth;
+                }
+                if (Number.isFinite(image.naturalHeight) && image.naturalHeight > 0) {
+                    media.height = image.naturalHeight;
+                }
+                pushMedia(media);
+            }
+            const videoNodes = Array.from(root.querySelectorAll("video[src], video source[src]"));
+            for (const node of videoNodes) {
+                const src = (node instanceof HTMLSourceElement ? node.src : node.currentSrc || node.src) || "";
+                if (!src) {
+                    continue;
+                }
+                pushMedia({
+                    type: "video",
+                    url: src,
+                });
+            }
+            return output;
+        };
         const pushItem = (item) => {
             const dedupeKey = `${item.id}:${item.text}`;
             if (!item.text || dedupe.has(dedupeKey)) {
@@ -786,11 +1443,12 @@ async function extractTweetCards(page, limit) {
         const articles = Array.from(document.querySelectorAll("article"));
         for (const article of articles) {
             const statusAnchor = article.querySelector("a[href*='/status/']");
-            const url = statusAnchor?.href;
+            const matchedId = statusAnchor?.href?.match(/status\/(\d+)/)?.[1];
+            const url = canonicalizeStatusUrl(statusAnchor?.href, matchedId);
             const id = url?.match(/status\/(\d+)/)?.[1] ?? `article-${items.length + 1}`;
-            const textNodes = Array.from(article.querySelectorAll("[data-testid='tweetText'], div[lang], div[dir='auto']"));
-            const mergedText = normalize(textNodes.map((n) => n.textContent || "").join(" "));
-            const fallbackText = normalize(article.textContent || "");
+            const tweetTextNode = article.querySelector("[data-testid='tweetText']");
+            const mergedText = cleanText(tweetTextNode?.innerText || tweetTextNode?.textContent || "");
+            const fallbackText = cleanText(article.innerText || article.textContent || "");
             const text = mergedText || fallbackText;
             if (!text) {
                 continue;
@@ -808,6 +1466,10 @@ async function extractTweetCards(page, limit) {
             if (createdAtRaw) {
                 item.createdAt = createdAtRaw;
             }
+            const media = collectDomMedia(article);
+            if (media.length > 0) {
+                item.media = toTweetMediaArray(media);
+            }
             pushItem(item);
             if (items.length >= maxItems) {
                 break;
@@ -819,22 +1481,28 @@ async function extractTweetCards(page, limit) {
                 if (items.length >= maxItems) {
                     break;
                 }
-                const text = normalize(cell.innerText || cell.textContent || "");
+                const tweetTextNode = cell.querySelector("[data-testid='tweetText']");
+                const text = cleanText(tweetTextNode?.innerText || tweetTextNode?.textContent || cell.innerText || cell.textContent || "");
                 if (!text || text.length < 16) {
                     continue;
                 }
                 const statusAnchor = cell.querySelector("a[href*='/status/']");
-                const url = statusAnchor?.href;
+                const matchedId = statusAnchor?.href?.match(/status\/(\d+)/)?.[1];
+                const url = canonicalizeStatusUrl(statusAnchor?.href, matchedId);
                 const id = url?.match(/status\/(\d+)/)?.[1] ?? `cell-${items.length + 1}`;
                 const item = { id, text };
                 if (url) {
                     item.url = url;
                 }
+                const media = collectDomMedia(cell);
+                if (media.length > 0) {
+                    item.media = toTweetMediaArray(media);
+                }
                 pushItem(item);
             }
         }
         if (items.length === 0) {
-            const bodyText = normalize(document.body?.innerText || "");
+            const bodyText = cleanText(document.body?.innerText || "");
             if (bodyText) {
                 const snippet = bodyText.slice(0, 280);
                 pushItem({
@@ -847,6 +1515,181 @@ async function extractTweetCards(page, limit) {
     }, { maxItems: limit });
     return cards;
 }
+async function scrollTweetDetailSurface(page) {
+    return await page.evaluate(({ op }) => {
+        void op;
+        const viewportHeight = window.innerHeight || 0;
+        const scrollHeight = Math.max(document.documentElement?.scrollHeight ?? 0, document.body?.scrollHeight ?? 0);
+        const beforeY = window.scrollY;
+        const maxScrollY = Math.max(0, scrollHeight - viewportHeight);
+        const delta = Math.max(Math.floor(viewportHeight * 0.9), 900);
+        const targetY = Math.min(beforeY + delta, maxScrollY);
+        window.scrollTo({ top: targetY, behavior: "instant" });
+        return targetY > beforeY;
+    }, { op: "scroll_tweet_detail_surface" });
+}
+async function extractTweetCardsAcrossScroll(page, limit) {
+    let merged = mergeTimelineItems(mapTweetCards(await extractTweetCards(page, limit)));
+    let stagnantIterations = 0;
+    for (let attempt = 0; attempt < 6 && merged.length < limit; attempt += 1) {
+        const didScroll = await scrollTweetDetailSurface(page);
+        if (!didScroll) {
+            break;
+        }
+        await page.waitForTimeout(1_000);
+        const nextCards = mergeTimelineItems([...merged, ...mapTweetCards(await extractTweetCards(page, limit))]);
+        if (nextCards.length <= merged.length) {
+            stagnantIterations += 1;
+            if (stagnantIterations >= 2) {
+                break;
+            }
+        }
+        else {
+            stagnantIterations = 0;
+        }
+        merged = nextCards;
+    }
+    const hasCanonicalStatusItem = merged.some((item) => Boolean(item.url?.includes("/status/")));
+    if (hasCanonicalStatusItem) {
+        merged = merged.filter((item) => !item.id.startsWith("fallback-body-"));
+    }
+    return merged.slice(0, limit).map((item) => {
+        const nextItem = {
+            id: item.id,
+            text: item.text,
+        };
+        if (item.url) {
+            nextItem.url = item.url;
+        }
+        if (item.media && item.media.length > 0) {
+            nextItem.media = item.media;
+        }
+        return nextItem;
+    });
+}
+async function extractNotificationCards(page, limit) {
+    return await page.evaluate(({ op, maxItems }) => {
+        if (op !== "extract_notifications") {
+            return [];
+        }
+        const normalize = (value) => value.replace(/\s+/g, " ").trim();
+        const classifySummary = (value) => {
+            const text = value.toLowerCase();
+            if (text.includes("followed you"))
+                return "follow";
+            if (text.includes("liked your post"))
+                return "like";
+            if (text.includes("reposted your post") || text.includes("reposted"))
+                return "repost";
+            if (text.includes("replying to @") || text.includes("replied"))
+                return "reply";
+            if (text.includes("@"))
+                return "mention";
+            return "notification";
+        };
+        const isGenericHelperText = (value) => {
+            const text = value.toLowerCase();
+            return (text.includes("control which conversations you're mentioned in") ||
+                text.includes("control which conversations you’re mentioned in") ||
+                (text.includes("learn more") && text.includes("mentioned")));
+        };
+        const scoreItem = (value) => {
+            const text = normalize(value.text);
+            let score = text.length;
+            if (value.summary) {
+                score += 100;
+            }
+            if (value.tweetText) {
+                score += 60;
+            }
+            return score;
+        };
+        const pickPreferred = (current, next) => {
+            if (!current) {
+                return next;
+            }
+            return scoreItem(next) > scoreItem(current) ? next : current;
+        };
+        const byKey = new Map();
+        const pushItem = (item) => {
+            const text = normalize(item.text);
+            if (!text || isGenericHelperText(text)) {
+                return;
+            }
+            const normalizedItem = {
+                id: item.id,
+                text,
+            };
+            if (item.url) {
+                normalizedItem.url = item.url;
+            }
+            if (item.kind) {
+                normalizedItem.kind = item.kind;
+            }
+            if (item.summary) {
+                normalizedItem.summary = normalize(item.summary);
+            }
+            if (item.tweetText) {
+                normalizedItem.tweetText = normalize(item.tweetText);
+            }
+            const dedupeKey = item.url ? `url:${item.url}` : `text:${text.toLowerCase()}`;
+            byKey.set(dedupeKey, pickPreferred(byKey.get(dedupeKey), normalizedItem));
+        };
+        const articles = Array.from(document.querySelectorAll("article"));
+        for (const article of articles) {
+            const statusAnchor = article.querySelector("a[href*='/status/']");
+            const url = statusAnchor?.href;
+            const id = url?.match(/status\/(\d+)/)?.[1] ?? `article-${byKey.size + 1}`;
+            const textNodes = Array.from(article.querySelectorAll("[data-testid='tweetText'], div[lang], div[dir='auto']"));
+            const tweetText = normalize(textNodes.map((node) => node.textContent || "").join(" "));
+            const fallbackText = normalize(article.innerText || article.textContent || "");
+            const summary = tweetText ? normalize(fallbackText.replace(tweetText, "")) : "";
+            const item = {
+                id,
+                text: tweetText || fallbackText,
+            };
+            if (url) {
+                item.url = url;
+            }
+            if (summary) {
+                item.summary = summary;
+                item.kind = classifySummary(summary);
+            }
+            if (tweetText) {
+                item.tweetText = tweetText;
+            }
+            pushItem(item);
+        }
+        if (byKey.size < maxItems) {
+            const cells = Array.from(document.querySelectorAll("[data-testid='cellInnerDiv']"));
+            for (const cell of cells) {
+                const fallbackText = normalize(cell.innerText || cell.textContent || "");
+                const tweetNode = cell.querySelector("[data-testid='tweetText'], div[lang], div[dir='auto']");
+                const tweetText = normalize(tweetNode?.innerText || tweetNode?.textContent || "");
+                const summary = tweetText ? normalize(fallbackText.replace(tweetText, "")) : "";
+                const statusAnchor = cell.querySelector("a[href*='/status/']");
+                const url = statusAnchor?.href;
+                const id = url?.match(/status\/(\d+)/)?.[1] ?? `cell-${byKey.size + 1}`;
+                const item = {
+                    id,
+                    text: tweetText || fallbackText,
+                };
+                if (url) {
+                    item.url = url;
+                }
+                if (summary) {
+                    item.summary = summary;
+                    item.kind = classifySummary(summary);
+                }
+                if (tweetText) {
+                    item.tweetText = tweetText;
+                }
+                pushItem(item);
+            }
+        }
+        return Array.from(byKey.values()).slice(0, maxItems);
+    }, { op: "extract_notifications", maxItems: limit });
+}
 async function withEphemeralReadOnlyPage(page, url, run) {
     const context = page.context();
     const readPage = await context.newPage();
@@ -860,6 +1703,18 @@ async function withEphemeralReadOnlyPage(page, url, run) {
         await readPage.close().catch(() => { });
     }
 }
+async function withEphemeralPage(page, url, run) {
+    const context = page.context();
+    const ephemeralPage = await context.newPage();
+    try {
+        await ensureNetworkCaptureInstalled(ephemeralPage);
+        await ephemeralPage.goto(url, { waitUntil: "domcontentloaded", timeout: 60_000 });
+        return await run(ephemeralPage);
+    }
+    finally {
+        await ephemeralPage.close().catch(() => { });
+    }
+}
 function getReadPageCacheState(page) {
     let state = READ_PAGE_CACHE.get(page);
     if (!state) {
@@ -956,9 +1811,109 @@ function mapTweetCards(items) {
         if (item.url) {
             mapped.url = item.url;
         }
+        if (item.media && item.media.length > 0) {
+            mapped.media = item.media;
+        }
         return mapped;
     });
 }
+function getTimelineStatusId(item) {
+    if (item.id && !item.id.startsWith("article-") && !item.id.startsWith("cell-")) {
+        return item.id;
+    }
+    return item.url?.match(/status\/(\d+)/)?.[1] ?? "";
+}
+function getTimelineDedupeKey(item) {
+    const statusId = getTimelineStatusId(item);
+    if (statusId) {
+        return `id:${statusId}`;
+    }
+    if (item.url) {
+        return `url:${item.url}`;
+    }
+    return `text:${item.text}`;
+}
+function pickPreferredTimelineItem(current, next) {
+    if (!current) {
+        return next;
+    }
+    const score = (item) => {
+        let total = item.text.length;
+        if (item.url) {
+            total += 10;
+            if (canonicalizeStatusUrl(item.url, item.id) === item.url) {
+                total += 20;
+            }
+        }
+        if (item.media && item.media.length > 0) {
+            total += item.media.length * 15;
+        }
+        if (item.text.includes("Post your reply") || item.text.includes("Relevant View activity")) {
+            total -= 80;
+        }
+        return total;
+    };
+    const currentScore = score(current);
+    const nextScore = score(next);
+    return nextScore > currentScore ? next : current;
+}
+function mergeTimelineItems(items) {
+    const order = [];
+    const merged = new Map();
+    for (const item of items) {
+        const key = getTimelineDedupeKey(item);
+        if (!merged.has(key)) {
+            order.push(key);
+        }
+        merged.set(key, pickPreferredTimelineItem(merged.get(key), item));
+    }
+    return order.map((key) => merged.get(key)).filter((item) => Boolean(item));
+}
+function extractHandleFromStatusUrl(url) {
+    if (!url) {
+        return "";
+    }
+    try {
+        const parsed = new URL(url);
+        const segments = parsed.pathname.split("/").filter(Boolean);
+        if (segments[0] === "i" && segments[1] === "web") {
+            return "";
+        }
+        const handle = segments[0] ?? "";
+        return handle.replace(/^@+/, "").trim().toLowerCase();
+    }
+    catch {
+        return "";
+    }
+}
+function buildConversationPayload(items, focalStatusId, replyLimit, source, nextCursor, debugReason) {
+    const focalIndex = items.findIndex((item) => getTimelineStatusId(item) === focalStatusId);
+    if (focalIndex < 0) {
+        return errorResult("UPSTREAM_CHANGED", "focal tweet not found in conversation");
+    }
+    const focal = items[focalIndex];
+    if (!focal) {
+        return errorResult("UPSTREAM_CHANGED", "focal tweet not found in conversation");
+    }
+    const ancestors = items.slice(0, focalIndex);
+    const allReplies = items.slice(focalIndex + 1);
+    const replies = allReplies.slice(0, replyLimit);
+    const output = {
+        focal,
+        ancestors,
+        replies,
+        source,
+        hasMore: allReplies.length > replyLimit,
+    };
+    if (nextCursor) {
+        output.nextCursor = nextCursor;
+        output.hasMore = true;
+    }
+    if (source === "dom" && debugReason) {
+        output.debug = { reason: debugReason };
+    }
+    return output;
+}
 function toTimelinePageFromNetwork(input) {
     const result = {
         items: mapTweetCards(input.items),
@@ -1020,22 +1975,157 @@ async function readTweetByUrl(page, url) {
         if (matchId) {
             const fromNetwork = await readTimelineViaNetwork(readPage, {
                 mode: "tweet",
-                limit: 1,
+                limit: Math.max(DEFAULT_TIMELINE_LIMIT, 20),
                 tweetId: matchId,
             });
-            const first = fromNetwork.items[0];
-            if (first) {
-                return { tweet: first };
+            const matched = fromNetwork.items.find((item) => item.id === matchId) ?? fromNetwork.items[0];
+            if (matched) {
+                return { tweet: matched };
             }
         }
-        const cards = await extractTweetCards(readPage, 1);
-        const tweet = cards[0];
+        const cards = await extractTweetCardsAcrossScroll(readPage, 20);
+        const tweet = (matchId ? cards.find((item) => item.id === matchId) : undefined) ?? cards[0];
         if (!tweet) {
             return errorResult("UPSTREAM_CHANGED", "tweet content not found");
         }
         return { tweet };
     });
 }
+async function downloadTweetMediaByUrl(page, url, mediaIndex) {
+    const tweetResult = await readTweetByUrl(page, url);
+    if (!tweetResult || typeof tweetResult !== "object" || !("tweet" in tweetResult)) {
+        return tweetResult;
+    }
+    const tweet = tweetResult.tweet;
+    const media = Array.isArray(tweet.media) ? tweet.media : [];
+    if (media.length === 0) {
+        return errorResult("NO_MEDIA", "tweet has no downloadable media");
+    }
+    if (mediaIndex !== undefined && (!Number.isInteger(mediaIndex) || mediaIndex < 0)) {
+        return errorResult("VALIDATION_ERROR", "mediaIndex must be a non-negative integer");
+    }
+    if (mediaIndex !== undefined && mediaIndex >= media.length) {
+        return errorResult("VALIDATION_ERROR", "mediaIndex is out of range");
+    }
+    const selectedEntries = mediaIndex === undefined
+        ? media.map((entry, index) => ({ mediaIndex: index, media: entry }))
+        : [{ mediaIndex, media: media[mediaIndex] }];
+    try {
+        const artifacts = await materializeTweetMediaArtifacts(tweet, selectedEntries);
+        return {
+            tweet,
+            items: selectedEntries.map((entry, index) => ({
+                mediaIndex: entry.mediaIndex,
+                media: entry.media,
+                artifact: artifacts[index],
+            })),
+        };
+    }
+    catch (error) {
+        return mapTweetMediaDownloadError(error);
+    }
+}
+async function readTweetConversationByUrl(page, url, limit, cursor) {
+    return await withEphemeralReadOnlyPage(page, url, async (readPage) => {
+        const matchId = url.match(/status\/(\d+)/)?.[1];
+        if (!matchId) {
+            return errorResult("VALIDATION_ERROR", "tweet id could not be derived from url");
+        }
+        const merged = [];
+        let source = "dom";
+        const request = {
+            mode: "tweet",
+            limit,
+            tweetId: matchId,
+        };
+        if (cursor) {
+            request.cursor = cursor;
+        }
+        const fromNetwork = await readTimelineViaNetwork(readPage, request);
+        if (fromNetwork.items.length > 0) {
+            merged.push(...mapTweetCards(fromNetwork.items));
+            source = "network";
+        }
+        if (!cursor) {
+            const domCards = await extractTweetCardsAcrossScroll(readPage, Math.max(limit + 1, 20));
+            merged.push(...mapTweetCards(domCards));
+        }
+        const conversationItems = mergeTimelineItems(merged);
+        if (conversationItems.length === 0) {
+            return errorResult("UPSTREAM_CHANGED", "tweet conversation content not found");
+        }
+        return buildConversationPayload(conversationItems, matchId, limit, source, fromNetwork.nextCursor, fromNetwork.reason ?? (source === "dom" ? "dom_fallback" : undefined));
+    });
+}
+async function readTweetRepliesByUrl(page, url, limit, cursor) {
+    const conversation = await readTweetConversationByUrl(page, url, limit, cursor);
+    if (!conversation || typeof conversation !== "object" || !("focal" in conversation) || !("replies" in conversation)) {
+        return conversation;
+    }
+    const typed = conversation;
+    const output = {
+        focal: typed.focal,
+        items: typed.replies.slice(0, limit),
+        source: typed.source,
+        hasMore: typed.hasMore,
+    };
+    if (typed.nextCursor) {
+        output.nextCursor = typed.nextCursor;
+    }
+    if (typed.debug) {
+        output.debug = typed.debug;
+    }
+    return output;
+}
+async function readTweetThreadByUrl(page, url, limit) {
+    const conversation = await readTweetConversationByUrl(page, url, Math.max(limit, 20));
+    if (!conversation || typeof conversation !== "object" || !("focal" in conversation)) {
+        return conversation;
+    }
+    const typed = conversation;
+    const focalHandle = extractHandleFromStatusUrl(typed.focal.url);
+    const threadItems = mergeTimelineItems([...typed.ancestors, typed.focal, ...typed.replies].filter((item) => {
+        if (!focalHandle) {
+            return true;
+        }
+        return extractHandleFromStatusUrl(item.url) === focalHandle;
+    })).slice(0, limit);
+    if (threadItems.length === 0) {
+        return errorResult("UPSTREAM_CHANGED", "tweet conversation content not found");
+    }
+    const root = threadItems[0];
+    if (!root) {
+        return errorResult("UPSTREAM_CHANGED", "tweet thread content not found");
+    }
+    const output = {
+        root,
+        focal: typed.focal,
+        tweets: threadItems,
+        source: typed.source,
+    };
+    if (typed.hasMore) {
+        output.incomplete = true;
+    }
+    if (typed.nextCursor) {
+        output.nextCursor = typed.nextCursor;
+    }
+    if (typed.debug) {
+        output.debug = typed.debug;
+    }
+    return output;
+}
+async function readNotifications(page, limit) {
+    await waitForTweetSurface(page);
+    const cards = await extractNotificationCards(page, limit);
+    return {
+        items: cards.map(enrichNotificationItem),
+        source: "dom",
+        hasMore: false,
+        debug: {
+            reason: "notifications_dom",
+        },
+    };
+}
 async function readProfile(page, handle) {
     const normalizedHandle = handle.replace(/^@+/, "").trim();
     const profileUrl = `https://x.com/${normalizedHandle}`;
@@ -1235,82 +2325,1179 @@ async function waitForComposeConfirmation(page, text, timeoutMs) {
     }
     return { confirmed: true };
 }
-async function requireAuthenticated(page) {
-    const auth = await detectAuthStable(page);
-    if (auth.state === "authenticated") {
-        return { ok: true, auth };
+async function ensureReplyComposerReady(page) {
+    const composerSelectors = [
+        "div[data-testid='tweetTextarea_0']",
+        "div[role='textbox'][data-testid='tweetTextarea_0']",
+        "div[role='textbox'][aria-label*='Post text']",
+        "div[role='textbox'][aria-label*='Reply']",
+        "div[role='textbox'][aria-label*='Post your reply']",
+    ];
+    const openReplySelectors = [
+        "[data-testid='reply']",
+        "[data-testid='replyButton']",
+        "button[aria-label*='Reply']",
+        "div[role='button'][aria-label*='Reply']",
+    ];
+    for (const selector of composerSelectors) {
+        const handle = await page.waitForSelector(selector, { timeout: 800 }).catch(() => null);
+        if (handle) {
+            await handle.dispose();
+            return;
+        }
     }
-    if (auth.state === "challenge_required") {
+    await page
+        .evaluate((selectors) => {
+        for (const selector of selectors) {
+            const element = document.querySelector(selector);
+            if (element) {
+                element.click();
+                return;
+            }
+        }
+    }, openReplySelectors)
+        .catch(() => { });
+    for (const selector of composerSelectors) {
+        const handle = await page.waitForSelector(selector, { timeout: 2500 }).catch(() => null);
+        if (handle) {
+            await handle.dispose();
+            return;
+        }
+    }
+}
+async function composeReply(page, text, dryRun) {
+    const composerSelectors = [
+        "div[data-testid='tweetTextarea_0']",
+        "div[role='textbox'][data-testid='tweetTextarea_0']",
+        "div[role='textbox'][aria-label*='Reply']",
+        "div[role='textbox'][aria-label*='Post your reply']",
+        "div[role='textbox'][aria-label*='Post text']",
+    ];
+    const selectAllShortcut = process.platform === "darwin" ? "Meta+A" : "Control+A";
+    let composerSelector;
+    for (const selector of composerSelectors) {
+        const handle = await page.waitForSelector(selector, { timeout: 800 }).catch(() => null);
+        if (!handle) {
+            continue;
+        }
+        await handle.dispose().catch(() => { });
+        composerSelector = selector;
+        break;
+    }
+    if (!composerSelector) {
+        return { ok: false, reason: "composer_not_found" };
+    }
+    try {
+        await page.click(composerSelector);
+        await page.keyboard.press(selectAllShortcut).catch(() => { });
+        await page.keyboard.press("Backspace").catch(() => { });
+        await page.type(composerSelector, text, { delay: 12 });
+    }
+    catch {
+        return { ok: false, reason: "compose_input_failed" };
+    }
+    const submitVisible = await waitForReplySubmitReady(page, 2_000);
+    if (dryRun) {
         return {
-            ok: false,
-            result: errorResult("CHALLENGE_REQUIRED", "x.com challenge is blocking actions", {
-                state: auth.state,
-                signals: auth.signals,
-            }),
+            ok: true,
+            dryRun: true,
+            submitVisible,
         };
     }
+    if (!submitVisible) {
+        return { ok: false, reason: "submit_not_found" };
+    }
     return {
-        ok: false,
-        result: errorResult("AUTH_REQUIRED", "login required", {
-            state: auth.state,
-            signals: auth.signals,
-        }),
+        ok: true,
+        submitVisible: true,
     };
 }
-export function createXAdapter(options) {
-    const composeConfirmTimeoutMs = options?.composeConfirmTimeoutMs ?? DEFAULT_COMPOSE_CONFIRM_TIMEOUT_MS;
-    const maxPostLength = options?.maxPostLength ?? DEFAULT_MAX_POST_LENGTH;
-    return {
-        name: "adapter-x",
-        start: async ({ page }) => {
-            await ensureNetworkCaptureInstalled(page);
-            await page.waitForLoadState("domcontentloaded").catch(() => {
-                // Keep startup best-effort; auth probing will still run.
-            });
-            await warmupAuthProbe(page);
-        },
-        listTools: async () => TOOL_DEFINITIONS,
-        callTool: async ({ name, input }, { page }) => {
-            const args = toRecord(input);
-            if (name === "auth.get") {
-                const auth = await detectAuthStable(page);
-                return {
-                    state: auth.state,
-                    signals: auth.signals,
-                };
+async function waitForReplySubmitReady(page, timeoutMs) {
+    try {
+        await page.waitForFunction(({ op }) => {
+            if (op !== "reply_submit_ready") {
+                return false;
             }
-            if (name === "timeline.home.list") {
-                const authCheck = await requireAuthenticated(page);
-                if (!authCheck.ok) {
-                    return authCheck.result;
+            const selectors = [
+                "[data-testid='tweetButtonInline']",
+                "[data-testid='tweetButton']",
+                "div[data-testid='toolBar'] [data-testid='tweetButtonInline']",
+            ];
+            const isEnabled = (element) => {
+                if (!element) {
+                    return false;
                 }
-                const limit = normalizeTimelineLimit(args);
-                const cursor = typeof args.cursor === "string" ? args.cursor.trim() : "";
-                const result = cursor
-                    ? await readTimelineWithMode(page, "home", limit, cursor)
-                    : await readTimelineWithMode(page, "home", limit);
-                if (result.source === "network" || result.items.length > 0) {
-                    return result;
+                if (element instanceof HTMLButtonElement) {
+                    return !element.disabled;
                 }
-                return await withCachedReadOnlyPage(page, "home", "https://x.com/home", async (readPage) => {
-                    return cursor
-                        ? await readTimelineWithMode(readPage, "home", limit, cursor)
-                        : await readTimelineWithMode(readPage, "home", limit);
-                });
-            }
-            if (name === "tweet.get") {
-                const authCheck = await requireAuthenticated(page);
-                if (!authCheck.ok) {
-                    return authCheck.result;
+                const ariaDisabled = (element.getAttribute("aria-disabled") ?? "").toLowerCase();
+                return ariaDisabled !== "true";
+            };
+            const composerSelectors = [
+                "div[data-testid='tweetTextarea_0']",
+                "div[role='textbox'][data-testid='tweetTextarea_0']",
+                "div[role='textbox'][aria-label*='Reply']",
+                "div[role='textbox'][aria-label*='Post your reply']",
+                "div[role='textbox'][aria-label*='Post text']",
+            ];
+            const findNearestSubmit = (composer) => {
+                if (!composer) {
+                    return null;
                 }
-                const url = typeof args.url === "string" ? args.url.trim() : "";
-                const id = typeof args.id === "string" ? args.id.trim() : "";
-                const targetUrl = url || (id ? `https://x.com/i/web/status/${id}` : "");
-                if (!targetUrl) {
-                    return errorResult("VALIDATION_ERROR", "url or id is required");
+                const roots = [
+                    composer.closest("[role='dialog']"),
+                    composer.closest("form"),
+                    composer.closest("article"),
+                    composer.parentElement,
+                    composer.parentElement?.parentElement,
+                    document.body,
+                ];
+                for (const root of roots) {
+                    if (!root) {
+                        continue;
+                    }
+                    for (const selector of selectors) {
+                        const element = root.querySelector(selector);
+                        if (isEnabled(element)) {
+                            return element;
+                        }
+                    }
+                }
+                return null;
+            };
+            let composer = null;
+            for (const selector of composerSelectors) {
+                composer = document.querySelector(selector);
+                if (composer) {
+                    break;
+                }
+            }
+            if (findNearestSubmit(composer)) {
+                return true;
+            }
+            for (const selector of selectors) {
+                const element = document.querySelector(selector);
+                if (isEnabled(element)) {
+                    return true;
+                }
+            }
+            return false;
+        }, { op: "reply_submit_ready" }, { timeout: Math.max(1_500, Math.min(timeoutMs, 6_000)) });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function submitReply(page) {
+    return await page.evaluate(({ op }) => {
+        if (op !== "reply_submit") {
+            return { ok: false, reason: "invalid_operation" };
+        }
+        const composerSelectors = [
+            "div[data-testid='tweetTextarea_0']",
+            "div[role='textbox'][data-testid='tweetTextarea_0']",
+            "div[role='textbox'][aria-label*='Reply']",
+            "div[role='textbox'][aria-label*='Post your reply']",
+            "div[role='textbox'][aria-label*='Post text']",
+        ];
+        const selectors = [
+            "[data-testid='tweetButtonInline']",
+            "[data-testid='tweetButton']",
+            "div[data-testid='toolBar'] [data-testid='tweetButtonInline']",
+        ];
+        const isEnabled = (element) => {
+            if (!element) {
+                return false;
+            }
+            if (element instanceof HTMLButtonElement) {
+                return !element.disabled;
+            }
+            const ariaDisabled = (element.getAttribute("aria-disabled") ?? "").toLowerCase();
+            return ariaDisabled !== "true";
+        };
+        const findNearestSubmit = (composer) => {
+            if (!composer) {
+                return null;
+            }
+            const roots = [
+                composer.closest("[role='dialog']"),
+                composer.closest("form"),
+                composer.closest("article"),
+                composer.parentElement,
+                composer.parentElement?.parentElement,
+                document.body,
+            ];
+            for (const root of roots) {
+                if (!root) {
+                    continue;
+                }
+                for (const selector of selectors) {
+                    const element = root.querySelector(selector);
+                    if (isEnabled(element)) {
+                        return element;
+                    }
+                }
+            }
+            return null;
+        };
+        let composer = null;
+        for (const selector of composerSelectors) {
+            composer = document.querySelector(selector);
+            if (composer) {
+                break;
+            }
+        }
+        const nearestSubmit = findNearestSubmit(composer);
+        if (nearestSubmit) {
+            nearestSubmit.click();
+            return { ok: true };
+        }
+        for (const selector of selectors) {
+            const element = document.querySelector(selector);
+            if (!isEnabled(element)) {
+                continue;
+            }
+            element?.click();
+            return { ok: true };
+        }
+        return { ok: false, reason: "submit_not_found" };
+    }, { op: "reply_submit" });
+}
+async function waitForReplyConfirmation(page, targetUrl, text, timeoutMs) {
+    const firstPassTimeoutMs = Math.max(2_500, Math.min(timeoutMs, 5_000));
+    const firstPass = await waitForComposeConfirmation(page, text, firstPassTimeoutMs);
+    if (firstPass.confirmed) {
+        return firstPass;
+    }
+    await page.waitForTimeout(1_000);
+    await page.goto(targetUrl, { waitUntil: "domcontentloaded", timeout: 60_000 }).catch(() => { });
+    await waitForTweetSurface(page);
+    const secondPassTimeoutMs = Math.max(2_500, timeoutMs - firstPassTimeoutMs);
+    return await waitForComposeConfirmation(page, text, secondPassTimeoutMs);
+}
+async function waitForGrokSurface(page) {
+    await page
+        .waitForFunction(() => {
+        const composer = document.querySelector("textarea") ||
+            document.querySelector("[contenteditable='true'][role='textbox']") ||
+            document.querySelector("[role='textbox'][contenteditable='true']");
+        const messages = document.querySelector("[data-message-author-role='assistant']") ||
+            document.querySelector("[data-testid*='assistant']") ||
+            document.querySelector("article");
+        return composer !== null || messages !== null;
+    }, undefined, { timeout: 12_000 })
+        .catch(() => { });
+    await page.waitForTimeout(800);
+}
+async function submitGrokPrompt(page, prompt) {
+    const composerSelectors = [
+        "textarea",
+        "[contenteditable='true'][role='textbox']",
+        "[role='textbox'][contenteditable='true']",
+    ];
+    const submitSelectors = [
+        "button[aria-label*='Grok something']",
+        "button[aria-label*='Send']",
+        "button[aria-label*='send']",
+        "button[data-testid*='send']",
+        "button[type='submit']",
+    ];
+    const selectAllShortcut = process.platform === "darwin" ? "Meta+A" : "Control+A";
+    let composerSelector;
+    for (const selector of composerSelectors) {
+        const handle = await page.waitForSelector(selector, { timeout: 1_200 }).catch(() => null);
+        if (!handle) {
+            continue;
+        }
+        await handle.dispose().catch(() => { });
+        composerSelector = selector;
+        break;
+    }
+    if (!composerSelector) {
+        return { ok: false, reason: "composer_not_found" };
+    }
+    try {
+        await page.click(composerSelector);
+        await page.keyboard.press(selectAllShortcut).catch(() => { });
+        await page.keyboard.press("Backspace").catch(() => { });
+        await page.type(composerSelector, prompt, { delay: 12 });
+    }
+    catch {
+        return { ok: false, reason: "compose_input_failed" };
+    }
+    const submitSelector = await page.evaluate((selectors) => {
+        const normalize = (value) => value.replace(/\s+/g, " ").trim().toLowerCase();
+        for (const selector of selectors) {
+            const element = document.querySelector(selector);
+            if (!element) {
+                continue;
+            }
+            if (element instanceof HTMLButtonElement && element.disabled) {
+                continue;
+            }
+            const ariaDisabled = (element.getAttribute("aria-disabled") ?? "").toLowerCase();
+            if (ariaDisabled === "true") {
+                continue;
+            }
+            const label = normalize(element.getAttribute("aria-label") ?? element.textContent ?? "");
+            if (label.includes("stop")) {
+                continue;
+            }
+            return selector;
+        }
+        return undefined;
+    }, submitSelectors);
+    if (!submitSelector) {
+        return { ok: false, reason: "submit_not_found" };
+    }
+    try {
+        await page.click(submitSelector);
+    }
+    catch {
+        return { ok: false, reason: "submit_click_failed" };
+    }
+    return { ok: true };
+}
+async function prepareGrokSession(page, conversationId) {
+    const targetUrl = typeof conversationId === "string" && conversationId.trim().length > 0
+        ? `https://x.com/i/grok?conversation=${encodeURIComponent(conversationId.trim())}`
+        : "https://x.com/i/grok";
+    if (!isSameLocation(page.url(), targetUrl)) {
+        await page.goto(targetUrl, { waitUntil: "domcontentloaded", timeout: 60_000 }).catch(() => { });
+    }
+    await waitForGrokSurface(page);
+    if (conversationId && conversationId.trim().length > 0) {
+        return;
+    }
+    const currentConversationId = (() => {
+        try {
+            return new URL(page.url()).searchParams.get("conversation") ?? undefined;
+        }
+        catch {
+            return undefined;
+        }
+    })();
+    if (typeof page.locator !== "function") {
+        return;
+    }
+    const newChatButton = page
+        .locator("button[aria-label*='New Chat'], button:has-text('New Chat')")
+        .first();
+    if ((await newChatButton.count().catch(() => 0)) === 0) {
+        return;
+    }
+    await newChatButton.click({ timeout: 2_000 }).catch(() => { });
+    await page
+        .waitForFunction(({ previousConversationId }) => {
+        const currentUrl = window.location.href;
+        try {
+            const conversation = new URL(currentUrl).searchParams.get("conversation") ?? undefined;
+            if (!previousConversationId) {
+                return conversation === undefined || conversation.length === 0;
+            }
+            return conversation !== previousConversationId;
+        }
+        catch {
+            return false;
+        }
+    }, { previousConversationId: currentConversationId }, { timeout: 5_000 })
+        .catch(() => { });
+    await page.waitForTimeout(600);
+    await waitForGrokSurface(page);
+}
+async function uploadGrokAttachments(page, attachments) {
+    if (attachments.length === 0) {
+        return { ok: true };
+    }
+    const uploadSelectors = [
+        "input[type='file'][accept*='application/pdf']",
+        "input[type='file'][accept*='text/csv']",
+        "input[type='file'][accept*='text/plain']",
+        "input[type='file']",
+    ];
+    let uploadSelector;
+    for (const selector of uploadSelectors) {
+        const handle = await page.waitForSelector(selector, { timeout: 1_200 }).catch(() => null);
+        if (!handle) {
+            continue;
+        }
+        await handle.dispose().catch(() => { });
+        uploadSelector = selector;
+        break;
+    }
+    if (!uploadSelector) {
+        return { ok: false, reason: "attachment_input_not_found" };
+    }
+    try {
+        await page.setInputFiles(uploadSelector, attachments.map((attachment) => attachment.path));
+    }
+    catch {
+        return { ok: false, reason: "attachment_upload_failed" };
+    }
+    const attachmentNames = attachments.map((attachment) => attachment.name);
+    await page
+        .waitForFunction(({ names }) => {
+        const bodyText = document.body?.innerText ?? "";
+        return names.every((name) => bodyText.includes(name));
+    }, { names: attachmentNames }, { timeout: 10_000 })
+        .catch(() => { });
+    await page.waitForTimeout(600);
+    return { ok: true };
+}
+async function askGrokViaNetwork(page, prompt, timeoutMs) {
+    const captured = await captureRoutedResponseText(page, "https://grok.x.com/2/grok/add_response.json*", async () => {
+        const submitResult = await submitGrokPrompt(page, prompt);
+        return submitResult.ok;
+    }, {
+        timeoutMs,
+    });
+    if (!captured || captured.status < 200 || captured.status >= 300) {
+        return undefined;
+    }
+    const responseText = captured.text;
+    const entries = parseNdjsonLines(responseText);
+    const finalParts = collectTextByTag(entries.map((entry) => {
+        const output = {};
+        if (typeof entry.result?.message === "string") {
+            output.message = entry.result.message;
+        }
+        if (typeof entry.result?.messageTag === "string") {
+            output.messageTag = entry.result.messageTag;
+        }
+        return output;
+    }), "final");
+    let conversationId;
+    for (const entry of entries) {
+        if (!conversationId && typeof entry.conversationId === "string") {
+            conversationId = entry.conversationId;
+        }
+    }
+    const finalResponse = joinTextParts(finalParts).trim();
+    if (!finalResponse) {
+        return undefined;
+    }
+    const artifactResult = await materializeGrokArtifacts(finalResponse);
+    const output = {
+        ok: true,
+        response: artifactResult.response,
+        url: typeof conversationId === "string" ? `https://x.com/i/grok?conversation=${conversationId}` : page.url(),
+    };
+    if (typeof conversationId === "string") {
+        output.conversationId = conversationId;
+    }
+    if (artifactResult.artifacts) {
+        output.artifacts = artifactResult.artifacts;
+    }
+    return output;
+}
+async function waitForGrokResponse(page, previousResponse, prompt, timeoutMs) {
+    try {
+        await page.waitForFunction(({ op, previous, promptText }) => {
+            if (op !== "grok_wait") {
+                return false;
+            }
+            const normalize = (value) => value.replace(/\s+/g, " ").trim();
+            const previousText = normalize(previous);
+            const normalizedPrompt = normalize(promptText);
+            const isIgnoredResponse = (value) => {
+                const lower = value.toLowerCase();
+                return (lower.length < 3 ||
+                    lower.startsWith("see new posts") ||
+                    lower.startsWith("thought for ") ||
+                    lower.startsWith("agents thinking") ||
+                    lower.startsWith("ask anything") ||
+                    lower === "agents" ||
+                    lower === "thinking" ||
+                    lower === "expert" ||
+                    lower.startsWith("grok") ||
+                    lower.includes("explore ") ||
+                    lower.includes("discuss ") ||
+                    lower.includes("create images") ||
+                    lower.includes("edit image") ||
+                    lower.includes("latest news") ||
+                    lower === normalizedPrompt.toLowerCase() ||
+                    lower === previousText.toLowerCase());
+            };
+            const scope = document.querySelector("div[aria-label='Grok']") ??
+                document.querySelector("main");
+            if (!scope) {
+                return false;
+            }
+            const lines = (scope.innerText || scope.textContent || "")
+                .split(/\n+/)
+                .map((line) => normalize(line))
+                .filter((line) => line.length > 0);
+            const linePromptIndex = lines.lastIndexOf(normalizedPrompt);
+            if (linePromptIndex >= 0) {
+                const hasStopControl = Array.from(document.querySelectorAll("button")).some((button) => {
+                    const label = normalize(button.getAttribute("aria-label") ?? button.textContent ?? "").toLowerCase();
+                    return label.includes("stop");
+                });
+                let hasLineCandidate = false;
+                for (let index = linePromptIndex + 1; index < lines.length; index += 1) {
+                    const candidate = lines[index];
+                    if (!candidate || isIgnoredResponse(candidate)) {
+                        continue;
+                    }
+                    hasLineCandidate = true;
+                }
+                if (!hasStopControl && hasLineCandidate) {
+                    return true;
+                }
+            }
+            const entries = [];
+            for (const node of Array.from(scope.querySelectorAll("div, span, p"))) {
+                if (node.closest("button, a, textarea, nav")) {
+                    continue;
+                }
+                const text = normalize(node.innerText || node.textContent || "");
+                if (!text) {
+                    continue;
+                }
+                const childWithSameText = Array.from(node.children).some((child) => {
+                    if (!(child instanceof HTMLElement)) {
+                        return false;
+                    }
+                    return normalize(child.innerText || child.textContent || "") === text;
+                });
+                if (childWithSameText) {
+                    continue;
+                }
+                if (entries[entries.length - 1] !== text) {
+                    entries.push(text);
+                }
+            }
+            const hasStopControl = Array.from(document.querySelectorAll("button")).some((button) => {
+                const label = normalize(button.getAttribute("aria-label") ?? button.textContent ?? "").toLowerCase();
+                return label.includes("stop");
+            });
+            const promptIndex = entries.lastIndexOf(normalizedPrompt);
+            if (promptIndex < 0) {
+                return false;
+            }
+            let hasCandidate = false;
+            for (let index = promptIndex + 1; index < entries.length; index += 1) {
+                const candidate = entries[index];
+                if (!candidate || isIgnoredResponse(candidate)) {
+                    continue;
+                }
+                hasCandidate = true;
+            }
+            return !hasStopControl && hasCandidate;
+        }, {
+            op: "grok_wait",
+            previous: (previousResponse ?? "").replace(/\s+/g, " ").trim(),
+            promptText: prompt,
+        }, { timeout: timeoutMs });
+    }
+    catch {
+        return { confirmed: false };
+    }
+    const state = await page.evaluate(({ op, promptText, previousText }) => {
+        if (op !== "grok_extract_state") {
+            return undefined;
+        }
+        const normalize = (value) => value.replace(/\s+/g, " ").trim();
+        const normalizedPrompt = normalize(promptText);
+        const normalizedPrevious = normalize(previousText);
+        const isIgnoredResponse = (value) => {
+            const lower = value.toLowerCase();
+            return (lower.length < 3 ||
+                lower.startsWith("see new posts") ||
+                lower.startsWith("thought for ") ||
+                lower.startsWith("agents thinking") ||
+                lower.startsWith("ask anything") ||
+                lower === "agents" ||
+                lower === "thinking" ||
+                lower === "expert" ||
+                lower.startsWith("grok") ||
+                lower.includes("explore ") ||
+                lower.includes("discuss ") ||
+                lower.includes("create images") ||
+                lower.includes("edit image") ||
+                lower.includes("latest news") ||
+                lower === normalizedPrompt.toLowerCase() ||
+                lower === normalizedPrevious.toLowerCase());
+        };
+        const scope = document.querySelector("div[aria-label='Grok']") ??
+            document.querySelector("main");
+        if (!scope) {
+            return undefined;
+        }
+        const lines = (scope.innerText || scope.textContent || "")
+            .split(/\n+/)
+            .map((line) => normalize(line))
+            .filter((line) => line.length > 0);
+        const lineResponseCandidates = [];
+        const linePromptIndex = lines.lastIndexOf(normalizedPrompt);
+        if (linePromptIndex >= 0) {
+            for (let index = linePromptIndex + 1; index < lines.length; index += 1) {
+                const candidate = lines[index];
+                if (!candidate || isIgnoredResponse(candidate)) {
+                    continue;
+                }
+                lineResponseCandidates.push(candidate);
+            }
+        }
+        let responseForPrompt;
+        if (lineResponseCandidates.length > 0) {
+            responseForPrompt = lineResponseCandidates.sort((left, right) => right.length - left.length)[0];
+        }
+        if (responseForPrompt) {
+            let latestResponse = responseForPrompt;
+            for (let index = lines.length - 1; index >= 0; index -= 1) {
+                const candidate = lines[index];
+                if (!candidate || isIgnoredResponse(candidate)) {
+                    continue;
+                }
+                latestResponse = candidate;
+                break;
+            }
+            return {
+                responseForPrompt,
+                latestResponse,
+            };
+        }
+        const entries = [];
+        for (const node of Array.from(scope.querySelectorAll("div, span, p"))) {
+            if (node.closest("button, a, textarea, nav")) {
+                continue;
+            }
+            const text = normalize(node.innerText || node.textContent || "");
+            if (!text) {
+                continue;
+            }
+            const childWithSameText = Array.from(node.children).some((child) => {
+                if (!(child instanceof HTMLElement)) {
+                    return false;
+                }
+                return normalize(child.innerText || child.textContent || "") === text;
+            });
+            if (childWithSameText) {
+                continue;
+            }
+            if (entries[entries.length - 1] !== text) {
+                entries.push(text);
+            }
+        }
+        const responseCandidates = [];
+        const promptIndex = entries.lastIndexOf(normalizedPrompt);
+        if (promptIndex >= 0) {
+            for (let index = promptIndex + 1; index < entries.length; index += 1) {
+                const candidate = entries[index];
+                if (!candidate || isIgnoredResponse(candidate)) {
+                    continue;
+                }
+                responseCandidates.push(candidate);
+            }
+        }
+        responseForPrompt = undefined;
+        if (responseCandidates.length > 0) {
+            responseForPrompt = responseCandidates.sort((left, right) => right.length - left.length)[0];
+        }
+        let latestResponse;
+        for (let index = entries.length - 1; index >= 0; index -= 1) {
+            const candidate = entries[index];
+            if (!candidate || isIgnoredResponse(candidate)) {
+                continue;
+            }
+            latestResponse = candidate;
+            break;
+        }
+        return {
+            responseForPrompt,
+            latestResponse,
+        };
+    }, {
+        op: "grok_extract_state",
+        promptText: prompt,
+        previousText: previousResponse ?? "",
+    });
+    if (state && typeof state === "object" && typeof state.responseForPrompt === "string" && state.responseForPrompt.length > 0) {
+        await page.waitForTimeout(600);
+        const settledState = await page.evaluate(({ op, promptText, previousText }) => {
+            if (op !== "grok_extract_state") {
+                return undefined;
+            }
+            const normalize = (value) => value.replace(/\s+/g, " ").trim();
+            const normalizedPrompt = normalize(promptText);
+            const normalizedPrevious = normalize(previousText);
+            const isIgnoredResponse = (value) => {
+                const lower = value.toLowerCase();
+                return (lower.length < 3 ||
+                    lower.startsWith("see new posts") ||
+                    lower.startsWith("thought for ") ||
+                    lower.startsWith("agents thinking") ||
+                    lower.startsWith("ask anything") ||
+                    lower === "agents" ||
+                    lower === "thinking" ||
+                    lower === "expert" ||
+                    lower.startsWith("grok") ||
+                    lower.includes("explore ") ||
+                    lower.includes("discuss ") ||
+                    lower.includes("create images") ||
+                    lower.includes("edit image") ||
+                    lower.includes("latest news") ||
+                    lower === normalizedPrompt.toLowerCase() ||
+                    lower === normalizedPrevious.toLowerCase());
+            };
+            const scope = document.querySelector("div[aria-label='Grok']") ??
+                document.querySelector("main");
+            if (!scope) {
+                return undefined;
+            }
+            const lines = (scope.innerText || scope.textContent || "")
+                .split(/\n+/)
+                .map((line) => normalize(line))
+                .filter((line) => line.length > 0);
+            const lineResponseCandidates = [];
+            const linePromptIndex = lines.lastIndexOf(normalizedPrompt);
+            if (linePromptIndex >= 0) {
+                for (let index = linePromptIndex + 1; index < lines.length; index += 1) {
+                    const candidate = lines[index];
+                    if (!candidate || isIgnoredResponse(candidate)) {
+                        continue;
+                    }
+                    lineResponseCandidates.push(candidate);
+                }
+            }
+            if (lineResponseCandidates.length > 0) {
+                return {
+                    responseForPrompt: lineResponseCandidates.sort((left, right) => right.length - left.length)[0],
+                };
+            }
+            const entries = [];
+            for (const node of Array.from(scope.querySelectorAll("div, span, p"))) {
+                if (node.closest("button, a, textarea, nav")) {
+                    continue;
+                }
+                const text = normalize(node.innerText || node.textContent || "");
+                if (!text) {
+                    continue;
+                }
+                const childWithSameText = Array.from(node.children).some((child) => {
+                    if (!(child instanceof HTMLElement)) {
+                        return false;
+                    }
+                    return normalize(child.innerText || child.textContent || "") === text;
+                });
+                if (childWithSameText) {
+                    continue;
+                }
+                if (entries[entries.length - 1] !== text) {
+                    entries.push(text);
+                }
+            }
+            const responseCandidates = [];
+            const promptIndex = entries.lastIndexOf(normalizedPrompt);
+            if (promptIndex >= 0) {
+                for (let index = promptIndex + 1; index < entries.length; index += 1) {
+                    const candidate = entries[index];
+                    if (!candidate || isIgnoredResponse(candidate)) {
+                        continue;
+                    }
+                    responseCandidates.push(candidate);
+                }
+            }
+            let responseForPrompt;
+            if (responseCandidates.length > 0) {
+                responseForPrompt = responseCandidates.sort((left, right) => right.length - left.length)[0];
+            }
+            return {
+                responseForPrompt,
+            };
+        }, {
+            op: "grok_extract_state",
+            promptText: prompt,
+            previousText: previousResponse ?? "",
+        });
+        if (settledState &&
+            typeof settledState === "object" &&
+            typeof settledState.responseForPrompt === "string" &&
+            settledState.responseForPrompt.length > 0) {
+            return {
+                confirmed: true,
+                response: settledState.responseForPrompt,
+            };
+        }
+    }
+    if (state && typeof state === "object" && typeof state.responseForPrompt === "string" && state.responseForPrompt.length > 0) {
+        return {
+            confirmed: true,
+            response: state.responseForPrompt,
+        };
+    }
+    return { confirmed: false };
+}
+async function readLatestGrokResponse(page) {
+    const state = await page.evaluate(({ op }) => {
+        if (op !== "grok_extract_state") {
+            return undefined;
+        }
+        const normalize = (value) => value.replace(/\s+/g, " ").trim();
+        const isIgnoredResponse = (value) => {
+            const lower = value.toLowerCase();
+            return (lower.length < 3 ||
+                lower.startsWith("see new posts") ||
+                lower.startsWith("thought for ") ||
+                lower.startsWith("agents thinking") ||
+                lower.startsWith("ask anything") ||
+                lower === "agents" ||
+                lower === "thinking" ||
+                lower === "expert" ||
+                lower.startsWith("grok") ||
+                lower.includes("explore "));
+        };
+        const scope = document.querySelector("div[aria-label='Grok']") ??
+            document.querySelector("main");
+        if (!scope) {
+            return undefined;
+        }
+        const lines = (scope.innerText || scope.textContent || "")
+            .split(/\n+/)
+            .map((line) => normalize(line))
+            .filter((line) => line.length > 0);
+        for (let index = lines.length - 1; index >= 0; index -= 1) {
+            const candidate = lines[index];
+            if (!candidate || isIgnoredResponse(candidate)) {
+                continue;
+            }
+            return { latestResponse: candidate };
+        }
+        const entries = [];
+        for (const node of Array.from(scope.querySelectorAll("div, span, p"))) {
+            if (node.closest("button, a, textarea, nav")) {
+                continue;
+            }
+            const text = normalize(node.innerText || node.textContent || "");
+            if (!text || isIgnoredResponse(text)) {
+                continue;
+            }
+            const childWithSameText = Array.from(node.children).some((child) => {
+                if (!(child instanceof HTMLElement)) {
+                    return false;
+                }
+                return normalize(child.innerText || child.textContent || "") === text;
+            });
+            if (childWithSameText) {
+                continue;
+            }
+            if (entries[entries.length - 1] !== text) {
+                entries.push(text);
+            }
+        }
+        let latestResponse;
+        for (let index = entries.length - 1; index >= 0; index -= 1) {
+            const candidate = entries[index];
+            if (!candidate || isIgnoredResponse(candidate)) {
+                continue;
+            }
+            latestResponse = candidate;
+            break;
+        }
+        return { latestResponse };
+    }, { op: "grok_extract_state" });
+    if (state && typeof state === "object" && typeof state.latestResponse === "string") {
+        return state.latestResponse;
+    }
+    return undefined;
+}
+function logGrokPhase(phase, details) {
+    const payload = {
+        phase,
+    };
+    if (details) {
+        for (const [key, value] of Object.entries(details)) {
+            if (value !== undefined) {
+                payload[key] = value;
+            }
+        }
+    }
+    process.stderr.write(`[adapter-x grok] ${JSON.stringify(payload)}\n`);
+}
+async function askGrok(page, prompt, timeoutMs, attachments, conversationId) {
+    logGrokPhase("start", { timeoutMs, promptLength: prompt.length });
+    try {
+        const targetUrl = typeof conversationId === "string" && conversationId.trim().length > 0
+            ? `https://x.com/i/grok?conversation=${encodeURIComponent(conversationId.trim())}`
+            : "https://x.com/i/grok";
+        return await withEphemeralPage(page, targetUrl, async (grokPage) => {
+            logGrokPhase("page_opened", { url: grokPage.url() });
+            await prepareGrokSession(grokPage, conversationId);
+            logGrokPhase("surface_ready");
+            const uploadResult = await uploadGrokAttachments(grokPage, attachments);
+            const attachmentLogDetails = {
+                ok: uploadResult.ok,
+                attachmentCount: attachments.length,
+            };
+            if (!uploadResult.ok) {
+                attachmentLogDetails.reason = uploadResult.reason;
+            }
+            logGrokPhase("attachments_ready", attachmentLogDetails);
+            if (!uploadResult.ok) {
+                return errorResult("UPSTREAM_CHANGED", "grok attachment controls not found", {
+                    reason: uploadResult.reason,
+                });
+            }
+            const networkResult = await askGrokViaNetwork(grokPage, prompt, timeoutMs);
+            logGrokPhase("network_result", {
+                ok: networkResult?.ok === true,
+                responseLength: networkResult?.response.length ?? 0,
+            });
+            if (networkResult?.ok) {
+                const output = {
+                    ok: true,
+                    response: networkResult.response,
+                    url: networkResult.url,
+                };
+                if (networkResult.conversationId) {
+                    output.conversationId = networkResult.conversationId;
+                }
+                if (networkResult.artifacts) {
+                    output.artifacts = networkResult.artifacts;
+                }
+                return output;
+            }
+            await grokPage.goto("https://x.com/i/grok", { waitUntil: "domcontentloaded", timeout: 60_000 }).catch(() => { });
+            await waitForGrokSurface(grokPage);
+            const previousResponse = await readLatestGrokResponse(grokPage);
+            logGrokPhase("previous_response_read", {
+                hasPreviousResponse: previousResponse !== undefined,
+                previousResponseLength: previousResponse?.length ?? 0,
+            });
+            const submitResult = await submitGrokPrompt(grokPage, prompt);
+            const submitLogDetails = {
+                ok: submitResult.ok,
+            };
+            if (submitResult.reason !== undefined) {
+                submitLogDetails.reason = submitResult.reason;
+            }
+            logGrokPhase("submit_result", submitLogDetails);
+            if (!submitResult.ok) {
+                return errorResult("UPSTREAM_CHANGED", "grok controls not found", {
+                    reason: submitResult.reason ?? "unknown",
+                });
+            }
+            logGrokPhase("wait_start", { timeoutMs });
+            const confirmation = await waitForGrokResponse(grokPage, previousResponse, prompt, timeoutMs);
+            logGrokPhase("wait_result", {
+                confirmed: confirmation.confirmed,
+                responseLength: confirmation.response?.length ?? 0,
+            });
+            if (!confirmation.confirmed || !confirmation.response) {
+                return errorResult("ACTION_UNCONFIRMED", "grok response was not confirmed");
+            }
+            logGrokPhase("success", {
+                responseLength: confirmation.response.length,
+                url: grokPage.url(),
+            });
+            const output = {
+                ok: true,
+                response: confirmation.response,
+                url: grokPage.url(),
+            };
+            if (conversationId) {
+                output.conversationId = conversationId;
+            }
+            return output;
+        });
+    }
+    catch (error) {
+        const details = {};
+        if (error instanceof Error) {
+            details.name = error.name;
+            details.message = error.message;
+        }
+        else if (error !== undefined) {
+            details.message = String(error);
+        }
+        logGrokPhase("error", details);
+        return errorResult("UPSTREAM_CHANGED", "grok execution threw", details);
+    }
+}
+async function replyToTweet(page, targetUrl, text, dryRun, timeoutMs) {
+    return await withEphemeralPage(page, targetUrl, async (replyPage) => {
+        await waitForTweetSurface(replyPage);
+        await ensureReplyComposerReady(replyPage);
+        const composeResult = await composeReply(replyPage, text, dryRun);
+        if (!composeResult.ok) {
+            return errorResult("UPSTREAM_CHANGED", "reply controls not found", {
+                reason: composeResult.reason ?? "unknown",
+            });
+        }
+        if (composeResult.dryRun) {
+            return {
+                ok: true,
+                dryRun: true,
+                submitVisible: composeResult.submitVisible === true,
+                replyToUrl: targetUrl,
+            };
+        }
+        const submitReady = await waitForReplySubmitReady(replyPage, timeoutMs);
+        if (!submitReady) {
+            return errorResult("UPSTREAM_CHANGED", "reply controls not ready", {
+                reason: "submit_not_ready",
+            });
+        }
+        const submitResult = await submitReply(replyPage);
+        if (!submitResult.ok) {
+            return errorResult("UPSTREAM_CHANGED", "reply controls not found", {
+                reason: submitResult.reason ?? "unknown",
+            });
+        }
+        const confirmation = await waitForReplyConfirmation(replyPage, targetUrl, text, timeoutMs);
+        if (!confirmation.confirmed) {
+            return errorResult("ACTION_UNCONFIRMED", "reply submit was not confirmed in timeline");
+        }
+        const result = {
+            ok: true,
+            confirmed: true,
+            replyToUrl: targetUrl,
+        };
+        if (confirmation.statusUrl !== undefined) {
+            result.statusUrl = confirmation.statusUrl;
+        }
+        return result;
+    });
+}
+async function requireAuthenticated(page) {
+    const auth = await detectAuthStable(page);
+    if (auth.state === "authenticated") {
+        return { ok: true, auth };
+    }
+    if (auth.state === "challenge_required") {
+        return {
+            ok: false,
+            result: errorResult("CHALLENGE_REQUIRED", "x.com challenge is blocking actions", {
+                state: auth.state,
+                signals: auth.signals,
+            }),
+        };
+    }
+    return {
+        ok: false,
+        result: errorResult("AUTH_REQUIRED", "login required", {
+            state: auth.state,
+            signals: auth.signals,
+        }),
+    };
+}
+export function createXAdapter(options) {
+    const composeConfirmTimeoutMs = options?.composeConfirmTimeoutMs ?? DEFAULT_COMPOSE_CONFIRM_TIMEOUT_MS;
+    const grokResponseTimeoutMs = options?.grokResponseTimeoutMs ?? DEFAULT_GROK_RESPONSE_TIMEOUT_MS;
+    const maxPostLength = options?.maxPostLength ?? DEFAULT_MAX_POST_LENGTH;
+    return {
+        name: "adapter-x",
+        start: async ({ page }) => {
+            await ensureNetworkCaptureInstalled(page);
+            await page.waitForLoadState("domcontentloaded").catch(() => {
+                // Keep startup best-effort; auth probing will still run.
+            });
+            await warmupAuthProbe(page);
+        },
+        listTools: async () => TOOL_DEFINITIONS,
+        callTool: async ({ name, input }, { page }) => {
+            const args = toRecord(input);
+            if (name === "auth.get") {
+                const auth = await detectAuthStable(page);
+                return {
+                    state: auth.state,
+                    signals: auth.signals,
+                };
+            }
+            if (name === "timeline.home.list") {
+                const authCheck = await requireAuthenticated(page);
+                if (!authCheck.ok) {
+                    return authCheck.result;
+                }
+                const limit = normalizeTimelineLimit(args);
+                const cursor = typeof args.cursor === "string" ? args.cursor.trim() : "";
+                const result = cursor
+                    ? await readTimelineWithMode(page, "home", limit, cursor)
+                    : await readTimelineWithMode(page, "home", limit);
+                if (result.source === "network" || result.items.length > 0) {
+                    return result;
+                }
+                return await withCachedReadOnlyPage(page, "home", "https://x.com/home", async (readPage) => {
+                    return cursor
+                        ? await readTimelineWithMode(readPage, "home", limit, cursor)
+                        : await readTimelineWithMode(readPage, "home", limit);
+                });
+            }
+            if (name === "tweet.get") {
+                const authCheck = await requireAuthenticated(page);
+                if (!authCheck.ok) {
+                    return authCheck.result;
+                }
+                const url = typeof args.url === "string" ? args.url.trim() : "";
+                const id = typeof args.id === "string" ? args.id.trim() : "";
+                const targetUrl = url || (id ? `https://x.com/i/web/status/${id}` : "");
+                if (!targetUrl) {
+                    return errorResult("VALIDATION_ERROR", "url or id is required");
                 }
                 return await readTweetByUrl(page, targetUrl);
             }
+            if (name === "tweet.thread.get") {
+                const authCheck = await requireAuthenticated(page);
+                if (!authCheck.ok) {
+                    return authCheck.result;
+                }
+                const url = typeof args.url === "string" ? args.url.trim() : "";
+                const id = typeof args.id === "string" ? args.id.trim() : "";
+                const targetUrl = url || (id ? `https://x.com/i/web/status/${id}` : "");
+                if (!targetUrl) {
+                    return errorResult("VALIDATION_ERROR", "url or id is required");
+                }
+                const limit = normalizeTimelineLimit(args);
+                return await readTweetThreadByUrl(page, targetUrl, limit);
+            }
+            if (name === "tweet.media.download") {
+                const authCheck = await requireAuthenticated(page);
+                if (!authCheck.ok) {
+                    return authCheck.result;
+                }
+                const url = typeof args.url === "string" ? args.url.trim() : "";
+                const id = typeof args.id === "string" ? args.id.trim() : "";
+                const targetUrl = url || (id ? `https://x.com/i/web/status/${id}` : "");
+                if (!targetUrl) {
+                    return errorResult("VALIDATION_ERROR", "url or id is required");
+                }
+                const mediaIndex = typeof args.mediaIndex === "number" && Number.isFinite(args.mediaIndex)
+                    ? Math.floor(args.mediaIndex)
+                    : undefined;
+                return await downloadTweetMediaByUrl(page, targetUrl, mediaIndex);
+            }
+            if (name === "tweet.conversation.get") {
+                const authCheck = await requireAuthenticated(page);
+                if (!authCheck.ok) {
+                    return authCheck.result;
+                }
+                const url = typeof args.url === "string" ? args.url.trim() : "";
+                const id = typeof args.id === "string" ? args.id.trim() : "";
+                const targetUrl = url || (id ? `https://x.com/i/web/status/${id}` : "");
+                if (!targetUrl) {
+                    return errorResult("VALIDATION_ERROR", "url or id is required");
+                }
+                const limit = normalizeTimelineLimit(args);
+                const cursor = typeof args.cursor === "string" ? args.cursor.trim() : "";
+                return await readTweetConversationByUrl(page, targetUrl, limit, cursor || undefined);
+            }
+            if (name === "tweet.replies.list") {
+                const authCheck = await requireAuthenticated(page);
+                if (!authCheck.ok) {
+                    return authCheck.result;
+                }
+                const url = typeof args.url === "string" ? args.url.trim() : "";
+                const id = typeof args.id === "string" ? args.id.trim() : "";
+                const targetUrl = url || (id ? `https://x.com/i/web/status/${id}` : "");
+                if (!targetUrl) {
+                    return errorResult("VALIDATION_ERROR", "url or id is required");
+                }
+                const limit = normalizeTimelineLimit(args);
+                const cursor = typeof args.cursor === "string" ? args.cursor.trim() : "";
+                return await readTweetRepliesByUrl(page, targetUrl, limit, cursor || undefined);
+            }
             if (name === "favorites.list") {
                 const authCheck = await requireAuthenticated(page);
                 if (!authCheck.ok) {
@@ -1324,6 +3511,26 @@ export function createXAdapter(options) {
                         : await readTimelineWithMode(readPage, "bookmarks", limit);
                 });
             }
+            if (name === "notifications.list") {
+                const authCheck = await requireAuthenticated(page);
+                if (!authCheck.ok) {
+                    return authCheck.result;
+                }
+                const limit = normalizeTimelineLimit(args);
+                return await withCachedReadOnlyPage(page, "notifications", "https://x.com/notifications", async (readPage) => {
+                    return await readNotifications(readPage, limit);
+                });
+            }
+            if (name === "mentions.list") {
+                const authCheck = await requireAuthenticated(page);
+                if (!authCheck.ok) {
+                    return authCheck.result;
+                }
+                const limit = normalizeTimelineLimit(args);
+                return await withCachedReadOnlyPage(page, "notifications:mentions", "https://x.com/notifications/mentions", async (readPage) => {
+                    return await readNotifications(readPage, limit);
+                });
+            }
             if (name === "timeline.user.list") {
                 const authCheck = await requireAuthenticated(page);
                 if (!authCheck.ok) {
@@ -1414,6 +3621,43 @@ export function createXAdapter(options) {
                 }
                 return result;
             }
+            if (name === "tweet.reply") {
+                const authCheck = await requireAuthenticated(page);
+                if (!authCheck.ok) {
+                    return authCheck.result;
+                }
+                const text = typeof args.text === "string" ? args.text.trim() : "";
+                if (!text) {
+                    return errorResult("VALIDATION_ERROR", "text is required");
+                }
+                if (text.length > maxPostLength) {
+                    return errorResult("VALIDATION_ERROR", `text exceeds max length ${maxPostLength}`);
+                }
+                const url = typeof args.url === "string" ? args.url.trim() : "";
+                const id = typeof args.id === "string" ? args.id.trim() : "";
+                const targetUrl = url || (id ? `https://x.com/i/web/status/${id}` : "");
+                if (!targetUrl) {
+                    return errorResult("VALIDATION_ERROR", "url or id is required");
+                }
+                const dryRun = args.dryRun === true;
+                return await replyToTweet(page, targetUrl, text, dryRun, composeConfirmTimeoutMs);
+            }
+            if (name === "grok.chat") {
+                const authCheck = await requireAuthenticated(page);
+                if (!authCheck.ok) {
+                    return authCheck.result;
+                }
+                const prompt = typeof args.prompt === "string" ? args.prompt.trim() : "";
+                if (!prompt) {
+                    return errorResult("VALIDATION_ERROR", "prompt is required");
+                }
+                const resolvedAttachments = await resolveGrokAttachments(args.attachmentPaths);
+                if (!resolvedAttachments.ok) {
+                    return resolvedAttachments.result;
+                }
+                const conversationId = typeof args.conversationId === "string" ? args.conversationId.trim() : "";
+                return await askGrok(page, prompt, grokResponseTimeoutMs, resolvedAttachments.attachments, conversationId || undefined);
+            }
             return errorResult("TOOL_NOT_FOUND", `unknown tool: ${name}`);
         },
         stop: async ({ page }) => {