@hraness/ghostget 0.18.0 → 0.18.2

package/src/plugins/whatsapp-linked-device/vendor/README.md

@@ -0,0 +1,39 @@
+# Reviewed WhatsApp automation transport
+
+This patch applies to `openclaw/wacli` commit
+`a020de724180d31eccfa5241d45443402d62fb06` (v0.15.0). It is opt-in through
+`sync --ghostget-private-transport`. Ordinary wacli commands retain their
+existing behavior. Ghostget does not admit stock auto-retrying sends for its
+automation contract.
+
+The private socket carries fixed-schema JSON, bound to an exact account,
+connection generation, direct recipient JID, and durable request ID. A claimed
+request is never sent again; only an exact prior accepted receipt is returned.
+Connection loss or an unfinished claim remains indeterminate. Acceptance means
+the provider acknowledged the operation, not that the recipient received it.
+
+Private sends make one joined application-level attempt and omit recipient
+alias rewriting and URL previews. Text, document attachments, WebP stickers,
+reactions and polls use existing pinned wacli operations. The upstream protocol
+library may retransmit protocol frames with its own message ID. No account,
+pairing, private-message or live-send qualification is implied by offline tests.
+
+The private runtime installs SQLite triggers that journal message insert,
+update and delete projections in the same transaction. A persistent generation
+and monotonic sequence support resumption; retention is 10,000 events and
+expired or changed anchors require a new baseline. Historical backfill keeps
+its original timestamp. Consumers must apply their freshness policy before
+replying. A single writer connection uses `synchronous=FULL`.
+
+Build with Go 1.25.12, the unchanged committed module graph, a macOS arm64
+toolchain, and the exact commands in `provenance.json`. The native binary is
+bundled as compressed pinned bytes inside Ghostget's existing package archive.
+Owner setup installs it with the exact-hash installer; it is not an additional
+canonical package release asset. The supervised socket lives in its owned
+private cleanup directory so long managed account paths remain usable.
+
+Tests in the patch exercise a real private Unix socket using a synthetic
+runtime, joined cancellation, one-attempt failure, exact replay, identity and
+target mismatch, transactional events, cursor expiration and bounded retention.
+Both complete upstream suites (plain and `sqlite_fts5`) and `go vet ./...`
+passed. Two builds with identical flags produced identical bytes.

package/src/plugins/whatsapp-linked-device/vendor/provenance.json

@@ -0,0 +1,45 @@
+{
+  "schemaVersion": 1,
+  "upstream": {
+    "repository": "https://github.com/openclaw/wacli",
+    "version": "0.15.0",
+    "baseCommit": "a020de724180d31eccfa5241d45443402d62fb06"
+  },
+  "reviewedPatchStack": {
+    "tipCommit": "16cf7557a1683eb18e7a6e1c1fde8ca9f05e0850",
+    "patches": [{
+      "file": "0001-ghostget-private-messaging.patch",
+      "sha256": "44235d0fcd070d895fbe2fa3fa4406b34b8f7c808216fd22a2417c4fc86f3255",
+      "purpose": "Bounded owner-only IPC, durable one-attempt request claims, exact direct JIDs, joined cancellation and atomic bounded message-change events."
+    }]
+  },
+  "artifact": {
+    "platform": "darwin",
+    "arch": "arm64",
+    "version": "0.15.0+ghostget-private.1",
+    "executableSha256": "9b77ffb810d028fde725ca02b1451f1725b5ff5312a46a54468a9a38533d4cea",
+    "executableBytes": 21963810,
+    "compression": "gzip",
+    "compressedSha256": "1c1650d6c79b74db7f8f335b4746398c802031260a90468312dcaac0374a5166",
+    "compressedBytes": 7682949,
+    "build": {
+      "go": "go1.25.12 darwin/arm64",
+      "goArchiveSha256": "fa2c88bbcf64bd3b2aef355f026cfec6d3a4a01c132f999c8f8c964eb767164f",
+      "clang": "Apple clang version 21.0.0 (clang-2100.1.1.101)",
+      "macosSdk": "26.5",
+      "moduleGraphChanged": false,
+      "command": ["go", "build", "-trimpath", "-buildvcs=false", "-tags", "sqlite_fts5", "-ldflags", "-s -w -buildid= -X main.version=0.15.0+ghostget-private.1", "-o", "wacli-private", "./cmd/wacli"],
+      "secondIdenticalBuildVerified": true
+    }
+  },
+  "validation": {
+    "goTestAll": "passed",
+    "goTestAllSqliteFts5": "passed",
+    "goVetAll": "passed",
+    "privateSocketUsesSyntheticRuntime": true,
+    "realAccountRead": false,
+    "pairingPerformed": false,
+    "liveSendPerformed": false,
+    "deliveryQualified": false
+  }
+}

package/src/provider-plugin.ts

@@ -3485,6 +3485,20 @@ export function bindProviderPluginRuntimeLoadIdentity(
   );
 }
 
