@rubytech/create-maxy-code 0.1.70 → 0.1.72

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rubytech/create-maxy-code",
-  "version": "0.1.70",
+  "version": "0.1.72",
   "description": "Install Maxy — AI for Productive People",
   "bin": {
     "create-maxy-code": "./dist/index.js"

package/payload/platform/plugins/admin/hooks/__tests__/turn-completed-graph-write.test.sh

@@ -232,6 +232,7 @@ RECORDER_BODY=$(grep -E '^/api/admin/claude-sessions	' "$REQ_LOG" | head -1 | cu
 BODY_OK=$(printf '%s' "$RECORDER_BODY" | python3 -c '
 import sys, json
 op = sys.argv[1]
+acct = sys.argv[2]
 try:
   outer = json.load(sys.stdin)
   msg = outer.get("initialMessage")
@@ -245,8 +246,14 @@ try:
                 msg.rstrip().endswith("do not emit it.")))
   conds.append(("no-placeholder-schema", "{schema}" not in msg))
   conds.append(("no-placeholder-conversation", "{conversation}" not in msg))
+  conds.append(("no-placeholder-accountid", "{accountId}" not in msg))
   # schema-base.md content is interpolated.
   conds.append(("contains-schema-base-header", "Schema Reference" in msg))
+  # Task 199 — accountId clarifier sentence + literal value rendered.
+  conds.append(("has-accountid-clarifier",
+                "accountId" in msg and "automatically supplied" in msg))
+  conds.append(("has-accountid-value",
+                "The current accountId is `" + acct + "`." in msg))
   # The conversation lines appear in role: text format.
   conds.append(("has-user-1", "\nuser: New Real Agent session" in msg))
   conds.append(("has-asst-1",
@@ -266,20 +273,22 @@ try:
   print("yes" if not failed else "no:"+repr(failed))
 except Exception as e:
   print("parse-fail:"+str(e))
-' "$OP_ID" 2>/dev/null)
+' "$OP_ID" "$ACCT_ID" 2>/dev/null)
 if [[ "$BODY_OK" == "yes" ]]; then
-  pass "case-5c initialMessage is the filled four-sentence paragraph; placeholders substituted; transcript rendered as role: text lines"
+  pass "case-5c initialMessage is the filled paragraph; schema/accountId/conversation placeholders substituted; accountId value rendered; transcript as role: text lines"
 else
   fail "case-5c filled-prompt shape wrong ($BODY_OK)"
 fi
 
-# 5h. (Task 195) exactly one `substitution` log-ingest line carrying
-#     positive byte counts for schema / conversation / body.
-SUBST_LINE_COUNT=$(ingest_lines | grep -cE "^substitution sessionId=${OP_ID} schemaBytes=[1-9][0-9]* conversationBytes=[1-9][0-9]* bodyBytes=[1-9][0-9]*$" || true)
+# 5h. (Task 195 + 199) exactly one `substitution` log-ingest line carrying
+#     positive byte counts for schema / conversation / body AND
+#     accountIdPresent=yes (the envelope's accountId is non-empty here —
+#     run_hook always passes ACCOUNT_ID="$ACCT_ID" into the hook env).
+SUBST_LINE_COUNT=$(ingest_lines | grep -cE "^substitution sessionId=${OP_ID} schemaBytes=[1-9][0-9]* conversationBytes=[1-9][0-9]* bodyBytes=[1-9][0-9]* accountIdPresent=yes$" || true)
 if [[ "$SUBST_LINE_COUNT" -eq 1 ]]; then
-  pass "case-5h substitution log line emitted once with positive byte counts"
+  pass "case-5h substitution log line emitted once with positive byte counts and accountIdPresent=yes"
 else
-  fail "case-5h expected exactly 1 substitution line w/ positive bytes, got $SUBST_LINE_COUNT (lines: $(ingest_lines))"
+  fail "case-5h expected exactly 1 substitution line w/ positive bytes + accountIdPresent=yes, got $SUBST_LINE_COUNT (lines: $(ingest_lines))"
 fi
 
 # 5i. (Task 195) substitution line lands between envelope and spawn-request.
@@ -605,6 +614,68 @@ else
   fail "case-10 escaping wrong ($ESC_OK): $ESC_BODY"
 fi
 
+# --- Case 11 (Task 199): missing accountId → accountIdPresent=no, no crash ---
+# When ACCOUNT_ID env is empty, the envelope's accountId field is "" and
+# the {accountId} placeholder collapses to an empty string. The hook does
+# NOT loud-fail (the agent's new clarifier sentence + the server-side
+# validator on the writers handle the bad signal). The substitution log
+# line emits accountIdPresent=no — the regression signature for upstream
+# envelope-shape drift.
+: > "$REQ_LOG"
+NO_ACCT_STDIN_FILE=$(mktemp); TMPFILES+=("$NO_ACCT_STDIN_FILE")
+printf '%s' "$ORDERED_ENVELOPE" > "$NO_ACCT_STDIN_FILE"
+NO_ACCT_STDERR=$(mktemp); TMPFILES+=("$NO_ACCT_STDERR")
+NO_ACCT_STDOUT=$(mktemp); TMPFILES+=("$NO_ACCT_STDOUT")
+MAXY_SESSION_ROLE="admin" \
+  MAXY_SPECIALIST="" \
+  MAXY_UI_INTERNAL_PORT="$LISTENER_PORT" \
+  ACCOUNT_ID="" \
+  bash "$HOOK" <"$NO_ACCT_STDIN_FILE" >"$NO_ACCT_STDOUT" 2>"$NO_ACCT_STDERR"
+NO_ACCT_RC=$?
+sleep 0.1
+[[ "$NO_ACCT_RC" -eq 0 ]] || fail "case-11 rc=$NO_ACCT_RC stderr=$(cat "$NO_ACCT_STDERR")"
+[[ -z "$(cat "$NO_ACCT_STDERR")" ]] || fail "case-11 stderr must be empty, got: $(cat "$NO_ACCT_STDERR")"
+
+# 11a. substitution log line carries accountIdPresent=no
+SUBST_NO_COUNT=$(ingest_lines | grep -cE "^substitution sessionId=${OP_ID} schemaBytes=[1-9][0-9]* conversationBytes=[1-9][0-9]* bodyBytes=[1-9][0-9]* accountIdPresent=no$" || true)
+if [[ "$SUBST_NO_COUNT" -eq 1 ]]; then
+  pass "case-11a empty ACCOUNT_ID → substitution log carries accountIdPresent=no"
+else
+  fail "case-11a expected 1 substitution line w/ accountIdPresent=no, got $SUBST_NO_COUNT (lines: $(ingest_lines))"
+fi
+
+# 11b. recorder spawn still fires — the hook does NOT loud-fail on absent
+#      accountId. The filled body still substitutes; the placeholder
+#      collapses to empty backticks.
+NO_ACCT_BODY=$(grep -E '^/api/admin/claude-sessions	' "$REQ_LOG" | head -1 | cut -f2-)
+NO_ACCT_OK=$(printf '%s' "$NO_ACCT_BODY" | python3 -c '
+import sys, json
+try:
+  outer = json.load(sys.stdin)
+  msg = outer.get("initialMessage")
+  if not isinstance(msg, str):
+    print("no:initialMessage-not-string")
+    sys.exit(0)
+  conds = []
+  conds.append(("starts-template", msg.startswith("You are an expert Neo4J graph operator.")))
+  conds.append(("no-placeholder-accountid", "{accountId}" not in msg))
+  # Placeholder collapses to empty backticks.
+  conds.append(("empty-accountid-rendered", "The current accountId is ``." in msg))
+  conds.append(("clarifier-still-present",
+                "never refuse a write because accountId" in msg))
+  # Transcript still rendered.
+  conds.append(("has-user-line", "\nuser: " in msg))
+  failed = [name for name, ok in conds if not ok]
+  print("yes" if not failed else "no:"+repr(failed))
+except Exception as e:
+  print("parse-fail:"+str(e))
+' 2>/dev/null)
+if [[ "$NO_ACCT_OK" == "yes" ]]; then
+  pass "case-11b empty ACCOUNT_ID → filled body still substitutes; {accountId} → empty backticks; clarifier sentence intact"
+else
+  fail "case-11b filled-body shape wrong on empty accountId ($NO_ACCT_OK): $NO_ACCT_BODY"
+fi
+
 # --- Summary ------------------------------------------------------------
 echo "---"
 echo "PASSED: $PASS  FAILED: $FAIL"

package/payload/platform/plugins/admin/hooks/turn-completed-graph-write.sh

@@ -366,6 +366,7 @@ if vertical_path:
 
 with open(envelope_path, "r", encoding="utf-8") as f:
     envelope = json.load(f)
+account_id = envelope.get("accountId", "") or ""
 turns = envelope.get("turns") or []
 lines = []
 for t in turns:
@@ -391,11 +392,17 @@ for t in turns:
 # the last one from the closing `, using the tools at your disposal.`
 conversation_text = "\n" + "\n".join(lines) + "\n"
 
-filled = body_template.replace("{schema}", schema_text).replace("{conversation}", conversation_text)
+filled = (
+    body_template
+    .replace("{schema}", schema_text)
+    .replace("{accountId}", account_id)
+    .replace("{conversation}", conversation_text)
+)
 
 schema_bytes = len(schema_text.encode("utf-8"))
 conv_bytes = len(conversation_text.encode("utf-8"))
 body_bytes = len(filled.encode("utf-8"))
+account_id_present = "yes" if account_id else "no"
 
 spawn_body = {
   "adminSessionId": sid,
@@ -405,7 +412,7 @@ spawn_body = {
   "initialMessage": filled,
 }
 
-print(f"{schema_bytes}\t{conv_bytes}\t{body_bytes}")
+print(f"{schema_bytes}\t{conv_bytes}\t{body_bytes}\t{account_id_present}")
 print(json.dumps(spawn_body))
 PY
 )
@@ -413,9 +420,9 @@ rm -f "$ENVELOPE_FILE"
 
 BYTES_LINE=$(printf '%s' "$COMBINED" | head -n1)
 SPAWN_BODY=$(printf '%s' "$COMBINED" | tail -n +2)
-IFS=$'\t' read -r SCHEMA_BYTES CONV_BYTES BODY_BYTES <<<"$BYTES_LINE"
+IFS=$'\t' read -r SCHEMA_BYTES CONV_BYTES BODY_BYTES ACCOUNT_ID_PRESENT <<<"$BYTES_LINE"
 
-emit_log "substitution sessionId=${ADMIN_SESSION_ID} schemaBytes=${SCHEMA_BYTES} conversationBytes=${CONV_BYTES} bodyBytes=${BODY_BYTES}"
+emit_log "substitution sessionId=${ADMIN_SESSION_ID} schemaBytes=${SCHEMA_BYTES} conversationBytes=${CONV_BYTES} bodyBytes=${BODY_BYTES} accountIdPresent=${ACCOUNT_ID_PRESENT}"
 emit_log "spawn-request sessionId=${ADMIN_SESSION_ID} specialist=database-operator initialMessageBytes=${BODY_BYTES}"
 
 SPAWN_RES_FILE=$(mktemp)

package/payload/platform/templates/specialists/agents/database-operator.md

@@ -2,11 +2,16 @@
 name: database-operator
 description: "Background recorder for the memory graph. Reads the operator's full conversation transcript (ordered turns array with text and tool calls) from stdin and writes whatever the most recent operator turn implies into the graph via the wrapped writers. Fires once per admin turn from a Stop hook; never reachable from the admin agent directly."
 summary: "Watches every completed admin turn and records what it implies into the memory graph."
-model: claude-haiku-4-5
+model: claude-sonnet-4-6
 tools: mcp__memory__memory-write, mcp__memory__memory-update, mcp__memory__memory-search, mcp__memory__profile-update, mcp__memory__profile-read, mcp__contacts__contact-create, mcp__contacts__contact-update, mcp__tasks__task-create, mcp__tasks__task-update, mcp__tasks__project-create, mcp__tasks__project-update
 ---
 
 You are an expert Neo4J graph operator. Here is the schema {schema}.
+
+The `accountId` property is automatically supplied by the writers from
+server-side environment state — never refuse a write because accountId
+is absent from this prompt. The current accountId is `{accountId}`.
+
 Use your expert judgement to update the graph in reaction to the
 following conversation {conversation}, using the tools at your disposal.
 You are not user-facing and your text goes nowhere — do not emit it.

package/payload/premium-plugins/real-agent/plugins/brochures/skills/property-brochure/SKILL.md

@@ -86,12 +86,12 @@ A `[SKIP]` answer is a **valid** answer for the gate. An empty answer is still a
 
 If the operator's request contains "and socials", "+socials", "with socials", "with OG images", or any equivalent, append a socials step after the brochure web bundle is built:
 
-1. Invoke the `property-socials` skill on the same `<property_dir>` (it reads `output/web/page.html` or `output/web/index.html`, `property.json`, and the brand pack).
-2. The OG JPGs (landscape 1200x630, square 1080x1080, portrait 1080x1350) land under `output/web/socials/`.
-3. This skill **additionally** produces a small gallery page at `output/web/socials.html`: the third endpoint in the web bundle, alongside the brochure HTML and the landing page, previewing each tile size with download links and the suggested copy / alt text for each platform. Brand it from the same DESIGN.md tokens used for the brochure.
-4. The bundle's smoke-test extends to `socials.html` and every JPG referenced; all must return 200 from the isolated HTTP server.
+1. Invoke the `property-socials` skill on the same `<property_dir>` (it reads `output/web/index.html`, `property.json`, and the brand pack).
+2. `property-socials` owns the full deliverable: OG JPGs in `output/web/socials/` (landscape 1200×628, square 1200×1200, portrait 1080×1350), the gallery page at `output/web/socials.html`, captions at `output/web/social-posts.md`, and the `og.html` template kept for re-runs. The orchestrator does **not** produce a separate gallery — everything lands when the skill returns, so a direct standalone invocation produces an identical bundle to the orchestrator-invoked one.
+3. After the skill returns, extend the bundle's smoke-test to include `socials.html` and every JPG referenced; all must return 200 from the isolated HTTP server.
+4. Re-zip the web bundle with the socials artefacts included.
 
-The web bundle is then re-zipped with the socials artefacts included. If the operator did **not** request socials, do not run the step; adding 1 to 3 MB of imagery and a third HTML page silently is an over-reach.
+If the operator did **not** request socials, do not run the step; adding 1 to 3 MB of imagery and a third HTML page silently is an over-reach.
 
 ## Step 4 — populate, render, deliver
 
@@ -151,6 +151,8 @@ The recurring failure pattern is trusting a derived summary (a WebFetch markdown
 
 When any field above is unresolved after consulting its primary source, **stop before substitution** and present the operator with one consolidated prompt listing every unknown by name, the primary source already consulted, and the candidate value (if any). Operator answers in one pass; substitution then proceeds from confirmed values. **Never render a brochure with fields silently coerced to `TBC`, an approximation, or a default. A `TBC` shipped to a buyer must have been confirmed as a `TBC` by the operator, not chosen by the agent.**
 
+**EPC is in a stricter tier — `TBC` is not a confirmable outcome.** UK law requires an EPC for any marketed property, so the brochure cannot ship with `epc_rating: "TBC"` even with operator confirmation. If `property-extract` returned `TBC` (the listing displays it that way, or the page lacks the data), the operator confirmation prompt for the EPC slot must demand an actual A–G band plus the current/potential scores and a path to the certificate PDF/image. The operator's path of last resort is the [EPC Register](https://www.epcregister.com/) — look up by address or postcode, download the certificate, and supply the band + scores back to the brochure step. Confirming `TBC` for `epc_rating` is the one answer the prompt must refuse to accept; the brochure halts until a real rating arrives.
+
 ## Hard rules (load-bearing — do not violate)
 
 - **Never `Read` an image whose longest edge exceeds 2000px** — it can drop the session. Measure with `sips -g pixelWidth -g pixelHeight <file>` first.
@@ -164,6 +166,14 @@ When any field above is unresolved after consulting its primary source, **stop b
 - **Suppress screen-only chrome before snapshotting** — the template's `.download-bar` is hidden under `@media print` but Playwright's `element.screenshot()` captures the screen render, where the bar IS visible. The render script in `build.md` injects a style tag (`.download-bar { display: none !important; }`) before capture. Any custom render script must do the same.
 - **Brand-token overrides MUST land at the `BRAND_TOKENS_OVERRIDE_SLOT` sentinel** — immediately before the closing `}` of the template's `:root` rule. Any earlier insertion site loses the CSS cascade: the template's own `--paper-25 / --serif / --gold-700` declarations win in source order, and the brochure renders in Premium register despite `register=branded`. The substitution gate and snapshot capture both pass — failure is silent until visual review.
 - **Display-headline wrap contract on `{{ property_name }}`** — `.back-headline em`, `.cover-title`, and `.opener-title em` carry `white-space: nowrap` so multi-word property names sit on one line regardless of brand display family. Removing the nowrap rule reintroduces non-deterministic wrap (same name renders correctly in Premium and breaks in Branded when the display family changes). For a property name long enough to overflow at the column width, shrink the headline `font-size` or shorten the name — never delete the nowrap rule.
+- **Web bundle must contain only referenced images.** Before the zip step, walk `output/web/images/` and remove every file not appearing in any of the bundle's HTML surfaces (`brochure.html`, the companion landing page, optional `og.html`). A bundle carrying unreferenced images is a build defect; the 30–50 MB target documented in `build.md → Web bundle` is enforced, not aspirational. See `build.md → Strip unreferenced images` for the recipe.
+- **Web PDF defaults to JPEG-embedded at quality 85.** Snapshot PNGs in `output/.snapshots-web/` are re-encoded to JPEG q=85 before `img2pdf` binds them. PNG-embedded for the web grade is opt-in only (one-pagers / report-style where small-text crispness outweighs wire size). The print master never flips to JPEG — its audience archives for press runs. A web PDF over ~20 MB on a 16-page folio means the re-encode was skipped.
+- **Companion landing page is named `index.html`.** Every reference (template, bundle, smoke-test, docs) uses `index.html` so the static host serves it as the default document without an explicit URL. Do not drift back to `page.html` — that name was deprecated in favour of hosting-platform default-document compatibility.
+- **Floorplan ships as PNG on disk.** The brochure templates reference `images/<slug>-floorplan.png` and the contract is PNG-only on disk regardless of source format. If the operator-supplied source is JPG, convert at build time (`magick <src>.jpg <slug>-floorplan.png`) before substitution. JPEG compression artefacts on thin lines and small text are unacceptable for floorplans.
+- **Brand-token override block must carry both vocabularies and target both templates.** The brochure (`template.html`) and the landing page (`index.html`) declare independent `:root` token vocabularies (`--paper-25 / --gold-700 / …` vs `--paper / --gold / …`). The brand-tokens block must emit **both** sets of token names with the same brand values and substitute at the `BRAND_TOKENS_OVERRIDE_SLOT` sentinel in **both** templates. A block that only carries the brochure's vocabulary leaves the landing page rendering Premium silently — the substitution gate passes and the snapshot capture proceeds. See `references/build.md → Brand-token override emission` for the mapping table and example block. Long-term vocabulary unification is a follow-up; until it lands the dual emission is structurally required.
+- **Doc-comment strip pass runs against BOTH templates.** After substitution, the `<!-- REPLACE … -->` authoring notes must be removed from both `brochure.html` AND `index.html`. A strip pass that covers only the brochure leaves landing-page authoring notes rendering as visible body text whenever a comment delimiter is misplaced. The companion source-side check in `references/build.md → Template authoring hygiene + CI lint` catches the same defect class at template-edit time.
+- **EPC is mandatory — `TBC` is not shippable.** UK law requires an EPC for any marketed property. The brochure must not render with `epc_rating: "TBC"`, no matter what `property-extract` returned. If the rating is missing or the listing displayed `TBC`, the operator confirmation prompt must demand an actual A–G band (plus current/potential scores and the certificate path) before substitution proceeds. The operator's authoritative fallback is the [EPC Register](https://www.epcregister.com/) — look up by address or postcode, download the certificate, supply the values. `TBC` is the one answer the operator cannot confirm for this field.
+- **Web bundle ships the PDF, not per-page JPGs.** The bundle does not include `cover-print.jpg … backpage-print.jpg` — those duplicate the brochure content already embedded in `<slug>-brochure.pdf`. The web copy of `brochure.html` has its `.print-img` src attributes cleared so the print stylesheet drops to the live-DOM fallback; operators who want a printable PDF download the bundled PDF directly. See `references/build.md → Clear .print-img src in the web copy`. Shipping both was the historical bundle-bloat defect.
 - **No `{{ token }}` may remain in rendered output** — `grep '{{' output/brochure.html` must return zero matches before PDFs are built.
 
 ## Scope

package/payload/premium-plugins/real-agent/plugins/brochures/skills/property-brochure/references/build.md

@@ -4,7 +4,8 @@
 
 1. Copy template to property directory, populate with content
 2. Stage `output/images/` per `images.md → Image renaming and optimisation`
-3. **If branded register and `<brand_dir>/DESIGN.md` contains a `## Type roles` block** — emit the role overlay into both `brochure.html` and `page.html`/`index.html` per **Type-role overlay generation** below. Run this **before** any snapshot capture; the overlay is part of what the user reviews in the browser, not a post-process applied to PDFs.
+3. **If branded register and `<brand_dir>/DESIGN.md` contains a `## Type roles` block** — emit the role overlay into both `brochure.html` and `index.html` per **Type-role overlay generation** below. Run this **before** any snapshot capture; the overlay is part of what the user reviews in the browser, not a post-process applied to PDFs.
+3b. **Doc-comment strip — run against BOTH templates.** After substitution and overlay emission, run a regex pass that removes template authoring notes (the `<!-- REPLACE … -->` markers and any demo-placeholder blocks inside comments) from both `brochure.html` and `index.html`. The single regex is `re.compile(r"<!--\s*REPLACE\s+.*?-->", re.DOTALL)`. Run it explicitly against **both** files — a strip pass that covers only the brochure leaves landing-page authoring notes rendering as visible body text whenever a comment delimiter is misplaced (the historical `page.html` template shipped this defect once already). See **Template authoring hygiene + CI lint** below for the source-side check that catches the same class of defect at template-edit time, before a property build is ever started.
 4. Serve locally: `python3 -m http.server <port>` from the project root
 5. Navigate Playwright to the brochure URL
 6. Present to user in browser for review
@@ -107,7 +108,7 @@ Both are image-only — no fonts embedded, no Ghostscript anywhere in the chain.
 
 ### Build steps
 
-For each grade, bind the per-page PNG snapshots into a PDF via img2pdf, then linearize via qpdf:
+Build both grades from the per-page snapshots in `output/` and `output/.snapshots-web/`, then linearize via qpdf. The print master embeds the PNG snapshots verbatim; the web grade re-encodes them as JPEG quality 85 before binding, so the deliverable that goes out to email and CDN hosting is materially smaller:
 
 ```bash
 # Print master from 300 dpi PNGs (in output/)
@@ -124,13 +125,17 @@ qpdf --linearize --object-streams=disable \
      /tmp/pre-linearize.pdf \
      <property_slug>-brochure-print.pdf
 
-# Web PDF from 192 dpi PNGs (in output/.snapshots-web/)
+# Web PDF from 192 dpi PNGs → JPEG q=85 (in output/.snapshots-web/)
+# img2pdf preserves JPEG bytes verbatim, so re-encoding once up front is the only quality step.
 cd <property_dir>/output/.snapshots-web/
+for png in *-print.png; do
+  magick "$png" -quality 85 -strip -interlace none -colorspace sRGB "${png%.png}.jpg"
+done
 img2pdf --pagesize 297mmx210mm \
         --title "<Property Name> · <address line 1>" \
         --author "<Agent Name>" \
         --output /tmp/pre-linearize.pdf \
-        cover-print.png page2-print.png … backpage-print.png
+        cover-print.jpg page2-print.jpg … backpage-print.jpg
 qpdf --linearize --object-streams=disable \
      /tmp/pre-linearize.pdf \
      <property_dir>/output/<property_slug>-brochure-web.pdf
@@ -149,9 +154,9 @@ pdfinfo  <output>.pdf | grep Optimized   # → "Optimized: yes"
 pdffonts <output>.pdf | wc -l            # → 2 (header rows only; no font entries)
 ```
 
-A typical 16-page folio ships with the print master at **65–100 MB** and the web PDF at **25–45 MB**. If the print master lands under ~40 MB, the snapshot DPR is wrong (likely rendered at 2× instead of 3.125×). If the web PDF exceeds ~55 MB, source photos may be over-floor (see **Image resolution floor** in a4-print-documents) or the snapshot DPR drifted to 3.125× by accident.
+A typical 16-page folio ships with the print master at **65–100 MB** (PNG-embedded) and the web PDF at **7–15 MB** (JPEG-embedded at q=85). If the print master lands under ~40 MB, the snapshot DPR is wrong (likely rendered at 2× instead of 3.125×). If the web PDF exceeds ~20 MB, the JPEG re-encode was skipped (bind step ran against `.png` instead of `.jpg`) or the snapshot DPR drifted to 3.125× by accident.
 
-If the web PDF runs into a transport limit (some webmail systems cap at 25 MB), substitute JPEG-encoded snapshots: `magick page-print.png -quality 88 -strip -interlace none -colorspace sRGB page-print.jpg`, then bind `.jpg` files instead of `.png`. Expect 30–40% size reduction with no visible quality loss at 192 dpi.
+The web PDF defaults to JPEG-embedded; PNG-embedded for the web grade is **opt-in only**, for one-pagers or report-style brochures where small-text crispness matters more than wire size. For the standard photographic property folio, JPEG q=85 is visually indistinguishable from PNG at typical screen DPRs and is roughly 3–5× smaller. The print master never flips to JPEG — its audience archives for press runs.
 
 ### When to (re)generate
 
@@ -165,9 +170,8 @@ The web bundle is a parallel directory with the same on-disk shape as `output/`
 
 ```
 output/web/
-  brochure.html                      # identical content; only print-img references switched .png → .jpg
+  brochure.html                      # identical content; .print-img src attributes cleared (see below)
   index.html                          # companion landing page (mandatory in bundle)
-  cover-print.jpg, page2-print.jpg … backpage-print.jpg   # 96 dpi JPEG snapshots (q=88)
   <slug>-brochure.pdf                # identical bytes to <slug>-brochure-web.pdf at the property level — simpler name inside the bundle since there's only one PDF here
   images/
     <slug>-NN.webp                   # web-tier per-slot encodings (see table below)
@@ -175,6 +179,8 @@ output/web/
     <brand>-logo-light.png
 ```
 
+The bundle deliberately does **not** include the per-page JPG snapshots (`cover-print.jpg` etc). They duplicate the brochure content already embedded in `<slug>-brochure.pdf` at smaller cost-to-quality. Operators who want printed output download the PDF from the bundle; operators who view `brochure.html` in a browser and hit Cmd+P get the live-DOM print path (see `Print snapshot capture → Live-DOM fallback`). Shipping both was the historical defect that pushed a 16-page folio bundle past 50 MB.
+
 ### Web-tier image encoding
 
 The same per-slot tier idea as the digital floor in `images.md`, but with smaller widths and slightly lower quality — sized for screen viewing at 100% zoom, not for print sharpness.
@@ -184,41 +190,34 @@ The same per-slot tier idea as the digital floor in `images.md`, but with smalle
 | Hero / cover / banner / feature / drone aerial / front elevation / outdoor full-bleed | **1300 px @ q82** | 80–300 KB |
 | Story photo (in-spread half-page) | **1100 px @ q80** | 60–250 KB |
 | Gallery thumb / strip / image-led grid cell | **800 px @ q76** | 25–80 KB |
-| **Floor plan** (PNG, line art) | **source file copied unchanged** — `cp <slug>-floorplan.png web/images/` | matches source (often 500 KB – 1 MB) |
+| **Floor plan** (PNG output, line art) | **PNG source copied unchanged; JPG source converted to PNG at build time** — `magick <slug>-floorplan.jpg <slug>-floorplan.png` then drop the `.jpg`. The brochure templates reference `images/<slug>-floorplan.png` and the contract is PNG-only on disk; JPEG compression artefacts on thin lines and small text are unacceptable for floorplans. | matches PNG output (often 500 KB – 1 MB) |
 | Site plan (raster line art) | **1100 px @ q80** WebP if not already PNG; if PNG, copy unchanged | 30–60 KB or source size |
 
 A 27-image folio typically lands at **~2.5 MB** of web photographs, with the floor plan adding **0.5–1.0 MB** on top because line art is preserved at source resolution. Total web image weight is typically 3.0–3.5 MB.
 
 **Floor-plan rule, repeated for emphasis.** Line-art PNG floor plans are **never re-encoded** for the web bundle — copy the source file as-is. Browsers render PNG line art crisply at any zoom level; converting to WebP introduces visible artefacts on text and rules even at q90+. The bundle gains a few hundred KB but the trade-off is on the right side.
 
-### Print snapshots — JPEG at 96 dpi for the web bundle
+### Clear `.print-img` src in the web copy
 
-The canonical snapshots in `output/` are 300 dpi PNG (~4–7 MB each, ~65 MB total) — far too heavy for the web bundle's `.print-img` swap layer. For the web bundle, derive 96 dpi JPEG copies directly from the canonical 300 dpi PNGs (no PDF round-trip):
-
-```bash
-cd output/web
-for png in ../*-print.png; do
-  base=$(basename "$png" .png)
-  magick "$png" -resize 1123x794^ -quality 88 -strip -interlace none -colorspace sRGB "$base.jpg"
-done
-```
-
-`-resize 1123x794^` downsamples to A4-landscape at 96 dpi (use `794x1123^` for portrait). `-strip` removes embedded metadata (EXIF, ICC) so the bundle stays minimal. `-interlace none` produces baseline JPEG which decodes faster in mobile previewers than progressive.
-
-JPEG at 88% quality is roughly 5× smaller than the PNG equivalent for photographic content. A 16-page folio's web-bundle snapshots total ~3 MB. The brochure HTML's `print-img` references must be updated from `.png` to `.jpg` on the web copy:
+The canonical `output/brochure.html` carries `<img class="print-img" src="cover-print.png">` references that power the snapshot path in the print stylesheet (Cmd+P → embedded PNG fills the page). The web bundle does **not** include those PNGs — and does not derive smaller JPEG copies either, because the PDF embedded in the bundle already covers the "I want a printable artefact" need. Instead, the web copy of `brochure.html` has its `.print-img` src attributes cleared so the print stylesheet drops to the live-DOM fallback path:
 
 ```python
-# Edit the web copy of brochure.html only — leave the canonical output/brochure.html unchanged
+# Edit the web copy of brochure.html only — leave the canonical output/brochure.html unchanged.
 import re
 with open("output/web/brochure.html") as f:
     s = f.read()
-s = re.sub(r'(cover-print|page\d+-print|backpage-print)\.png',
-           lambda m: m.group(1) + '.jpg', s)
+# Clear every .print-img src — the print stylesheet's :has(.print-img[src]:not([src=""]))
+# selector then fails, and the @media print live-DOM path renders the page directly.
+s = re.sub(
+    r'(<img\s+class="print-img"[^>]*?\s+)src="[^"]*"',
+    r'\1src=""',
+    s,
+)
 with open("output/web/brochure.html", "w") as f:
     f.write(s)
 ```
 
-A 16-page folio's web-bundle snapshots total ~3 MB (vs ~85 MB for the canonical print PNGs), with no perceptual difference at typical Cmd+P quality.
+The `.print-img` element on screen is `opacity: 0; width: 1px; height: 1px` regardless of `src`, so clearing the attribute has zero visible effect — only the print stylesheet branches differently. Operators who want a printable PDF download `<slug>-brochure.pdf` directly from the bundle.
 
 ### Copy the web PDF into the bundle
 
@@ -228,6 +227,34 @@ The web PDF (`<slug>-brochure-web.pdf` at the property level) is also placed ins
 cp output/<slug>-brochure-web.pdf output/web/<slug>-brochure.pdf
 ```
 
+### Strip unreferenced images
+
+Every image in `output/web/images/` must be reachable from at least one HTML surface in the bundle (`brochure.html`, the companion landing page, and `og.html` if present). The build accumulates working images during editing — operator drops a hero, re-numbers a sequence, swaps an image and forgets to delete the prior version — and without the strip step the bundle ships every accumulated file. Typical bloat on a re-iterated 16-page folio is 20–40 unreferenced `.webp` files at ~500 KB each, which is what pushes a "30–50 MB target" bundle to 80–120 MB.
+
+```bash
+cd output/web
+
+# Collect every image actually referenced by the bundle's HTML surfaces.
+# `cat *.html` catches brochure.html, the companion landing page, and og.html
+# without needing to know the landing-page filename in advance.
+referenced=$(cat *.html 2>/dev/null \
+  | grep -oE 'images/[A-Za-z0-9_.-]+\.(webp|jpg|jpeg|png|svg)' \
+  | sort -u)
+
+# Walk images/ and remove anything not in $referenced. Brand assets
+# (logos, QR PNGs) are referenced by the templates and survive.
+removed=0
+for f in images/*; do
+  if ! echo "$referenced" | grep -qxF "$f"; then
+    rm -f "$f"
+    removed=$((removed + 1))
+  fi
+done
+echo "[strip] removed $removed unreferenced files from output/web/images/"
+```
+
+The strip is a closed-set operation: two agents producing the bundle for the same property emit byte-identical surviving image sets. Run it before the zip step; a bundle carrying unreferenced images is a build defect, not "extra-safe" packaging.
+
 ### Bundling
 
 After populating `output/web/`, zip it with `-X` (strip extra attributes) and exclude any `.DS_Store` / AppleDouble files:
@@ -247,7 +274,7 @@ Serve the unzipped bundle from an isolated temp directory and verify every refer
 TMP=/tmp/web-test && rm -rf $TMP && mkdir -p $TMP
 cd $TMP && unzip -q /path/to/<slug>-web.zip
 python3 -m http.server 8765 &
-for f in brochure.html index.html cover-print.jpg images/<slug>-01.webp images/<brand>-logo-light.png <slug>-brochure.pdf; do
+for f in brochure.html index.html images/<slug>-01.webp images/<brand>-logo-light.png <slug>-brochure.pdf; do
   echo "$(curl -s -o /dev/null -w '%{http_code}' http://127.0.0.1:8765/$f) $f"
 done
 ```
@@ -258,19 +285,129 @@ The brochure should render the same as the canonical preview, just lighter on th
 
 | File | `output/` (canonical archive) | `output/web/` (web bundle) |
 |---|---|---|
-| `brochure.html` | full-resolution images, `.png` snapshot refs | identical structure, `.jpg` snapshot refs, smaller image refs |
+| `brochure.html` | full-resolution images, `.png` snapshot refs | identical structure, `.print-img` srcs cleared (live-DOM print fallback) |
 | `index.html` | — | ✓ companion landing page; see `index-landing.md` |
 | `<slug>-brochure-print.pdf` | ✓ canonical print master (50–80 MB, 300 dpi) | — (too large to bundle) |
-| `<slug>-brochure-web.pdf` | ✓ web/digital deliverable (20–35 MB, 192 dpi) | — copied into bundle as `<slug>-brochure.pdf` |
+| `<slug>-brochure-web.pdf` | ✓ web/digital deliverable (7–15 MB, 192 dpi JPEG-embedded) | — copied into bundle as `<slug>-brochure.pdf` |
 | `<slug>-brochure.pdf` | — | ✓ identical bytes to `-web.pdf`; matches index.html / brochure.html link |
-| `cover-print.png … backpage-print.png` | ✓ 300 dpi PNG (~4–7 MB each) — canonical snapshots | — replaced by 96 dpi `.jpg` versions |
-| `cover-print.jpg … backpage-print.jpg` | — | ✓ 96 dpi JPEG (~150 KB each, derived from the 300 dpi PNGs) |
+| `cover-print.png … backpage-print.png` | ✓ 300 dpi PNG (~4–7 MB each) — canonical snapshots | — bundle ships the PDF instead of per-page JPGs |
 | `images/<slug>-NN.webp` | full-quality per Render-slot table | web-tier per the web table above |
 | `images/qr-*.png`, `images/<brand>-logo-*.png` | ✓ | ✓ (copied unchanged — already small) |
 | `.snapshots-web/*-print.png` | ✓ intermediate (192 dpi PNGs used by the web-PDF build; deletable after) | — |
 
 The convention: `output/` is the canonical archive for the property's lifetime. `output/web/` is a derived bundle, regenerable any time from the canonical artefacts.
 
+## Brand-token override emission (cascade-safe, two-template, two-vocabulary)
+
+Branded register replaces palette and type tokens in `:root`. The override is emitted as a `<style id="brand-tokens">…</style>` block at the **`BRAND_TOKENS_OVERRIDE_SLOT`** sentinel in **both** the brochure template (`template.html`) and the companion landing page (`index.html`). The sentinel sits immediately before the closing `}` of each `:root` rule — placing the override after the template's own declarations is what keeps the brand values winning the cascade. See SKILL.md hard rule "Brand-token overrides MUST land at the BRAND_TOKENS_OVERRIDE_SLOT sentinel".
+
+### Two vocabularies (today)
+
+The brochure and the landing page use independent token vocabularies. Until vocabulary unification lands (see follow-up below), the brand-tokens block must include **both** sets of token names so that whichever template the block lands in, the right values bind.
+
+| Concept | `template.html` token | `index.html` token |
+|---|---|---|
+| Ivory page background | `--paper-25` | `--paper` |
+| Slightly darker cream surface | `--paper-50` | `--paper-2` |
+| Warm cream / banded surface | `--paper-100` | (no equivalent — omit) |
+| Pure white | `--paper-0` | (no equivalent — omit) |
+| Body ink | `--ink` | `--ink` (shared name) |
+| Secondary ink | (no equivalent — omit) | `--ink-2` |
+| Bronze accent | `--gold-700` | `--gold` |
+| Antique gold rule / softer accent | `--gold-500` | `--gold-soft` |
+| Champagne flourish | `--gold-300` | (no equivalent — omit) |
+| Display serif family | `--serif` | `--serif` (shared name) |
+| Body serif family | `--body-serif` | (no equivalent — omit) |
+| Sans family | `--sans` | (no equivalent — omit) |
+
+Pick one brand-pack value per concept, emit **both** token names in the same block. Example for a brand whose accent is brand-green `#02843E`:
+
+```html
+<style id="brand-tokens">
+:root {
+  /* template.html vocabulary */
+  --paper-25: #FFFFFF;
+  --paper-50: #F4F1EA;
+  --paper-100: #EFE7D8;
+  --gold-700: #02843E;
+  --gold-500: #4FB371;
+  --gold-300: #C9E8D4;
+  --ink: #323636;
+  --serif: 'Lora', 'Cormorant Garamond', serif;
+  --body-serif: 'Lora', serif;
+  --sans: 'Inter', sans-serif;
+
+  /* index.html vocabulary — same colour values, different token names */
+  --paper: #FFFFFF;
+  --paper-2: #F4F1EA;
+  --gold: #02843E;
+  --gold-soft: #4FB371;
+  --ink-2: #2A3036;
+}
+</style>
+```
+
+The same block is substituted at the sentinel in **both** templates. A block that only carries the `template.html` vocabulary leaves the landing page rendering Premium silently — the substitution gate passes and the snapshot capture proceeds. The defect is invisible until visual review.
+
+### Follow-up — vocabulary unification (long-term)
+
+The dual-emission above is a tactical fix for the divergence between the two templates' `:root` vocabularies. The long-term fix is to **unify the landing page on `template.html`'s tiered vocabulary** (`--paper-0 / -25 / -50 / -100`, `--gold-300 / -500 / -700`, `--ink` plus a `--ink-2` if needed) so every brand block is authored once instead of twice. Until that refactor lands, the dual-emission contract above is structurally required.
+
+## Template authoring hygiene + CI lint
+
+The doc-comment strip in step 3b of the workflow above catches template authoring notes **at property-build time** — but a template that ships with a misplaced `<!-- … -->` delimiter is a source-side defect that should be caught at template-edit time, before any property build runs against it. The historical `page.html` template carried a duplicated authoring note where one copy sat inside a proper comment and the other copy sat outside any delimiters; browsers rendered the duplicate as visible body text on every property built from that template.
+
+Add a CI step (or a `make check-templates` recipe at the plugin root) that parses every `references/*.html` and asserts:
+
+```python
+import re
+from pathlib import Path
+
+REFERENCES = Path("references")
+TEMPLATES = list(REFERENCES.glob("*.html"))           # template.html, index.html
+COMMENT_RE = re.compile(r"<!--.*?-->", re.DOTALL)
+
+LEAKED_PHRASES = [
+    "terminate this outer comment",
+    "REPLACE markers, use prose",
+    "delimiter pair",
+    "the bug that prompted this note",
+]
+
+defects = []
+
+for tpl in TEMPLATES:
+    text = tpl.read_text()
+
+    # 1. Every <!-- must be closed by --> within the file.
+    if text.count("<!--") != text.count("-->"):
+        defects.append(f"{tpl}: unbalanced HTML comment delimiters")
+
+    # 2. Strip every well-formed comment, then any LEAKED_PHRASES that
+    # remain are authoring notes sitting outside comments — body-text
+    # defects waiting to ship.
+    outside_comments = COMMENT_RE.sub("", text)
+    for phrase in LEAKED_PHRASES:
+        if phrase in outside_comments:
+            defects.append(f"{tpl}: authoring-note phrase {phrase!r} found outside any HTML comment")
+
+    # 3. `{{ token }}` placeholders are fine inside slot positions but
+    # an example placeholder appearing inside a code-block in body text
+    # (e.g. an explanation of how to use the template) is a leak.
+    # Surface as a soft warning — operator decides.
+    leftover_examples = re.findall(r"\{\{\s*example[_a-z]*\s*\}\}", outside_comments)
+    if leftover_examples:
+        defects.append(f"{tpl}: example placeholders leaked outside comments: {leftover_examples}")
+
+if defects:
+    print("Template lint failed:")
+    for d in defects:
+        print(f"  - {d}")
+    raise SystemExit(1)
+```
+
+Either check catches the page.html-class leak at edit time, before it ships to a property build. The lint runs against the source-side `references/*.html` only — the property-build copies under `<property_dir>/output/` are derived artefacts and are protected by step 3b above instead.
+
 ## Type-role overlay generation
 
 If the brand pack's `DESIGN.md` contains a `## Type roles` block (declared per `references/registers.md → Type-role overrides`), parse it and emit a single `<style id="brand-type-roles">…</style>` block at the `<!-- BRAND_TYPE_ROLES_OVERRIDE_SLOT -->` sentinel immediately before the closing `</style>` of the template's main stylesheet. The override CSS is generated **mechanically** from the recipe map below — the build does not invent selectors, it emits the documented ones using values from the DESIGN doc.

package/payload/premium-plugins/real-agent/plugins/brochures/skills/property-extract/SKILL.md

@@ -319,6 +319,7 @@ The skill orchestrates four capabilities, each a **what** not a **how**:
 2. **Extract.** Pull the raw HTML and grep all `b-cdn.net/propertyimages/...` and `b-cdn.net/floorplans/...` URLs. Deduplicate. Also grep PDF URLs containing `epc`. Extract the `<div class="section__description">` block for the description text. (Map detection is provider-agnostic and happens in step 4 below — don't try to parse map markup at this static-HTML stage.)
 3. **Stage.** Create the four-folder structure under `<output-dir>/<slug>-<listing-id>/`. Download images and floorplans in parallel (`xargs -n1 -P8 curl -O -L`) — there are routinely 40–60 images per listing and serial downloads are slow.
 4. **Capture map** (conditional, provider-agnostic). Drive Playwright to the listing URL and apply the heuristic detector under **Map — extract or omit**: try iframe-by-provider, then class/id-by-keyword, then static-map images, then visual fallback. On the first hit, scroll into view, wait for tiles, screenshot the **element** (not the page), convert to `map.webp` at ~1500 px wide. If no heuristic finds a map, skip — **extract or omit**, no fallback synthesis.
+4b. **Traverse tabbed UIs (conditional, provider-agnostic).** Modern listing pages from Loop CRM tenants, Rightmove, Zoopla and others render top-level data in tabs — *Details / Floorplan / EPC / Virtual Tour / Map View / Book Viewing* — and the static HTML returned by `WebFetch` or `curl` often does not include the inactive-tab content. If the probe in step 1 came back with data the listing visibly shows (EPC band, floorplan thumbnail, video URL) but the static-HTML extract in step 2 does not, the data is almost certainly tab-bound. Drive the Playwright session opened in step 4 (or open one if step 4 skipped) and walk the tab list: detect elements with `role="tablist"`, `role="tab"`, or class/id substrings `tab` containing the keywords `EPC`, `Floor plan`, `Map`, `Virtual tour`, `Brochure`. For each tab found, `page.click(<selector>)`, `page.waitForLoadState('networkidle')`, then harvest the panel content. For the EPC tab specifically: scrape the certificate PDF/PNG link and the displayed current/potential scores into `specifications.epc_rating`, `specifications.epc_current_score`, `specifications.epc_potential_score`. For other tabs: extract what each contract field needs and skip the rest. The traversal is principled — never hard-code a single agency's tab markup as the sole detector; the same listing surface ships with different tab implementations across CMS tenants.
 5. **Assemble.** Write `property.json` and `description.md`. Run a final consistency pass: image count in JSON matches files on disk, EPC rating in JSON matches the description.md line, agent contact in JSON matches the description.md header. `media.map` is populated iff a map screenshot landed on disk; `address.geo` is populated iff coordinates were parseable from a recognised URL pattern (and may legitimately be `null` even when `media.map` is set — see the schema notes).
 
 The skill does not prescribe which HTTP tool to use. `curl` is fine for the static HTML pages Muvin serves. If a future agent ships a JS-rendered listing page, switch to Chrome DevTools MCP or Playwright — the contract on the output is unchanged.
@@ -345,6 +346,7 @@ A delivered package that diverges substantially in shape from the reference is w
 | Saving `/tmp/muvin_property.html` or other working files inside the output directory | The directory is the deliverable. Working files get cleaned up. |
 | Hardcoding the tenant UUID | The UUID identifies the agency on Loop CRM. Different Muvin offices can have different tenant IDs. Extract it from the actual URLs on the page. |
 | Treating "EPC: TBC" as a missing field | "TBC" is information — the agent is telling you the assessment hasn't been done. Record it verbatim. |
+| Recording "EPC: TBC" when the listing's EPC tab actually shows a band but the static HTML did not | Modern listings tab-hide data behind a JS tab switcher; `WebFetch` / `curl` see only the active tab. If the listing visibly carries EPC content the static HTML lacks, drive Playwright per step 4b and harvest from the tab panel. "TBC" recorded from a missed-tab extract is a silent data-loss defect, not a faithful record. |
 | Synthesizing a map when the listing has none | The rule is **extract or omit**. Postcode-centroid renders, OSM static maps, and AI-generated map artwork are all forbidden. If the heuristic detector returns nothing, write `media.map: null` and move on. |
 | Hard-coding a single CMS's map markup (`section__property--map`, `<iframe src="google.com/maps">`) as the only detector | Each agent embeds maps differently — Loop CRM uses Google iframes, custom builds use Mapbox-GL canvases, others use static-map `<img>` tags. The detection order is heuristic and provider-agnostic by design. Hard-coding one breaks every other listing. |
 | Trying to render a map provider's tiles ourselves with our own API key | The screenshot approach captures whatever the agency already pays for, with their attribution. Spinning up our own Mapbox/Google account introduces a billing relationship the user didn't ask for, and risks brand-mismatch with what the agency publishes. Screenshot the element; don't reach for an API. |

package/payload/premium-plugins/real-agent/plugins/brochures/skills/property-socials/SKILL.md

@@ -27,23 +27,24 @@ shots — it does not re-design anything.
 
 ## Output contract
 
-Two deliverables every time: image files and the captions that go with them.
+This skill owns the **full** social-collateral deliverable. Whether invoked directly or through `make-brochure`'s `+socials` add-on, the same files land on disk — no orchestrator-side gallery emission, no split contract.
 
-**Image files** are written next to `page.html` so they share the same public
-URL prefix:
+```
+output/web/
+  socials/
+    og-landscape-<hero>.jpg     # 1200×628  Twitter / LinkedIn / Facebook / OG
+    og-square-<hero>.jpg        # 1200×1200 Instagram feed
+    og-portrait-<hero>.jpg      # 1080×1350 Instagram portrait, mobile
+  socials.html                  # gallery page — the third HTML endpoint in the bundle
+  social-posts.md               # paste-ready captions, also linked from socials.html
+  og.html                       # template that renders the tiles, kept for re-runs
+```
 
-| File | Dimensions | Use |
-|------|------------|-----|
-| `og-landscape-<hero>.jpg` | 1200×628  | Twitter / LinkedIn / Facebook / OG |
-| `og-square-<hero>.jpg`    | 1200×1200 | Instagram feed |
-| `og-portrait-<hero>.jpg`  | 1080×1350 | Instagram portrait, mobile |
+`<hero>` is `main`, `kitchen`, or `garden`. At minimum produce `og-landscape-main.jpg`; offer the full nine-variant set (landscape + square + portrait × main/kitchen/garden) when the user wants social collateral, not just a meta image.
 
-`<hero>` is `main`, `kitchen`, or `garden`. At minimum produce
-`og-landscape-main.jpg`; offer the full five-variant set (landscape + square +
-three portraits) when the user wants social collateral, not just a meta image.
+**Gallery page (`socials.html`)** sits at the root of the web bundle, alongside `brochure.html` and `index.html`. It previews each tile at its actual dimensions with download links, the suggested copy from `social-posts.md` inline next to each tile, and the platform's `<meta>` snippet ready to paste into a page `<head>`. Brand it from the same DESIGN.md tokens used for the brochure — same `:root` palette, same display family, same accent.
 
-**Captions** are written into `output/web/social-posts.md`, one section per
-image, ready to paste. Every caption is generated through the `plainly` skill's
+**Captions (`social-posts.md`)** are written one section per image, ready to paste. Every caption is generated through the `plainly` skill's
 register: no em-dashes, no inflation vocabulary (*discover*, *unlock*,
 *nestled*, *stunning*, *boasts*, *bespoke* where it isn't literally bespoke),
 no antithetical "it's not X, it's Y", no rhetorical openers (*Imagine…*,