@hraness/ghostget 0.17.2

package/dist/whatsapp-client.js

@@ -0,0 +1,355 @@
+// @bun
+import {
+  canonicalJson,
+  sha256
+} from "./index-gwk7rbyj.js";
+
+// src/whatsapp-client.ts
+import { spawnSync } from "child_process";
+import { existsSync } from "fs";
+import { fileURLToPath } from "url";
+import { types as nodeTypes } from "util";
+
+// src/whatsapp-client-binding.ts
+function fail(message) {
+  throw new Error(`Ghostget WhatsApp client: ${message}`);
+}
+function requireWhatsAppMessageLikeMeReceiptRequestBinding(receipt, request) {
+  if (receipt.auth.id !== request.authId) {
+    return fail("receipt auth identity does not match the requested auth locator");
+  }
+  if (receipt.output.directory !== request.output) {
+    return fail("receipt output directory does not match the requested output");
+  }
+  return receipt;
+}
+
+// src/whatsapp-export-coordinate.ts
+import { dirname, isAbsolute, resolve } from "path";
+var WHATSAPP_EXPORT_AUTH_ID_PATTERN = /^[a-z][a-z0-9-]{0,47}$/u;
+var MAX_WHATSAPP_EXPORT_OUTPUT_BYTES = 4096;
+function isWhatsAppExportAuthId(value) {
+  return typeof value === "string" && WHATSAPP_EXPORT_AUTH_ID_PATTERN.test(value);
+}
+function isWhatsAppExportOutputDirectory(value) {
+  return typeof value === "string" && isAbsolute(value) && resolve(value) === value && dirname(value) !== value && Buffer.byteLength(value, "utf8") <= MAX_WHATSAPP_EXPORT_OUTPUT_BYTES && !/[\0\r\n]/u.test(value);
+}
+
+// src/whatsapp-client.ts
+var MAX_STDOUT_BYTES = 2 * 1024 * 1024;
+var MAX_STDERR_BYTES = 8 * 1024;
+var MAX_V2_RECORDS = 500000;
+var PROCESS_TIMEOUT_MS = 6 * 60 * 60 * 1000 + 60000;
+var DIGEST_PATTERN = /^[a-f0-9]{64}$/u;
+function fail2(message) {
+  throw new Error(`Ghostget WhatsApp client: ${message}`);
+}
+function record(value, label) {
+  if (typeof value !== "object" || value === null || Array.isArray(value) || nodeTypes.isProxy(value) || Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null)
+    return fail2(`${label} must be a plain data object`);
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  for (const key of Reflect.ownKeys(descriptors)) {
+    if (typeof key !== "string")
+      return fail2(`${label} must contain only enumerable string data fields`);
+    const descriptor = descriptors[key];
+    if (descriptor === undefined || !descriptor.enumerable || !("value" in descriptor)) {
+      return fail2(`${label} must contain only enumerable string data fields`);
+    }
+  }
+  return Object.freeze(Object.fromEntries(Object.entries(descriptors).map(([key, descriptor]) => [key, descriptor.value])));
+}
+function exact(value, keys, label) {
+  const observed = Object.keys(value).sort();
+  const expected = [...keys].sort();
+  if (observed.length !== expected.length || observed.some((key, index) => key !== expected[index])) {
+    fail2(`${label} contains unsupported or missing fields`);
+  }
+}
+function timestamp(value, label, nullable = false) {
+  if (nullable && value === null)
+    return null;
+  if (typeof value !== "string")
+    return fail2(`${label} must be a timestamp`);
+  const parsed = new Date(value);
+  if (!Number.isFinite(parsed.getTime()) || parsed.toISOString() !== value) {
+    return fail2(`${label} must be a canonical UTC timestamp`);
+  }
+  return value;
+}
+function digest(value, label) {
+  if (typeof value !== "string" || !DIGEST_PATTERN.test(value)) {
+    return fail2(`${label} must be lowercase SHA-256`);
+  }
+  return value;
+}
+function nonNegative(value, label) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+    return fail2(`${label} must be a non-negative safe integer`);
+  }
+  return value;
+}
+function denseDataArray(value, label, maximum) {
+  if (nodeTypes.isProxy(value) || !Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype)
+    return fail2(`${label} must be an ordinary non-proxy array`);
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  const lengthDescriptor = Object.getOwnPropertyDescriptor(value, "length");
+  if (lengthDescriptor === undefined || !("value" in lengthDescriptor) || typeof lengthDescriptor.value !== "number" || !Number.isSafeInteger(lengthDescriptor.value) || lengthDescriptor.value < 0 || lengthDescriptor.value > maximum)
+    return fail2(`${label} length exceeds its reviewed bound`);
+  const length = lengthDescriptor.value;
+  const keys = Reflect.ownKeys(descriptors);
+  if (keys.length !== length + 1 || keys.some((key) => typeof key !== "string"))
+    return fail2(`${label} must be a dense array without named properties`);
+  const items = [];
+  for (let index = 0;index < length; index += 1) {
+    const descriptor = descriptors[String(index)];
+    if (descriptor === undefined || !descriptor.enumerable || !("value" in descriptor))
+      return fail2(`${label} must contain only dense enumerable data elements`);
+    items.push(descriptor.value);
+  }
+  if (keys.some((key) => key !== "length" && (typeof key !== "string" || !/^(0|[1-9][0-9]*)$/u.test(key)))) {
+    return fail2(`${label} must be a dense array without named properties`);
+  }
+  return Object.freeze(items);
+}
+function parseWhatsAppMessageLikeMeExportReceipt(value) {
+  const root = record(value, "receipt");
+  exact(root, [
+    "schemaVersion",
+    "format",
+    "runId",
+    "operation",
+    "status",
+    "transport",
+    "startedAt",
+    "finishedAt",
+    "auth",
+    "source",
+    "provider",
+    "completeness",
+    "warnings",
+    "counts",
+    "output",
+    "privacy",
+    "integrity"
+  ], "receipt");
+  if (root.schemaVersion !== 1 || root.format !== "wrench.whatsapp-message-like-me-export-receipt" || typeof root.runId !== "string" || !/^[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$/u.test(root.runId) || root.operation !== "whatsapp.export-message-like-me" || root.status !== "succeeded" || root.transport !== "linked-device-local-store")
+    return fail2("receipt identity is unsupported");
+  const startedAt = timestamp(root.startedAt, "receipt.startedAt");
+  const finishedAt = timestamp(root.finishedAt, "receipt.finishedAt");
+  if (finishedAt < startedAt)
+    return fail2("receipt timestamps are reversed");
+  const auth = record(root.auth, "receipt.auth");
+  exact(auth, ["id", "provider", "identitySha256"], "receipt.auth");
+  if (!isWhatsAppExportAuthId(auth.id)) {
+    return fail2("receipt.auth.id is not a bounded lowercase auth coordinate");
+  }
+  const parsedAuthId = auth.id;
+  if (auth.provider !== "whatsapp")
+    return fail2("receipt auth identity is unsupported");
+  const identitySha256 = digest(auth.identitySha256, "receipt.auth.identitySha256");
+  const source = record(root.source, "receipt.source");
+  exact(source, ["id", "version"], "receipt.source");
+  const provider = record(root.provider, "receipt.provider");
+  exact(provider, ["id", "version"], "receipt.provider");
+  if (source.id !== "wacli-local" || source.version !== "1.0.0" || provider.id !== "whatsapp" || provider.version !== "0.15.0")
+    return fail2("receipt producer identity is unsupported");
+  const completeness = record(root.completeness, "receipt.completeness");
+  exact(completeness, ["kind", "reason", "observedFrom", "observedThrough"], "receipt.completeness");
+  if (completeness.kind !== "bounded-local" || completeness.reason !== "local-store-coverage-unknown")
+    return fail2("receipt completeness boundary is unsupported");
+  const observedFrom = timestamp(completeness.observedFrom, "receipt.completeness.observedFrom", true);
+  const observedThrough = timestamp(completeness.observedThrough, "receipt.completeness.observedThrough", true);
+  if (observedFrom === null !== (observedThrough === null) || observedFrom !== null && observedThrough !== null && observedThrough < observedFrom) {
+    return fail2("receipt completeness timestamps are reversed");
+  }
+  const warnings = denseDataArray(root.warnings, "receipt.warnings", 5);
+  const warningOrder = [
+    "remote-history-incomplete",
+    "reaction-state-unproven",
+    "self-chat-excluded",
+    "message-payload-purged",
+    "non-conversation-chats-excluded"
+  ];
+  if (warnings[0] !== warningOrder[0] || warnings.some((item) => typeof item !== "string" || !warningOrder.includes(item)) || warnings.some((item, index) => index > 0 && warningOrder.indexOf(item) <= warningOrder.indexOf(warnings[index - 1])))
+    return fail2("receipt warnings are unsupported");
+  const warningTail = warnings.slice(1).map((warning) => warning);
+  const canonicalWarnings = Object.freeze([
+    "remote-history-incomplete",
+    ...warningTail
+  ]);
+  const counts = record(root.counts, "receipt.counts");
+  const countKinds = ["account", "participant", "conversation", "message", "reaction", "tombstone"];
+  exact(counts, countKinds, "receipt.counts");
+  const parsedCounts = Object.fromEntries(countKinds.map((kind) => [
+    kind,
+    nonNegative(counts[kind], `receipt.counts.${kind}`)
+  ]));
+  const observed = observedFrom !== null;
+  const totalRecords = countKinds.reduce((total, kind) => total + parsedCounts[kind], 0);
+  if (parsedCounts.account !== 1 || parsedCounts.participant < 1 || parsedCounts.reaction !== 0 || parsedCounts.tombstone !== 0 || parsedCounts.message > 0 !== observed || parsedCounts.conversation > 0 !== observed || parsedCounts.conversation > parsedCounts.message || parsedCounts.message > MAX_V2_RECORDS || parsedCounts.participant > parsedCounts.message + 1 || !Number.isSafeInteger(totalRecords) || totalRecords > MAX_V2_RECORDS || warnings.includes("message-payload-purged") && parsedCounts.message === 0)
+    return fail2("receipt counts contradict the fixed producer");
+  const output = record(root.output, "receipt.output");
+  exact(output, ["schemaVersion", "format", "directory", "manifestSha256"], "receipt.output");
+  if (!isWhatsAppExportOutputDirectory(output.directory)) {
+    return fail2("receipt.output.directory is not a bounded normalized non-root absolute directory");
+  }
+  const parsedOutputDirectory = output.directory;
+  if (output.schemaVersion !== 2 || output.format !== "message-like-me.local-message-bundle")
+    return fail2("receipt output identity is unsupported");
+  const manifestSha256 = digest(output.manifestSha256, "receipt.output.manifestSha256");
+  const privacy = record(root.privacy, "receipt.privacy");
+  exact(privacy, [
+    "classification",
+    "attachments",
+    "credentials",
+    "sourcePaths",
+    "mediaBytes",
+    "cloudSync"
+  ], "receipt.privacy");
+  if (privacy.classification !== "private-local" || privacy.attachments !== "metadata-only" || privacy.credentials !== "excluded" || privacy.sourcePaths !== "excluded" || privacy.mediaBytes !== "excluded" || privacy.cloudSync !== "none")
+    return fail2("receipt privacy boundary is unsupported");
+  const integrity = record(root.integrity, "receipt.integrity");
+  exact(integrity, ["algorithm", "receiptSha256"], "receipt.integrity");
+  if (integrity.algorithm !== "sha256")
+    return fail2("receipt integrity algorithm is unsupported");
+  const expectedDigest = digest(integrity.receiptSha256, "receipt.integrity.receiptSha256");
+  const projection = Object.freeze({
+    schemaVersion: 1,
+    format: "wrench.whatsapp-message-like-me-export-receipt",
+    runId: root.runId,
+    operation: "whatsapp.export-message-like-me",
+    status: "succeeded",
+    transport: "linked-device-local-store",
+    startedAt,
+    finishedAt,
+    auth: Object.freeze({
+      id: parsedAuthId,
+      provider: "whatsapp",
+      identitySha256
+    }),
+    source: Object.freeze({ id: "wacli-local", version: "1.0.0" }),
+    provider: Object.freeze({ id: "whatsapp", version: "0.15.0" }),
+    completeness: Object.freeze({
+      kind: "bounded-local",
+      reason: "local-store-coverage-unknown",
+      observedFrom,
+      observedThrough
+    }),
+    warnings: canonicalWarnings,
+    counts: Object.freeze({
+      account: 1,
+      participant: parsedCounts.participant,
+      conversation: parsedCounts.conversation,
+      message: parsedCounts.message,
+      reaction: 0,
+      tombstone: 0
+    }),
+    output: Object.freeze({
+      schemaVersion: 2,
+      format: "message-like-me.local-message-bundle",
+      directory: parsedOutputDirectory,
+      manifestSha256
+    }),
+    privacy: Object.freeze({
+      classification: "private-local",
+      attachments: "metadata-only",
+      credentials: "excluded",
+      sourcePaths: "excluded",
+      mediaBytes: "excluded",
+      cloudSync: "none"
+    })
+  });
+  if (sha256(canonicalJson(projection)) !== expectedDigest) {
+    return fail2("receipt digest does not match its canonical projection");
+  }
+  return Object.freeze({
+    ...projection,
+    integrity: Object.freeze({ algorithm: "sha256", receiptSha256: expectedDigest })
+  });
+}
+function cliSourcePath() {
+  const besideSource = fileURLToPath(new URL("./cli.ts", import.meta.url));
+  if (existsSync(besideSource))
+    return besideSource;
+  const packagedSource = fileURLToPath(new URL("../src/cli.ts", import.meta.url));
+  if (existsSync(packagedSource))
+    return packagedSource;
+  return fail2("the installed Ghostget CLI source is unavailable");
+}
+function preparedEnvironment(additions) {
+  const environment = Object.create(null);
+  for (const [key, value] of Object.entries(process.env)) {
+    if (typeof value === "string")
+      environment[key] = value;
+  }
+  if (additions === undefined)
+    return Object.freeze(environment);
+  const source = record(additions, "options.environment");
+  for (const [key, value] of Object.entries(source)) {
+    if (key.length < 1 || key.includes("=") || key.includes("\x00")) {
+      return fail2("environment name is malformed");
+    }
+    if (value === undefined)
+      delete environment[key];
+    else if (typeof value !== "string" || value.includes("\x00")) {
+      return fail2("environment value is malformed");
+    } else
+      environment[key] = value;
+  }
+  return Object.freeze(environment);
+}
+function exportWhatsAppMessageLikeMeSync(requestValue, optionsValue = {}) {
+  if (typeof process.versions.bun !== "string") {
+    return fail2("@hraness/ghostget/whatsapp requires Bun");
+  }
+  const request = record(requestValue, "request");
+  exact(request, ["authId", "output"], "request");
+  if (!isWhatsAppExportAuthId(request.authId)) {
+    return fail2("request.authId is not a bounded lowercase auth coordinate");
+  }
+  if (!isWhatsAppExportOutputDirectory(request.output)) {
+    return fail2("request.output is not a bounded normalized non-root absolute directory");
+  }
+  const requestedAuthId = request.authId;
+  const requestedOutput = request.output;
+  const requested = Object.freeze({
+    authId: requestedAuthId,
+    output: requestedOutput
+  });
+  const options = record(optionsValue, "options");
+  exact(options, Object.hasOwn(options, "environment") ? ["environment"] : [], "options");
+  const result = spawnSync(process.execPath, [
+    cliSourcePath(),
+    "whatsapp",
+    "export-message-like-me",
+    "--auth",
+    requestedAuthId,
+    "--output",
+    requestedOutput,
+    "--json"
+  ], {
+    cwd: process.cwd(),
+    env: preparedEnvironment(options.environment),
+    encoding: "utf8",
+    maxBuffer: MAX_STDOUT_BYTES,
+    timeout: PROCESS_TIMEOUT_MS,
+    stdio: ["ignore", "pipe", "inherit"]
+  });
+  if (result.error !== undefined)
+    return fail2("installed CLI could not complete the export");
+  if (result.status !== 0 || result.signal !== null) {
+    const errorText = typeof result.stderr === "string" ? Buffer.from(result.stderr, "utf8").subarray(0, MAX_STDERR_BYTES).toString("utf8").trim() : "";
+    return fail2(errorText.length > 0 ? errorText : "installed CLI rejected the export");
+  }
+  let raw;
+  try {
+    raw = JSON.parse(result.stdout.trim());
+  } catch {
+    return fail2("installed CLI returned malformed JSON");
+  }
+  return requireWhatsAppMessageLikeMeReceiptRequestBinding(parseWhatsAppMessageLikeMeExportReceipt(raw), requested);
+}
+export {
+  parseWhatsAppMessageLikeMeExportReceipt,
+  exportWhatsAppMessageLikeMeSync
+};

package/docs/imessage-direct-provider.md

@@ -0,0 +1,106 @@
+# Direct iMessage provider
+
+The `imessage` source plugin wraps one exact reviewed `openclaw/imsg` build. It
+supports bounded local chat and message reads plus confirmed one-to-eight-bubble
+turns to an exact live chat GUID. The mutation path is fixed to AppleScript and
+`iMessage`, with SMS fallback disabled.
+
+The plugin does not select an Apple ID. Messages chooses the device-default
+account and routing identity. `account_id`, `account_login`, and
+`last_addressed_handle` from `chat.db` are observations for route inspection,
+not a selectable or proven sending account. The auth subject binds a canonical
+local Messages store coordinate and this device-default policy. It does not
+claim to identify the signed-in Apple account.
+
+## Reviewed transport
+
+The vendored patch stack applies to `openclaw/imsg` 0.14.1 at commit
+`25beb76c902b0acf2dd7ae392f1b0792f6813240`. The first commit,
+`292db82d89293867ef847a2875667fea0fdd5dc1`, isolates AppleScript payloads.
+The second, `c5994f00d17969fd7772fd2772e7b3591089513a`, adds the read-only exact
+`chats.get(chat_id)` lookup required to revalidate a route without relying on a
+bounded recent-chat scan. Patch SHA-256 values, changed files, and the full
+artifact review boundary are recorded in
+`src/plugins/imessage-direct/vendor/provenance.json`.
+
+AppleScript source remains on standard input. Recipient, text, service,
+attachment path, chat target, and the chat-routing flag live in checked
+mode-0600 files under one random mode-0700 directory. The nested `osascript`
+argv contains only fixed interpreter switches and an opaque random locator.
+The patch rejects symlinks, file substitution, owner or mode changes, and
+in-place content changes. It reaps the child before removing known private
+files and the checked directory.
+
+The Ghostget runtime adds an outer boundary. Every RPC child is a fresh detached
+process group with fixed argv `imsg rpc`, bounded stdin/stdout/stderr, a fixed
+minimal environment, a total deadline, and durable cleanup admission. Each
+confirmed bubble produces one separately journaled send process and exactly one
+send request. Private message text appears only in that process's RPC stdin.
+Timeout, signal, malformed output, or lost output after spawn is indeterminate.
+The runtime never retries.
+
+`imsg rpc status` is the exact nonlaunching readiness probe. It retries the database open and
+probes only an already-running private bridge. It does not launch, kill, or
+relaunch Messages. Ghostget requires protocol 1, imsg 0.14.1, a readable database,
+and the reviewed `chats.get`, read, and send methods. This proves the local contract is currently
+usable, not which Apple account Messages will choose.
+
+## Build and installation boundary
+
+Apply both vendored mail patches in order to an otherwise clean checkout at the exact base,
+then build `imsg` in release mode. The current reviewed macOS arm64 executable
+SHA-256 is
+`77a0db864dfd247cd0a9142dd98997960582e6f150f76ecd3bf1c38944f2bf71`.
+Compiler, SDK, and command provenance are in the manifest. A different byte is
+not this reviewed transport, even if it prints version 0.14.1.
+
+Install only that byte sequence through the checked installer:
+
+```sh
+ghostget imessage transport install --binary /absolute/path/to/imsg --json
+```
+
+The installer supports only the declared current platform, reads the source
+without following a symlink, checks owner, mode, size, stability, and SHA-256,
+and installs by an exclusive same-filesystem link. It never replaces mismatched
+existing bytes. Software build, installation, Messages login, and account
+recovery remain operator workflows, not provider operations.
+
+Bind the local Messages store after the reviewed binary is installed:
+
+```sh
+ghostget adapter sync-bundled --json
+ghostget auth add imessage-main --linked-device imessage \
+  --device-store "${HOME}/Library/Messages"
+ghostget auth bind imessage-main --site imessage
+```
+
+macOS must grant the invoking terminal Full Disk Access for `chat.db` and
+Automation access to Messages for a send. No live send is part of installation
+or subject binding.
+
+## Outcome boundary
+
+Stock AppleScript does not return a message GUID. A Ghostget result is
+`submitted` only when the patched imsg process independently observes one
+matching outgoing `chat.db` row and returns the exact message GUID, chat GUID,
+row ID, `iMessage` service, and `applescript` transport. This is evidence of
+local Messages acceptance, not network delivery or recipient receipt.
+
+The transport preserves imsg's `not_started`, `may_have_completed`, and
+`still_in_flight` categories in encrypted provider output. Once Ghostget has
+started the confirmed child, every non-accepted result remains non-retryable at
+the Ghostget boundary. The separately requested `messaging.delivery.read`
+operation can inspect only a GUID already obtained from exact accepted evidence.
+A missing row is not proof that an unobserved send did not happen.
+
+Threaded replies are unsupported because AppleScript cannot express them. The
+generic messaging facade owns one composite confirmation and a per-part
+journal with a proven accepted prefix, at most one uncertain current part, and
+an unattempted suffix. Before each remaining bubble it rereads the exact chat
+and bounded history, accepting only the unchanged preview base, that same base
+while an accepted bubble is not yet visible, or the exact visible own-message
+prefix with bounded-window eviction. Foreign activity, edits, deletions,
+reordering, or identity reuse stops the suffix. The provider hook
+`executeImsgDirectMessagingPart` rejects non-send recipes and delegates every
+bubble to the same supervised at-most-once operation boundary.

package/docs/rental-listings.md

@@ -0,0 +1,94 @@
+# Rental listings
+
+Ghostget exposes public Puerto Rico rental search as one named operation,
+`listings.search`, on the built-in `clasificados-web` plugin.
+
+The operation is read-only. It takes a location plus optional bedroom and rent
+bounds, fetches the reviewed ClasificadosOnline list pages, and returns
+structured rows. Each row includes the canonical listing URL, rent, beds, baths,
+street address when the list card publishes one, ZIP when a reviewed ZIP table
+or known-address override can prove it, and a neighborhood derived from that
+address and ZIP or from the listing's own coordinates. Broker titles and
+`BarrioCond` blurbs are never the neighborhood source.
+
+## Input
+
+Required key:
+
+- `location` — a reviewed San Juan location token such as `San Juan, PR`,
+  `Hato Rey`, `Condado`, `Santurce`, `Río Piedras`, or `Viejo San Juan`.
+
+Optional keys:
+
+- `beds_min` — keep listings with at least this many bedrooms. ClasificadosOnline
+  treats its own bedroom field as an exact match, so Ghostget omits that field
+  from the query and applies the bound locally.
+- `max_price` — keep listings at or below this monthly rent.
+
+Unknown keys, extra fields, and locations outside the reviewed San Juan pueblo
+set are rejected.
+
+## Neighborhood verification
+
+Listing text often lies. A Hato Rey tower can advertise Condado. Ghostget resolves
+neighborhood in this order:
+
+1. A reviewed street-plus-ZIP override for a known building.
+2. A reviewed San Juan ZIP when the listing or override publishes one.
+3. Coordinates published on the same list card as the listing.
+
+Reviewed ZIP examples:
+
+- `00918` — Hato Rey
+- `00907` — Condado / Miramar
+- `00901` — Old San Juan / Puerta de Tierra / Paseo Caribe
+
+Coordinates on ClasificadosOnline detail pages include related listings. The
+runtime therefore binds latitude and longitude from the list card only.
+
+## Completeness
+
+San Juan is five ClasificadosOnline pueblos, not one island-wide search.
+`location=San Juan, PR` walks those five reviewed list pages. The pueblo query
+uses the page's latin-1 form encoding, so `Río Piedras` is `R%EDo`, not UTF-8.
+Completeness is `partial` when any page is full, when a card is skipped because
+it is not a San Juan listing, or when a card is missing a reviewed field.
+Completeness is `complete` only when every requested pueblo page is a short,
+fully projected page. Bath counts keep a reviewed half-step (`2 1/2` is `2.5`).
+Studios that omit the bedroom icon and name themselves estudio, efficiency, or
+studio project as zero bedrooms.
+
+## Live probe
+
+A live ClasificadosOnline probe on 2026-09-03 for San Juan two-bedroom rentals
+at or below $5500 returned 43 structured rows with canonical detail URLs,
+including Hato Rey, Condado / Miramar, Santurce, Río Piedras, and Old San Juan
+neighborhoods derived from coordinates or known-address overrides. First-page
+pueblo results were full, so completeness was `partial`. Aquablue at 48 Luis
+Muñoz Rivera is covered by the recorded fixture: the override binds Hato Rey
+`00918` even when the title says Condado. Replay the live probe with:
+
+```bash
+ghostget clasificados-web listings.search \
+  --input '{"location":"San Juan, PR","beds_min":2,"max_price":5500}' \
+  --json
+```
+
+The command is a live network probe. Tests cover the same input against recorded
+list-card fixtures so CI does not depend on the site.
+
+## Surfaces that are not shipped
+
+Zillow-group HTML and first-party search endpoints from this environment
+returned PerimeterX or equivalent bot challenges on zillow.com, hotpads.com,
+trulia.com, apartments.com, and homes.com. No reviewed public search contract
+exists for those hosts, so Ghostget does not ship a Zillow-group `listings.search`
+and does not ship a DOM-click recipe.
+
+Puerto Rico MLS public search is also not shipped. londonfoster.com's search
+index is Florida inventory. puertoricorealtorsmls.com answered with a disk-full
+error. stellarmls.com is a Florida member marketing site. Individual Puerto Rico
+detail pages are not a reviewed search index.
+
+Those blockers stay documented until a first-party public contract can be
+reviewed. They are not capture-required stubs and they are not portable plugins.