+/** Trusted extensions share the binding's complete source snapshot. They cannot
+ * load an independent provider runtime without the registry's pre/post checks. */
+export async function loadProviderPluginExtensionRuntime<T>(
+  loadRuntime: () => Promise<unknown>, loader: () => Promise<T>,
+): Promise<T> {
+  const identity = providerPluginRuntimeLoadIdentities.get(loadRuntime);
+  if (identity === undefined) throw new Error("Provider extension has no registered implementation identity");
+  providerPluginStartedRuntimeLoaders.add(loadRuntime);
+  await identity.verify("before");
+  const runtime = await loader();
+  await identity.verify("after");
+  return runtime;
+}
+
 export function lazyProviderApiRuntime(
   loader: () => Promise<ProviderApiPluginRuntimeV1>,
 ): ProviderApiPluginRuntimeHooksV1 {

package/src/providers/imessage-automation.ts

@@ -0,0 +1,250 @@
+import { createHash } from "node:crypto";
+import { constants } from "node:fs";
+import { open } from "node:fs/promises";
+import { join } from "node:path";
+import type { GhostgetAuth } from "../auth";
+import { canonicalJson } from "../canonical-json";
+import type { LocalCliExecutionOptions } from "../local-cli-execution";
+import { OperationDeadline } from "../operation-deadline";
+import type { AutomationAction, AutomationConversation, AutomationCoordinate, AutomationIdentity, AutomationMessage, AutomationProviderStatus, AutomationProviderSendResult, MessagingAutomationProvider } from "../messaging-automation-types";
+import { AUTOMATION_ACTION_KINDS, automationArray, automationDigest, automationInteger, automationRecord, automationText, parseAutomationAction, parseAutomationCoordinate, parseAutomationIdentity } from "../messaging-automation-validation";
+import { IMSG_NO_FETCH_RICH_CARDS_AVAILABLE, type ImsgChatCoordinate, type ImsgRpcRequest } from "./imessage-direct";
+import { imsgAutomationProjection as project, withImsgAutomationRuntime, type ImsgChatProjection, type ImsgDirectRuntimeDependencies } from "./imessage-direct-runtime";
+
+export type ImsgAutomationOperation = "inspect" | "conversations" | "resolve" | "history" | "events" | AutomationAction["kind"];
+/** The Ghostget host supplies existing permission admission, auth lifetime and
+ * exact plugin closure. A contact grant only narrows this authority. */
+export type ImsgAutomationAdmission = Readonly<{ auth: GhostgetAuth; accountIdentity: string; implementationIdentity: string }>;
+export type ImsgAutomationOptions = Readonly<{
+  authorize(operation: ImsgAutomationOperation, signal?: AbortSignal): Promise<ImsgAutomationAdmission>;
+  execution: Pick<LocalCliExecutionOptions, "registerCleanupBarrier" | "environment">;
+  resolveAsset(assetId: string, signal?: AbortSignal): Promise<Readonly<{ bytes: Uint8Array; sha256: string }>>;
+  dependencies?: ImsgDirectRuntimeDependencies;
+}>;
+type Session = Parameters<Parameters<typeof withImsgAutomationRuntime>[2]>[0];
+const sha = (value: unknown): string => createHash("sha256").update(canonicalJson(value)).digest("hex");
+function request(method: string, params: Readonly<Record<string, unknown>> = {}, id = "operation"): ImsgRpcRequest { return { jsonrpc: "2.0", id, method, params }; }
+function coordinate(value: unknown): Extract<AutomationCoordinate, { provider: "imessage" }> {
+  const result = parseAutomationCoordinate(value);
+  if (result.provider !== "imessage") throw new Error("iMessage cannot operate another messaging network");
+  return result;
+}
+function target(value: AutomationCoordinate): ImsgChatCoordinate {
+  const item = coordinate(value); return { chatGuid: item.chatGuid, service: "iMessage", observedChatRowId: item.observedChatRowId };
+}
+function conversation(chat: ImsgChatProjection): AutomationConversation {
+  return { coordinate: coordinate({ provider: "imessage", chatGuid: chat.guid, service: "iMessage", observedChatRowId: chat.id }), title: chat.title, kind: chat.kind, participants: chat.participants };
+}
+async function exactConversation(session: Session, value: AutomationCoordinate): Promise<AutomationConversation> {
+  const selected = target(value);
+  const output = await session.run([request("chats.get", { chat_id: selected.observedChatRowId })]);
+  return conversation(project.exactChat(output.get("operation"), selected));
+}
+function methods(session: Session): ReadonlySet<string> {
+  const status = session.status as Record<string, unknown>; // already parsed by the pinned runtime
+  return new Set(automationArray(status.methods, 256).map(value => automationText(value, 128)));
+}
+function providerStatus(session: Session, identity: AutomationIdentity): AutomationProviderStatus {
+  const available = methods(session);
+  const rpc: Partial<Record<AutomationAction["kind"], string>> = { text: "send", attachment: "send", reaction: "tapback", sticker: "send.sticker", link: "send.rich", poll: "poll.send" };
+  const actions = Object.fromEntries(AUTOMATION_ACTION_KINDS.map(kind => {
+    if (kind === "link" && !IMSG_NO_FETCH_RICH_CARDS_AVAILABLE) return [kind, { available: false, reason: "The installed iMessage artifact predates no-fetch rich cards. The replacement native build has not been admitted." }];
+    const method = rpc[kind]; const ready = method !== undefined && available.has(method);
+    return [kind, { available: ready, reason: ready ? null : !method ? "The pinned iMessage helper has no reviewed operation for this action." : method === "send" ? "The native iMessage send operation is unavailable. Check Messages permissions in Ghostget." : `The private Messages bridge does not currently advertise ${method}. Its injection design requires owner-configured system support, including disabled SIP. Ghostget installation never changes SIP.` }];
+  })) as AutomationProviderStatus["actions"];
+  return { identity, connected: true, events: { available: available.has("messages.after"), reason: available.has("messages.after") ? null : "The pinned database cursor operation is unavailable." }, actions };
+}
+function message(value: unknown, selected: AutomationCoordinate): AutomationMessage {
+  const projected = project.parseMessage(value, "automation message", target(selected));
+  const raw = value as Record<string, unknown>;
+  if (raw.is_reaction !== undefined && typeof raw.is_reaction !== "boolean") throw new Error("Invalid reaction marker");
+  const related = raw.is_reaction === true ? automationText(raw.reacted_to_guid, 256) : projected.replyToGuid;
+  if (Buffer.byteLength(projected.text) > 65_536) throw new Error("Automation message exceeds its text bound");
+  return { id: automationText(projected.guid, 256), coordinate: selected, direction: projected.isFromMe ? "outgoing" : "incoming", occurredAt: projected.createdAt, text: projected.text, kind: raw.is_reaction === true ? "reaction" : "message", relatedMessageId: related, attachments: [] };
+}
+async function historyMessages(session: Session, selected: AutomationCoordinate, limit: number): Promise<readonly AutomationMessage[]> {
+  await exactConversation(session, selected);
+  const response = await session.run([request("messages.history", { chat_id: target(selected).observedChatRowId, limit, attachments: false })]);
+  const row = automationRecord(response.get("operation"), ["messages"]);
+  const messages = automationArray(row.messages, limit).map(raw => message(raw, selected));
+  if (new Set(messages.map(item => item.id)).size !== messages.length) throw new Error("Repeated message identity");
+  return messages;
+}
+type Cursor = { version: 1; identity: string; coordinates: string; rows: number[]; anchors: ({ row: number; id: string } | null)[] };
+function cursor(value: string | null, identity: AutomationIdentity, coordinates: readonly AutomationCoordinate[]): Cursor {
+  if (value === null) return { version: 1, identity: sha(identity), coordinates: sha(coordinates), rows: coordinates.map(() => 0), anchors: coordinates.map(() => null) };
+  automationText(value, 16_384);
+  const decoded = Buffer.from(value, "base64url");
+  if (decoded.toString("base64url") !== value) throw new Error("Noncanonical iMessage cursor");
+  const parsed = automationRecord(JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(decoded)), ["version", "identity", "coordinates", "rows", "anchors"]);
+  if (parsed.version !== 1 || parsed.identity !== sha(identity) || parsed.coordinates !== sha(coordinates)) throw new Error("iMessage cursor generation or scope changed");
+  const rows = automationArray(parsed.rows, 50).map(value => automationInteger(value, 0, Number.MAX_SAFE_INTEGER));
+  if (rows.length !== coordinates.length) throw new Error("iMessage cursor scope changed");
+  const anchors = automationArray(parsed.anchors, 50).map((value, index) => {
+    if (value === null) return null;
+    const anchor = automationRecord(value, ["row", "id"]);
+    return { row: automationInteger(anchor.row, 1, rows[index] ?? 0), id: automationText(anchor.id, 256) };
+  });
+  if (anchors.length !== rows.length) throw new Error("iMessage cursor anchor scope changed");
+  return { version: 1, identity: parsed.identity as string, coordinates: parsed.coordinates as string, rows, anchors };
+}
+
+/** Concrete pinned imsg implementation. It never starts the private Messages
+ * bridge, changes OS permissions, or falls back to SMS or another transport. */
+export function createImsgAutomationProvider(options: ImsgAutomationOptions): MessagingAutomationProvider {
+  let closed = false; let inFlight: Promise<unknown> | undefined;
+  async function run<T>(operation: ImsgAutomationOperation, signal: AbortSignal | undefined, work: (session: Session, identity: AutomationIdentity, reauthorize: () => Promise<void>) => Promise<T>): Promise<T> {
+    if (closed || inFlight) throw new Error("iMessage provider is closed or busy");
+    const pending = (async () => {
+      signal?.throwIfAborted();
+      const admission = await options.authorize(operation, signal);
+      if (admission.auth.kind !== "linked-device-store" || admission.auth.provider !== "imessage") throw new Error("iMessage account required");
+      const deadline = new OperationDeadline(30_000, signal ? { signal } : {});
+      try {
+        return await withImsgAutomationRuntime(admission.auth, { ...options.execution, operationDeadline: deadline, ...(options.dependencies ? { dependencies: options.dependencies } : {}) }, async session => {
+          const identity = parseAutomationIdentity({ provider: "imessage", authId: admission.auth.id, accountIdentity: admission.accountIdentity, accountSubject: session.subject, implementationIdentity: admission.implementationIdentity, sourceGeneration: session.sourceGeneration });
+          const reauthorize = async () => { signal?.throwIfAborted(); const after = await options.authorize(operation, signal); if (sha(after) !== sha(admission)) throw new Error("iMessage account or permission changed during the operation"); };
+          const result = await work(session, identity, reauthorize);
+          await reauthorize();
+          return result;
+        });
+      } finally { deadline.dispose(); }
+    })();
+    inFlight = pending;
+    try { return await pending; } finally { if (inFlight === pending) inFlight = undefined; }
+  }
+  return {
+    provider: "imessage",
+    inspect(signal) { return run("inspect", signal, async (session, identity) => providerStatus(session, identity)); },
+    conversations(input, signal) {
+      const limit = automationInteger(input.limit, 1, 200);
+      return run("conversations", signal, async (session, identity) => {
+        const result = await session.run([request("chats.list", { limit })]);
+        return { identity, conversations: project.parseChats(result.get("operation")).map(conversation), complete: false };
+      });
+    },
+    resolve(value, signal) { const selected = coordinate(value); return run("resolve", signal, async (session, identity) => ({ identity, conversation: await exactConversation(session, selected) })); },
+    history(input, signal) {
+      const selected = coordinate(input.coordinate), limit = automationInteger(input.limit, 1, 200);
+      return run("history", signal, async (session, identity) => {
+        await exactConversation(session, selected);
+        const response = await session.run([request("messages.history", { chat_id: selected.observedChatRowId, limit, attachments: false })]);
+        const raw = automationArray(automationRecord(response.get("operation"), ["messages"]).messages, limit);
+        const messages = raw.map(value => message(value, selected));
+        if (new Set(messages.map(item => item.id)).size !== messages.length) throw new Error("Repeated history identity");
+        const next = cursor(null, identity, [selected]);
+        for (const [index, value] of raw.entries()) {
+          const row = automationInteger((value as Record<string, unknown>).id, 1, Number.MAX_SAFE_INTEGER);
+          if (row > next.rows[0]!) { next.rows[0] = row; next.anchors[0] = { row, id: messages[index]!.id }; }
+        }
+        // Start after the newest verified history row, then silently drain any
+        // remaining rows to establish the initial live boundary.
+        return { identity, messages, nextCursor: Buffer.from(canonicalJson(next)).toString("base64url"), caughtUp: false, gap: false };
+      });
+    },
+    events(input, signal) {
+      const coordinates = automationArray(input.coordinates, 50).map(coordinate).sort((a, b) => canonicalJson(a).localeCompare(canonicalJson(b)));
+      if (coordinates.length === 0 || new Set(coordinates.map(sha)).size !== coordinates.length) throw new Error("Distinct iMessage event scopes required");
+      const limit = automationInteger(input.limit, 1, 500);
+      return run("events", signal, async (session, identity) => {
+        if (!methods(session).has("messages.after")) throw new Error("Database event cursor is unavailable");
+        const next = cursor(input.cursor, identity, coordinates);
+        const messages: AutomationMessage[] = []; let caughtUp = true;
+        for (const [index, selected] of coordinates.entries()) {
+          if (messages.length === limit) { caughtUp = false; break; }
+          await exactConversation(session, selected);
+          const anchor = next.anchors[index];
+          if (anchor) {
+            const proof = await session.run([request("messages.after", { chat_id: selected.observedChatRowId, since_rowid: anchor.row - 1, limit: 1, attachments: false, convert_attachments: false, include_reactions: true })]);
+            const proofPage = automationRecord(proof.get("operation"), ["messages", "next_rowid", "has_more"]);
+            const first = automationArray(proofPage.messages, 1)[0];
+            if (!first || (first as Record<string, unknown>).id !== anchor.row || message(first, selected).id !== anchor.id) throw new Error("iMessage cursor anchor changed; re-enrollment is required");
+          }
+          const remaining = limit - messages.length;
+          const result = await session.run([request("messages.after", { chat_id: selected.observedChatRowId, since_rowid: next.rows[index], limit: remaining, attachments: false, convert_attachments: false, include_reactions: true })]);
+          const page = automationRecord(result.get("operation"), ["messages", "next_rowid", "has_more"]);
+          const nextRow = automationInteger(page.next_rowid, next.rows[index]!, Number.MAX_SAFE_INTEGER);
+          if (typeof page.has_more !== "boolean" || page.has_more && nextRow === next.rows[index]) throw new Error("Nonprogressing iMessage cursor");
+          const rawMessages = automationArray(page.messages, remaining);
+          let previous = next.rows[index]!;
+          for (const raw of rawMessages) {
+            const parsed = message(raw, selected);
+            const rowId = automationInteger((raw as Record<string, unknown>).id, previous + 1, nextRow);
+            previous = rowId; messages.push(parsed); next.anchors[index] = { row: rowId, id: parsed.id };
+          }
+          next.rows[index] = nextRow;
+          if (page.has_more) caughtUp = false;
+        }
+        if (new Set(messages.map(item => item.id)).size !== messages.length) throw new Error("Repeated event identity");
+        return { identity, messages, nextCursor: Buffer.from(canonicalJson(next)).toString("base64url"), caughtUp, gap: false };
+      });
+    },
+    async send(input, signal): Promise<AutomationProviderSendResult> {
+      const selected = coordinate(input.coordinate), action = parseAutomationAction(input.action), expected = parseAutomationIdentity(input.identity);
+      let dispatched = false;
+      try {
+        return await run(action.kind, signal, async (session, identity, reauthorize) => {
+          if (sha(identity) !== sha(expected)) throw new Error("iMessage account or source changed before dispatch");
+          const live = await exactConversation(session, selected);
+          if (live.kind !== "single" || live.participants.length !== 1) throw new Error("Only direct participant-bound automation is supported");
+          if (!providerStatus(session, identity).actions[action.kind].available) throw new Error("Requested action is unavailable");
+          let method: string; const params: Record<string, unknown> = { chat_guid: selected.chatGuid };
+          if (action.kind === "text") { method = "send"; Object.assign(params, { text: action.text, service: "imessage", transport: "applescript", allow_sms_fallback: false }); }
+          else if (action.kind === "link") { method = "send.rich"; params.url = action.url; params.fetch_metadata = false; }
+          else if (action.kind === "poll") { if (action.maximumSelections !== null) throw new Error("Native iMessage polls use provider selection behavior"); method = "poll.send"; Object.assign(params, { question: action.question, options: action.options, suppress_comment: true }); }
+          else if (action.kind === "reaction" || action.kind === "sticker" || action.kind === "attachment") {
+            if ((action.kind === "reaction" || action.kind === "sticker") && action.messageId !== null) {
+              const current = await historyMessages(session, selected, 200);
+              if (!current.some(message => message.id === action.messageId && message.kind === "message")) throw new Error("Reaction or sticker target must belong to current conversation history");
+            }
+            if (action.kind === "reaction") {
+              if (!["❤️", "👍", "👎", "😂", "‼️", "❓"].includes(action.emoji)) throw new Error("This iMessage contract admits the six standard reactions");
+              method = "tapback"; Object.assign(params, { message_guid: action.messageId, emoji: action.emoji, remove: action.remove });
+            } else {
+              const asset = await options.resolveAsset(action.assetId, signal);
+              const maximum = action.kind === "sticker" ? 500 * 1024 : 16 * 1024 * 1024;
+              if (!(asset.bytes instanceof Uint8Array) || asset.bytes.byteLength < 1 || asset.bytes.byteLength > maximum) throw new Error("Attachment byte admission failed");
+              const bytes = Buffer.from(asset.bytes);
+              if (createHash("sha256").update(bytes).digest("hex") !== automationDigest(asset.sha256)) throw new Error("Attachment byte admission failed");
+              const path = join(session.operationRoot, action.kind === "attachment" ? action.name : "sticker");
+              const file = await open(path, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+              try { await file.writeFile(bytes); await file.sync(); } finally { await file.close(); }
+              params.file = path;
+              if (action.kind === "sticker") { method = "send.sticker"; if (action.messageId !== null) params.attach_to = action.messageId; }
+              else { method = "send"; Object.assign(params, { service: "imessage", transport: "applescript", allow_sms_fallback: false }); }
+            }
+          } else throw new Error("No reviewed iMessage implementation exists for this experience");
+          signal?.throwIfAborted();
+          const response = await session.run([request(method, params)], async () => {
+            await reauthorize();
+            if (sha(await exactConversation(session, selected)) !== sha(live)) throw new Error("iMessage participants changed before dispatch");
+            await reauthorize();
+            dispatched = true;
+          });
+          const raw = response.get("operation");
+          if (raw === null || typeof raw !== "object" || Array.isArray(raw)) throw new Error("Invalid iMessage acceptance");
+          const result = raw as Record<string, unknown>;
+          if (action.kind === "text" || action.kind === "attachment") {
+            const accepted = project.parseSendAccepted(result, target(selected));
+            return { state: "accepted", messageId: automationText(accepted.messageGuid, 256), providerReceiptId: null, delivery: "unknown" };
+          }
+          const allowed = action.kind === "reaction" ? ["ok", "reaction"] : action.kind === "poll" ? ["ok", "event", "guid", "message_id", "poll"] : action.kind === "link" ? ["ok", "id", "guid", "message_id", "messageGuid", "chat_guid", "chatGuid", "queued", "service", "richLinkImageUsed"] : ["ok", "transfer_guid"];
+          if (result.ok !== true || Object.keys(result).some(key => !allowed.includes(key)) || result.chat_guid !== undefined && result.chat_guid !== selected.chatGuid || result.transport !== undefined && result.transport !== "applescript") throw new Error("iMessage acceptance changed");
+          const ids = [result.guid, result.message_id, result.messageGuid].filter(value => value !== undefined).map(value => automationText(value, 256));
+          const messageId = ids[0] ?? null;
+          if (ids.some(value => value !== messageId)) throw new Error("Ambiguous iMessage result identity");
+          if (result.chatGuid !== undefined && result.chatGuid !== selected.chatGuid || result.queued !== undefined && typeof result.queued !== "boolean") throw new Error("iMessage rich-link receipt changed");
+          if (action.kind === "link" && (result.service !== undefined && result.service !== "iMessage" || result.richLinkImageUsed !== undefined && result.richLinkImageUsed !== false)) throw new Error("iMessage rich-link transport or metadata mode changed");
+          if (result.id !== undefined) automationInteger(result.id, 1, Number.MAX_SAFE_INTEGER);
+          if (action.kind === "link" && messageId === null) throw new Error("Rich-link acceptance has no reconciled message identity");
+          const providerReceiptId = result.transfer_guid === undefined ? null : automationText(result.transfer_guid, 256);
+          if (action.kind === "reaction") { automationRecord(result, ["ok", "reaction"]); automationInteger(result.reaction, action.remove ? 3000 : 2000, action.remove ? 3005 : 2005); }
+          if (action.kind === "sticker") { automationRecord(result, ["ok", "transfer_guid"]); if (providerReceiptId === null) throw new Error("Sticker transfer receipt is missing"); }
+          if (action.kind === "poll" && (result.event !== "imessage.poll.created" || messageId === null)) throw new Error("Poll creation receipt is missing");
+          return { state: "accepted", messageId, providerReceiptId, delivery: "unknown" };
+        });
+      } catch { return { state: dispatched ? "indeterminate" : "not-started", reason: dispatched ? "iMessage dispatch or process cleanup could not be reconciled. Do not retry." : "iMessage admission failed before any send." }; }
+    },
+    async close() { closed = true; await inFlight; },
+  };
+}

package/src/providers/imessage-direct-install.ts

@@ -9,6 +9,7 @@ import {
   unlink,
 } from "node:fs/promises";
 import { isAbsolute, join } from "node:path";
+import { ensureImsgNativeResources, verifyImsgNativeResources } from "./messaging-native-install";
 
 import {
   ensurePrivateStateDirectory,
@@ -136,6 +137,11 @@ export async function resolvePinnedImsgBinary(
       `reviewed imsg transport ${IMSG_REVIEWED_VERSION} is unavailable or failed integrity verification`,
     );
   }
+  try {
+    await verifyImsgNativeResources(join(ghostgetStateHome(environment), "tools", "imsg", IMSG_REVIEWED_VERSION));
+  } catch {
+    throw installFailure("reviewed imsg resources are unavailable or failed integrity verification");
+  }
   return resolved;
 }
 
@@ -274,6 +280,7 @@ export async function installReviewedImsgBinary(
   try {
     ensurePrivateStateDirectory(installDirectory, environment);
     await validateInstallDirectory(installDirectory);
+    await ensureImsgNativeResources(installDirectory, environment);
   } catch (error) {
     if (error instanceof ImsgInstallFailure) throw error;
     throw installFailure("imsg install state directory is unavailable or unsafe");

package/src/providers/imessage-direct-runtime.ts

@@ -891,7 +891,7 @@ function parseMessages(
 
 function parseSendAccepted(
   value: unknown,
-  input: ImsgMessagingSendInput,
+  input: ImsgChatCoordinate,
 ): Readonly<Record<string, unknown>> {
   const source = record(value, "imsg send result");
   exactKeys(source, [
@@ -1033,6 +1033,9 @@ async function withRuntime<T>(
   durableCleanupAdmissionRequired: boolean,
   operation: (context: Readonly<{
     subject: string;
+    sourceGeneration: string;
+    status: unknown;
+    operationRoot: string;
     run: (
       requests: readonly ImsgRpcRequest[],
       beforeSpawn?: () => Promise<void>,
@@ -1053,6 +1056,11 @@ async function withRuntime<T>(
       ?? join(homedir(), "Library", "Messages");
     const store = await validateMessagesStore(auth.path, expectedStorePath);
     const subject = subjectForStore(store.storePath);
+    const databaseIdentity = await lstat(store.databasePath, { bigint: true });
+    const sourceGeneration = createHash("sha256").update(canonicalJson({
+      subject, device: String(databaseIdentity.dev), inode: String(databaseIdentity.ino),
+      birthtime: String(databaseIdentity.birthtimeNs),
+    })).digest("hex");
     if (auth.subject !== undefined && auth.subject !== subject) {
       throw new Error("current Messages device-default realm does not match the bound auth subject");
     }
@@ -1107,7 +1115,12 @@ async function withRuntime<T>(
       await realpath(reportedDatabasePath) !== reportedDatabasePath
       || reportedDatabasePath !== store.databasePath
     ) throw new Error("imsg status reported a different Messages database than the bound subject");
-    return await operation(Object.freeze({ subject, run }));
+    const result = await operation(Object.freeze({ subject, sourceGeneration, status: status.get("status"), operationRoot, run }));
+    const after = await lstat(store.databasePath, { bigint: true });
+    if (after.dev !== databaseIdentity.dev || after.ino !== databaseIdentity.ino || after.birthtimeNs !== databaseIdentity.birthtimeNs || after.isSymbolicLink()) {
+      throw new Error("Messages database generation changed during the operation");
+    }
+    return result;
   } finally {
     try {
       if (operationRoot === undefined) {
@@ -1137,6 +1150,23 @@ async function withRuntime<T>(
   }
 }
 
+/** Internal trusted host seam: retains the pinned executable, exact database,
+ * durable process cleanup and deadline used by the existing provider runtime.
+ * Callers build only reviewed semantic requests; this is never an agent tool. */
+export async function withImsgAutomationRuntime<T>(
+  auth: GhostgetAuth,
+  options: LocalCliExecutionOptions & Readonly<{ dependencies?: ImsgDirectRuntimeDependencies }>,
+  operation: Parameters<typeof withRuntime<T>>[9],
+): Promise<T> {
+  if (options.registerCleanupBarrier === undefined) throw new Error("Messaging automation requires durable provider cleanup custody");
+  return startProviderPluginCleanupTrackedOperation(options.registerCleanupBarrier, (publish, cleanup) => withRuntime(
+    requireImsgAuth(auth), 30_000, 10 * 1024 * 1024, options.dependencies,
+    options.environment ?? process.env, options.operationDeadline, publish, cleanup, true, operation,
+  ));
+}
+
+export const imsgAutomationProjection = Object.freeze({ parseChats, parseChat, parseMessages, parseMessage, exactChat, parseSendAccepted });
+
 export async function inspectImsgDirectRuntime(
   environment: Readonly<Record<string, string | undefined>>,
 ): Promise<LocalCliPluginRuntimeStatusV1> {

package/src/providers/imessage-direct.ts

@@ -13,7 +13,11 @@ export const IMSG_EXACT_CHAT_PATCH_COMMIT =
   "c5994f00d17969fd7772fd2772e7b3591089513a" as const;
 export const IMSG_EXACT_CHAT_PATCH_SHA256 =
   "b05aa92a078930f96fda611c674436638843f7b148d7bfa3b65ed1ccb0885c13" as const;
-export const IMSG_REVIEWED_PATCH_COMMIT = IMSG_EXACT_CHAT_PATCH_COMMIT;
+export const IMSG_NO_FETCH_RICH_CARDS_PATCH_COMMIT =
+  "520b82ab025c1d4d57333b552aa65c9ae3fdb5fd" as const;
+export const IMSG_NO_FETCH_RICH_CARDS_PATCH_SHA256 =
+  "c2346afca4dd0f9721c235db4f692d6a2d6dece36481e074d94b5ce78f2e019b" as const;
+export const IMSG_REVIEWED_PATCH_COMMIT = IMSG_NO_FETCH_RICH_CARDS_PATCH_COMMIT;
 export const IMSG_REVIEWED_PATCHES = Object.freeze([
   Object.freeze({
     commit: IMSG_PRIVATE_TRANSPORT_PATCH_COMMIT,
@@ -23,11 +27,17 @@ export const IMSG_REVIEWED_PATCHES = Object.freeze([
     commit: IMSG_EXACT_CHAT_PATCH_COMMIT,
     sha256: IMSG_EXACT_CHAT_PATCH_SHA256,
   }),
+  Object.freeze({
+    commit: IMSG_NO_FETCH_RICH_CARDS_PATCH_COMMIT,
+    sha256: IMSG_NO_FETCH_RICH_CARDS_PATCH_SHA256,
+  }),
 ]);
 export const IMSG_REVIEWED_VERSION =
-  "0.14.1+private-transport.2" as const;
+  "0.14.1+private-transport.3" as const;
 export const IMSG_DARWIN_ARM64_EXECUTABLE_SHA256 =
-  "77a0db864dfd247cd0a9142dd98997960582e6f150f76ecd3bf1c38944f2bf71" as const;
+  "46c4c73c81c7db2d516c2d467c66aff03c73de196996d646bc8afce0ea85cff6" as const;
+// The exact .3 source and binary pins include the tested no-fetch RPC mode.
+export const IMSG_NO_FETCH_RICH_CARDS_AVAILABLE = true;
 
 export const IMSG_TOOL_PIN = Object.freeze({
   id: "imsg-private-transport",

package/src/providers/linkedin-contact-failure.ts

@@ -16,6 +16,27 @@ export class LinkedInContactIdentityMismatch extends Error {
   }
 }
 
+export function isLinkedInContactGraphqlUnavailable(error: unknown): boolean {
+  let current: unknown = error;
+  for (let depth = 0; depth < 8 && current !== undefined; depth += 1) {
+    if (current instanceof LinkedInProfileBrowserResponseRejectedError) {
+      return current.status === 403
+        || current.contentType === "text/html"
+        || current.contentType === "missing";
+    }
+    if (
+      current instanceof Error
+      && "cause" in current
+      && current.cause !== current
+    ) {
+      current = current.cause;
+      continue;
+    }
+    break;
+  }
+  return false;
+}
+
 export function linkedInContactReadFailure(
   error: unknown,
   stage: LinkedInContactStage,

package/src/providers/linkedin-contact-platform.ts

@@ -4,7 +4,10 @@ import * as Layer from "effect/Layer";
 import { ReadEffectFailure, readAttempt } from "../read-effect";
 import { readNative } from "../read-effect-platform";
 import { LinkedInContactIdentityMismatch } from "./linkedin-contact-failure";
-import type { LinkedInContactInfoJsonInput } from "./linkedin-web-contact";
+import type {
+  LinkedInContactInfoJsonInput,
+  LinkedInContactNavigationInput,
+} from "./linkedin-web-contact";
 import type { LinkedInProfileBrowserTransport } from "./linkedin-web-profile-browser";
 
 export type LinkedInContactIdentity = { readonly subject: string };
@@ -30,6 +33,10 @@ function platform(ports: LinkedInContactNative) {
       readNative(() => browser.readProfileHtml(profileUrl)).pipe(Effect.uninterruptible),
     contactPayload: (browser: LinkedInProfileBrowserTransport, input: LinkedInContactInfoJsonInput) =>
       readNative(() => browser.readContactInfoJson(input)).pipe(Effect.uninterruptible),
+    contactOverlay: (browser: LinkedInProfileBrowserTransport, input: LinkedInContactInfoJsonInput) =>
+      readNative(() => browser.readContactOverlayText(input)).pipe(Effect.uninterruptible),
+    contactNavigation: (browser: LinkedInProfileBrowserTransport, input: LinkedInContactNavigationInput) =>
+      readNative(() => browser.readContactNavigationText(input)).pipe(Effect.uninterruptible),
     observedAt: readAttempt(ports.observedAt),
     closeBrowser: (browser: LinkedInProfileBrowserTransport) =>
       readNative(() => browser.close()).pipe(Effect.uninterruptible),

package/src/providers/linkedin-contact-program.ts

@@ -4,11 +4,14 @@ import { readAttempt, type ReadEffectFailure, withReadResource } from "../read-e
 import type { WebSessionExecution } from "../web-session-execution";
 import { LinkedInContactPlatform } from "./linkedin-contact-platform";
 import {
+  isLinkedInContactGraphqlUnavailable,
   linkedInContactDiagnostic,
   linkedInContactReadFailure,
   type LinkedInContactStage,
 } from "./linkedin-contact-failure";
 import {
+  extractLinkedInContactNavigationAction,
+  linkedInContactNavigationActionError,
   projectLinkedInContactInfo,
   projectLinkedInEmbeddedContactFields,
   projectLinkedInProfileContactBinding,
@@ -50,12 +53,38 @@ export function linkedInContactReadProgram(
           });
         } else {
           stage = "contact";
-          const queryId = resolveLinkedInProfileContactInfoQueryId(profileHtml);
-          contactPayload = yield* platform.contactPayload(browser, {
-            profileUrl: target.url,
+          const navigation = yield* readAttempt(() => extractLinkedInContactNavigationAction({
+            profileHtml,
+            publicIdentifier: binding.vanity,
             profileUrn: binding.profileUrn,
-            ...(queryId === undefined ? {} : { queryId }),
-          });
+          }));
+          if (navigation.kind === "action") {
+            contactPayload = yield* platform.contactNavigation(browser, {
+              profileUrl: target.url,
+              profileUrn: binding.profileUrn,
+              sduiid: navigation.action.sduiid,
+              clientArguments: navigation.action.clientArguments,
+            });
+          } else if (navigation.kind !== "absent") {
+            yield* readAttempt(() => {
+              throw linkedInContactNavigationActionError(navigation);
+            });
+          } else {
+            const queryId = resolveLinkedInProfileContactInfoQueryId(profileHtml);
+            const contactInput = {
+              profileUrl: target.url,
+              profileUrn: binding.profileUrn,
+              ...(queryId === undefined ? {} : { queryId }),
+            };
+            contactPayload = queryId === undefined
+              ? yield* platform.contactOverlay(browser, contactInput)
+              : yield* platform.contactPayload(browser, contactInput).pipe(
+                Effect.catchIf(
+                  (error) => isLinkedInContactGraphqlUnavailable(error),
+                  () => platform.contactOverlay(browser, contactInput),
+                ),
+              );
+          }
         }
         stage = "projection";
         const observedAt = yield* platform.observedAt;