@rubytech/create-sitedesk-code 0.1.511 → 0.1.513

package/payload/platform/plugins/admin/skills/deck-pages/SKILL.md

@@ -394,9 +394,9 @@ export default function DeckLayout({ children }: { children: React.ReactNode })
 
 The page component (`app/deck/page.tsx`) is a `"use client"` component containing the slides, the download function, and the download button. Keep the layout as a server component for metadata; the "use client" directive belongs on the page, not the layout.
 
-## Reference implementation
+## Reference arc
 
-A complete working deck lives at `/Users/neo/capacity-derivatives/app/deck/` — read `layout.tsx` and `page.tsx` there when building a new deck. The reference shows eight slides covering title, problem, market, solution, differentiation, roadmap, competitive landscape, and team/ask — the standard pitch-deck arc.
+A complete deck runs eight slides — title, problem, market, solution, differentiation, roadmap, competitive landscape, and team/ask. That is the standard pitch-deck arc; deviate only when the subject demands it.
 
 ## Checklist before shipping
 

package/payload/platform/plugins/admin/skills/skill-builder/SKILL.md

@@ -83,7 +83,7 @@ Show the user the complete SKILL.md content and each reference file. Ask them to
 
 Use `store-skill` to write the composed skill to disk as part of an admin-managed plugin. The tool computes the path internally — supply the names and content only.
 
-Pick a `pluginName` that groups related operator-authored skills (e.g. `beacons-skills`, `my-utils`). Reuse the same `pluginName` across calls so the skill joins existing operator skills under one plugin. If this is the first skill in a new plugin, the tool creates the `PLUGIN.md` automatically.
+Pick a `pluginName` that groups related operator-authored skills (e.g. `sales-skills`, `my-utils`). Reuse the same `pluginName` across calls so the skill joins existing operator skills under one plugin. If this is the first skill in a new plugin, the tool creates the `PLUGIN.md` automatically.
 
 ```
 store-skill({

package/payload/platform/plugins/admin/skills/whats-new/SKILL.md

@@ -9,6 +9,18 @@ Invoked by the admin agent directly.
 
 This is the platform's release timeline, newest first. Each entry shows the date it shipped and the version it shipped in, so you can tell the operator how current their install is. To compare, read the installed version from `capabilities-here` and match it against the versions below. Keep answers high level and in plain English; this is a summary, not a full commit log.
 
+## 2026-07-27 (0.1.513)
+
+- Fixed sign-in for sub-accounts: the browser session bridge now checks that you belong to the account you asked for, instead of only ever accepting the first one it found.
+- WhatsApp account checks now use the account's real identifier rather than a folder name, so conversations are attributed to the right account.
+- The saved session-title cache is now pruned as the sessions list is walked, so it no longer grows without limit.
+
+## 2026-07-27 (0.1.512)
+
+- Signed PDFs keep their clickable links and selectable text. The e-sign stamp no longer falls back to flattening each page into an image, which had been discarding every link in the document.
+- The sessions list is much faster: it no longer reads every account's transcripts in full just to build the list, and titles now come from a cache.
+- Fixed a dashboard error that repeated once a minute when you were switched to a sub-account, caused by asking for a conversations list only the main account is allowed to read.
+
 ## 2026-07-26 (0.1.511)
 
 - Fixed a dashboard bug where the Host CPU card could sit on a loading skeleton for a full minute after its figure had already arrived, even though the sidebar was showing the same number.

package/payload/platform/plugins/business-assistant/skills/e-sign/SKILL.md

@@ -477,47 +477,28 @@ Dispatch runs **only** inside a live operator session on the account's own devic
 
 2. **For each unswept row, in order — stamp, send, then mark that one row swept:**
 
-   - **Stamp a per-signer copy from the persisted base — no browser, no network.** Dispatch must **never fetch the deployed page**: it may sit behind **Cloudflare Access**, so a headless fetch hits the Access login screen, not the document, and the PDF is garbage. The render-once base (§ 5) is what removes that dependency. Load `${ACCOUNT_DIR}/e-sign/<DOC_REF>/base.pdf`, append an **Electronic Acceptance Certificate** page, and write a per-signer copy alongside it, all with a PDF library that loads the base and copies its pages through intact (**`pdf-lib`**, run as a small Node script). The stamp copies existing pages; it never renders them to an image. Rasterising the base (ghostscript to PNG, or any image-then-redraw rebuild) discards every link annotation and all selectable text, so the signer receives a flattened copy with dead links; it is prohibited whatever is or is not installed. A substitute for pdf-lib is allowed only if it imports existing PDF pages: pypdf, qpdf, or pdftk. A canvas-only generator such as reportlab cannot import a base and is not a substitute. Whatever the library, it adds no browser and no network call.
-
-     **Pre-flight: the page-copying library must resolve before any stamp runs.** A stamp attempted without it is the exact history this guards against, where a prior session met the missing library by rasterising instead of installing one:
+   - **Stamp a per-signer copy from the persisted base with the platform's stamp script.** Dispatch must **never fetch the deployed page**: it may sit behind **Cloudflare Access**, so a headless fetch hits the Access login screen, not the document, and the PDF is garbage. The render-once base (§ 5) is what removes that dependency. The stamp is platform code, not something to compose at dispatch time:
 
      ```bash
-     node -e 'import("pdf-lib").then(()=>console.log("ok"),e=>{console.error("pdf-lib missing: npm i pdf-lib at the account directory root");process.exit(1)})'
+     DIR="${ACCOUNT_DIR}/e-sign/<DOC_REF>" \
+     CERT='{"name":"…","title":"…","token":"…","doc_ref":"…","accepted_at":"…","method":"…","assertion":"…"}' \
+     node "$PLATFORM_ROOT/plugins/business-assistant/skills/e-sign/stamp.mjs"
      ```
 
-     On failure the one remediation is that install; a fallback that renders pages to images is never one. The stamp script itself:
-
-     ```js
-     // stamp.mjs — node, offline. Reads the persisted base, appends a certificate page,
-     // writes ${ACCOUNT_DIR}/e-sign/<DOC_REF>/signed-<token>.pdf. No network, no browser.
-     import { readFileSync, writeFileSync } from "node:fs";
-     import { PDFDocument, StandardFonts } from "pdf-lib";
-
-     const dir  = process.env.DIR;                       // ${ACCOUNT_DIR}/e-sign/<DOC_REF>
-     const cert = JSON.parse(process.env.CERT);          // {name,title,token,doc_ref,accepted_at,method,assertion}
-     const pdf  = await PDFDocument.load(readFileSync(`${dir}/base.pdf`));
-     const font = await pdf.embedFont(StandardFonts.Helvetica);
-     const page = pdf.addPage();
-     const lines = [
-       "Electronic Acceptance Certificate",
-       `Name:      ${cert.name}`,
-       `Title:     ${cert.title ?? "-"}`,
-       `Doc ref:   ${cert.doc_ref}`,
-       `Token:     ${cert.token}`,
-       `Accepted:  ${cert.accepted_at}`,
-       `Method:    ${cert.method}`,                      // e.g. "simple electronic signature (UK ECA 2000 s.7 / UK eIDAS)"
-       "",
-       "Assertion the signer ticked:",
-       cert.assertion,                                   // the verbatim intent/consent text from § 2
-     ];
-     let y = page.getHeight() - 60;
-     for (const ln of lines) { page.drawText(ln, { x: 50, y, size: 11, font }); y -= 20; }
-     writeFileSync(`${dir}/signed-${cert.token}.pdf`, await pdf.save());
+     It loads `base.pdf`, appends the **Electronic Acceptance Certificate** page, and writes `signed-<token>.pdf` beside the base. No browser, no network, and no library to install: `pdf-lib` is a platform dependency that every install provides.
+
+     **Never write your own stamp.** This is not a style preference. A session that found no PDF library on the box once answered it by rasterising the base to a 200 DPI image and redrawing it, which discarded every link annotation and all selectable text. Four signers were sent flattened copies with dead links and nothing logged it. Rasterising a base, whether through ghostscript or any other image-then-redraw route, is prohibited whatever is or is not installed on the device.
+
+     **Pre-flight.** An absent script means the install is out of date, and the single remediation is to upgrade it through the installer. Never hand-install a library on a device, and never substitute a stamp of your own while waiting:
+
+     ```bash
+     test -f "$PLATFORM_ROOT/plugins/business-assistant/skills/e-sign/stamp.mjs" \
+       || echo "e-sign stamp missing: upgrade this install, do not improvise a stamp"
      ```
 
-     The certificate fields come **from the D1 row**, not a re-fetch: `name`, `title` (an operator-defined field if present), `token`, `doc_ref`, `accepted_at`, the signing `method`, and the **verbatim intent/consent assertion** the signer ticked (§ 2). That makes the artifact self-contained evidence of who accepted, when, and on what stated basis.
+     The certificate fields come **from the D1 row**, not a re-fetch: `name`, `title` (an operator-defined field if present), `token`, `doc_ref`, `accepted_at`, the signing `method`, and the **verbatim intent/consent assertion** the signer ticked (§ 2). That makes the artifact self-contained evidence of who accepted, when, and on what stated basis. The script refuses to run on an incomplete certificate.
 
-     **Post-stamp gate: prove fidelity before any send.** For both `base.pdf` and the stamped copy, count link annotations with `grep -a -c '/URI'` and measure page-1 text extent with ghostscript text extraction (`gs -q -dNOPAUSE -dBATCH -sDEVICE=txtwrite -dFirstPage=1 -dLastPage=1 -o - <file> | wc -c`). The stamped copy passes only when its `/URI` count and its page-1 text extent are each at least the base's. On either regression the stamp rasterised or otherwise flattened the base, so delete the stamped copy, skip both sends, and leave the row `swept = 0` so the next sweep re-surfaces it. This gate converts a link-stripped copy from a no-event failure (nothing logs until a signer clicks a dead link) into a rejection at stamp time. Record the base and stamped `/URI` counts alongside every dispatch, pass or fail, so a fidelity regression is a number rather than a complaint.
+     **The fidelity gate lives inside the script, so it cannot be skipped.** Before writing anything it checks the stamped copy against the base on three counts: every base page must come through byte-identical, the page count must be the base plus the certificate pages, and the `/URI` link count must not drop. On any regression it writes no file and exits non-zero, in which case both sends are skipped and the row stays `swept = 0` so the next sweep re-surfaces it. That converts a link-stripped copy from a no-event failure, where nothing logs until a signer clicks a dead link, into a refusal at stamp time. A zero exit prints one `[e-sign-stamp]` line carrying the base and stamped `/URI` counts; keep it with the dispatch record so a fidelity regression is a number rather than a complaint.
 
    - **Send twice via `email-send`**, each carrying `doc_ref`, `name`, `token`, `accepted_at`, and the **stamped** PDF (`signed-<token>.pdf`) as an attachment:
      - once to the **business owner's configured address** (read from configured business identity — never hard-code a recipient in this workflow);

package/payload/platform/plugins/business-assistant/skills/e-sign/stamp.mjs

@@ -0,0 +1,269 @@
+#!/usr/bin/env node
+/**
+ * stamp.mjs — the e-sign per-signer stamp.
+ *
+ * Loads the persisted `base.pdf` for one DOC_REF, appends an Electronic
+ * Acceptance Certificate page carrying the D1 row's fields, and writes
+ * `signed-<token>.pdf` beside the base. No browser, no network.
+ *
+ * This ships with the platform rather than being written out by the agent at
+ * dispatch time, because the agent-authored version was the defect: a session
+ * that met a missing PDF library answered it by rasterising the base to PNG and
+ * redrawing it, which discarded every link annotation and all selectable text.
+ * Signers received flattened copies with dead links and nothing logged it
+ * (Task 1921). `pdf-lib` is a platform dependency, installed on every device by
+ * the installer's `npm install` in `platform/`, so the missing-library branch
+ * that led to rasterising cannot arise.
+ *
+ * The fidelity gate below is what makes that guarantee enforceable rather than
+ * merely intended: the stamped copy is written only when every base page came
+ * through byte-identical and no `/URI` link was lost. A rebuild-from-image
+ * implementation cannot pass it.
+ *
+ * Invocation (the skill's § 6 dispatch step):
+ *
+ *   DIR=<accountDir>/e-sign/<DOC_REF> \
+ *   CERT='{"name":…,"title":…,"token":…,"doc_ref":…,"accepted_at":…,"method":…,"assertion":…}' \
+ *   node "$PLATFORM_ROOT/plugins/business-assistant/skills/e-sign/stamp.mjs"
+ *
+ * Exit 0 writes the copy and prints one `[e-sign-stamp]` record line carrying
+ * the base and stamped `/URI` counts. Any non-zero exit means no copy was
+ * written and the acceptance row must stay `swept = 0`.
+ */
+
+import { createHash } from "node:crypto";
+import { readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { PDFArray, PDFDocument, PDFName, PDFRef, StandardFonts } from "pdf-lib";
+
+const MARGIN = 50;
+const TITLE_SIZE = 14;
+const BODY_SIZE = 11;
+const LINE_HEIGHT = 20;
+
+/** The certificate's fields, in the order § 6 of the skill declares them. */
+export function certificateLines(cert) {
+  return [
+    { text: "Electronic Acceptance Certificate", size: TITLE_SIZE },
+    { text: `Name:      ${cert.name}` },
+    { text: `Title:     ${cert.title ?? "-"}` },
+    { text: `Doc ref:   ${cert.doc_ref}` },
+    { text: `Token:     ${cert.token}` },
+    { text: `Accepted:  ${cert.accepted_at}` },
+    { text: `Method:    ${cert.method}` },
+    { text: "" },
+    { text: "Assertion the signer ticked:" },
+    { text: cert.assertion, wrap: true },
+  ];
+}
+
+/** Break `text` so each line fits `maxWidth` at `size`. Long unbreakable tokens
+ *  are emitted on their own line rather than dropped. */
+export function wrapText(text, font, size, maxWidth) {
+  const words = String(text).split(/\s+/).filter(Boolean);
+  if (words.length === 0) return [""];
+  const lines = [];
+  let line = "";
+  for (const word of words) {
+    const candidate = line ? `${line} ${word}` : word;
+    if (font.widthOfTextAtSize(candidate, size) <= maxWidth || !line) {
+      line = candidate;
+    } else {
+      lines.push(line);
+      line = word;
+    }
+  }
+  if (line) lines.push(line);
+  return lines;
+}
+
+function resolve(doc, obj) {
+  return obj instanceof PDFRef ? doc.context.lookup(obj) : obj;
+}
+
+/** SHA-256 of a page's concatenated content streams. Two pages with the same
+ *  digest carry the same drawing operators; a page re-rendered from an image
+ *  never matches the page it replaced. */
+export function pageContentDigest(doc, page) {
+  const parts = [];
+  const collect = (obj) => {
+    const value = resolve(doc, obj);
+    if (!value) return;
+    if (value instanceof PDFArray) {
+      for (const entry of value.asArray()) collect(entry);
+      return;
+    }
+    if (typeof value.getContents === "function") {
+      parts.push(Buffer.from(value.getContents()));
+      return;
+    }
+    if (value.contents) parts.push(Buffer.from(value.contents));
+  };
+  collect(page.node.get(PDFName.of("Contents")));
+  return createHash("sha256").update(Buffer.concat(parts)).digest("hex");
+}
+
+/** Annotations on `page` whose action dictionary carries a `/URI` — the
+ *  external hyperlinks the signer is meant to be able to click. */
+export function uriLinkCount(doc, page) {
+  const annots = resolve(doc, page.node.get(PDFName.of("Annots")));
+  if (!(annots instanceof PDFArray)) return 0;
+  let count = 0;
+  for (const entry of annots.asArray()) {
+    const annot = resolve(doc, entry);
+    if (typeof annot?.get !== "function") continue;
+    const action = resolve(doc, annot.get(PDFName.of("A")));
+    if (typeof action?.get !== "function") continue;
+    if (action.get(PDFName.of("URI")) !== undefined) count += 1;
+  }
+  return count;
+}
+
+/** Per-page digests and `/URI` counts, in page order. */
+export async function pageFingerprints(bytes) {
+  const doc = await PDFDocument.load(bytes);
+  return doc.getPages().map((page) => ({
+    digest: pageContentDigest(doc, page),
+    uris: uriLinkCount(doc, page),
+  }));
+}
+
+/**
+ * Reject the stamped bytes unless every base page survived unaltered.
+ *
+ * Three conditions, each naming a distinct way a stamp can destroy the document
+ * it was supposed to preserve:
+ *   1. page count, which catches base pages lost between building the document
+ *      and reading back what was serialised;
+ *   2. content digest, which catches a page redrawn (the rasterisation failure);
+ *   3. per-page `/URI` count, which catches annotations discarded while the
+ *      visible page survives. Compared page by page rather than as a document
+ *      total, so links moved off one page cannot be masked by another.
+ */
+export async function assertFidelity(baseBytes, stampedBytes, addedPages) {
+  const base = await pageFingerprints(baseBytes);
+  const stamped = await pageFingerprints(stampedBytes);
+
+  const expected = base.length + addedPages;
+  if (stamped.length !== expected) {
+    throw new Error(
+      `page count regressed: base ${base.length} + ${addedPages} certificate page(s) ` +
+        `should give ${expected}, stamped copy has ${stamped.length}`,
+    );
+  }
+
+  for (let i = 0; i < base.length; i += 1) {
+    if (stamped[i].digest !== base[i].digest) {
+      throw new Error(
+        `page ${i + 1} was re-rendered rather than copied — its content stream does not ` +
+          `match the base. A stamp must copy existing pages; rasterising or redrawing them ` +
+          `discards links and selectable text.`,
+      );
+    }
+    if (stamped[i].uris < base[i].uris) {
+      throw new Error(
+        `link annotations lost on page ${i + 1}: base carries ${base[i].uris} /URI link(s), ` +
+          `stamped copy carries ${stamped[i].uris}`,
+      );
+    }
+  }
+
+  const baseUris = base.reduce((n, p) => n + p.uris, 0);
+  const stampedUris = stamped.reduce((n, p) => n + p.uris, 0);
+  return { basePages: base.length, stampedPages: stamped.length, baseUris, stampedUris };
+}
+
+/** Load the base, append the certificate, and return the stamped bytes plus the
+ *  number of pages the certificate needed. */
+export async function buildStamped(baseBytes, cert) {
+  const pdf = await PDFDocument.load(baseBytes);
+  const basePages = pdf.getPageCount();
+  if (basePages === 0) throw new Error("base.pdf has no pages");
+
+  const font = await pdf.embedFont(StandardFonts.Helvetica);
+  const [width, height] = [pdf.getPage(0).getWidth(), pdf.getPage(0).getHeight()];
+  const maxWidth = width - MARGIN * 2;
+
+  let page = pdf.addPage([width, height]);
+  let y = height - MARGIN - LINE_HEIGHT;
+  const draw = (text, size) => {
+    if (y < MARGIN) {
+      page = pdf.addPage([width, height]);
+      y = height - MARGIN - LINE_HEIGHT;
+    }
+    if (text) page.drawText(text, { x: MARGIN, y, size, font });
+    y -= LINE_HEIGHT;
+  };
+
+  try {
+    for (const line of certificateLines(cert)) {
+      const size = line.size ?? BODY_SIZE;
+      if (line.wrap) {
+        for (const wrapped of wrapText(line.text, font, size, maxWidth)) draw(wrapped, size);
+      } else {
+        draw(line.text, size);
+      }
+    }
+  } catch (err) {
+    // Helvetica is WinAnsi-encoded, so a signer name or assertion carrying a
+    // character outside CP-1252 cannot be drawn. Say so in terms that keep the
+    // caller on the supported path: the remedy is a platform change that embeds
+    // a Unicode font, never a stamp improvised with a different library.
+    throw new Error(
+      `the certificate carries a character the standard font cannot encode (${err.message}). ` +
+        `This needs a platform fix that embeds a Unicode font. Do not improvise a stamp: ` +
+        `leave the row swept = 0 and report it.`,
+    );
+  }
+
+  return { bytes: await pdf.save(), addedPages: pdf.getPageCount() - basePages };
+}
+
+const REQUIRED_CERT_FIELDS = ["name", "token", "doc_ref", "accepted_at", "method", "assertion"];
+
+async function main() {
+  const dir = process.env.DIR;
+  if (!dir) throw new Error("DIR is not set — it must be <accountDir>/e-sign/<DOC_REF>");
+  if (!process.env.CERT) throw new Error("CERT is not set — it must be the D1 row's certificate fields as JSON");
+
+  let cert;
+  try {
+    cert = JSON.parse(process.env.CERT);
+  } catch (err) {
+    throw new Error(`CERT is not valid JSON: ${err.message}`);
+  }
+  const missing = REQUIRED_CERT_FIELDS.filter((field) => cert[field] === undefined || cert[field] === "");
+  if (missing.length > 0) {
+    throw new Error(
+      `CERT is missing ${missing.join(", ")} — every field comes from the acceptance row, never a re-fetch`,
+    );
+  }
+
+  const basePath = join(dir, "base.pdf");
+  const baseBytes = readFileSync(basePath);
+  const { bytes, addedPages } = await buildStamped(baseBytes, cert);
+  const counts = await assertFidelity(baseBytes, bytes, addedPages);
+
+  const outPath = join(dir, `signed-${cert.token}.pdf`);
+  writeFileSync(outPath, bytes);
+  console.log(
+    `[e-sign-stamp] op=stamped doc_ref=${cert.doc_ref} token=${cert.token} ` +
+      `base_pages=${counts.basePages} stamped_pages=${counts.stampedPages} ` +
+      `base_uris=${counts.baseUris} stamped_uris=${counts.stampedUris} out=${outPath}`,
+  );
+}
+
+// Node realpaths the ESM entry point, so `import.meta.url` is symlink-resolved
+// and `process.argv[1]` is not. Comparing them raw makes a symlinked
+// PLATFORM_ROOT skip main() and exit 0 having stamped nothing, which is exactly
+// the silent success this script exists to make impossible.
+const invokedDirectly =
+  process.argv[1] && import.meta.url === pathToFileURL(realpathSync(process.argv[1])).href;
+
+if (invokedDirectly) {
+  main().catch((err) => {
+    console.error(`[e-sign-stamp] op=failed reason="${err.message}" — no copy written, leave the row swept = 0`);
+    process.exit(1);
+  });
+}

package/payload/platform/plugins/cloudflare/PLUGIN.md

@@ -1,7 +1,7 @@
 ---
 name: cloudflare
 description: Cloudflare operations — tunnel setup/reset, DNS, Pages hosting, D1 data capture, and dashboard guidance. Zero agent-facing MCP tools; every operation is the agent invoking `cloudflared` or `wrangler` directly via Bash, calling the Cloudflare API with a reused per-scope narrow token, or quoting a dashboard click-path the operator performs themselves.
-account-owned-files: [{"file": "data-portal.json", "description": "The account's data-portal folder index, written by bin/portal-index-push.mjs on every push."}]
+account-owned-files: [{"file": "data-portal.json", "writtenBy": "agent", "description": "The account's portal config and folder index. Authored by the agent under the data-portal skill, which is also the only path that changes it; bin/portal-index-push.mjs reads it on every push."}]
 tools: []
 mcp-manifest: skip
 ---

package/payload/platform/plugins/cloudflare/bin/schema-exposed-dirs.mjs

@@ -78,7 +78,7 @@ export function resolveExposedDirs(schemaText, exposeFolders = []) {
     collisions: /** @type {string[]} */ ([]),
     exposed: /** @type {string[]} */ ([]),
   }
-  // Fail CLOSED. fs-schema-guard.sh:76-78 fails open on a missing schema so an
+  // Fail CLOSED. fs-schema-guard.sh:77-80 fails open on a missing schema so an
   // unseeded legacy account is not write-blocked; a read surface facing a
   // client must do the opposite. Do not "fix" this to match the guard.
   if (typeof schemaText !== 'string' || schemaText.length === 0) return empty

package/payload/platform/plugins/linkedin-import/skills/linkedin-import/references/profile.md

@@ -40,18 +40,18 @@ This reference invokes `mcp__plugin_memory_memory__memory-update` once with the
 {
   "nodeId": "<elementId of :UserProfile from owner-confirmation>",
   "properties": {
-    "givenName": "Joel",
-    "familyName": "Smalley",
+    "givenName": "<given name>",
+    "familyName": "<family name>",
     "additionalName": null,
     "address": null,
     "birthDate": null,
-    "headline": "Founder, Rubytech",
+    "headline": "Founder, <company>",
     "description": "Building {{productName}} …",
     "industry": "Software",
     "postalCode": null,
     "addressLocality": "London, UK",
-    "twitterHandles": ["@joelsmalley"],
-    "websites": ["https://getmaxy.com"],
+    "twitterHandles": ["@<handle>"],
+    "websites": ["https://example.com"],
     "instantMessengers": [],
     "linkedinProfileUpdatedAt": "<ISO 8601 timestamp>",
     "source": "linkedin"

package/payload/platform/plugins/memory/skills/conversation-archive-enrich/SKILL.md

@@ -15,8 +15,8 @@ The LLM step runs in the specialist's turn. There is no server-side Haiku round-
 
 When the operator names a specific archive AND asks for insights, enrichment, or derived claims against it. Concrete triggers:
 
-- "Derive insights from the Adam Mackay WhatsApp archive."
-- "Enrich the Joel × Adam conversation archive — surface anything actionable."
+- "Derive insights from the WhatsApp archive for <contact>."
+- "Enrich the <contact-a> × <contact-b> conversation archive — surface anything actionable."
 - "Run Phase 2 on `:ConversationArchive elementId=4:abcd…:42`."
 
 Never auto-fire after a Phase 1 ingest completes — `conversation-archive` (the ingest skill) explicitly writes ZERO observations. Phase 2 is operator-gated by design.

package/payload/platform/plugins/memory/skills/document-ingest/SKILL.md

@@ -206,7 +206,7 @@ Re-ingesting the same `attachmentId` is safe — the writer drops prior `:Sectio
 
 After `memory-ingest` returns the new KnowledgeDocument's `documentNodeId`, this step iterates the entities the dispatch brief named and connects each to the new document with the natural KD-level edge.
 
-**Entity sources.** The dispatch brief's "key entities to connect" list. Brief shape: prose names of Persons, Organizations, Services, Tasks, Events, KnowledgeDocuments, BrandingData that the document describes or references. Example: *"Person nodes for Joel Smalley, Adam Mackay, Dan McLeod; LocalBusiness / Organization nodes for Real Agent / Real Agency; Any existing Task nodes related to Real Agent Lettings."* Extract every named entity from the brief before any `memory-write`.
+**Entity sources.** The dispatch brief's "key entities to connect" list. Brief shape: prose names of Persons, Organizations, Services, Tasks, Events, KnowledgeDocuments, BrandingData that the document describes or references. Example: *"Person nodes for each named individual; LocalBusiness / Organization nodes for each named company; any existing Task nodes related to the engagement the document describes."* Extract every named entity from the brief before any `memory-write`.
 
 **Resolution.** For each named entity:
 2. If the entity resolves to exactly one node, write the edge from KD to that node (see edge-type table below).

package/payload/platform/plugins/scheduling/PLUGIN.md

@@ -1,7 +1,7 @@
 ---
 name: scheduling
 description: "Calendar and scheduling — create events, manage appointments, set up recurring triggers."
-account-owned-files: [{"file": "calendar-availability.json", "description": "The booking page's availability config, written by the publish-availability script and read by the live booking page."}]
+account-owned-files: [{"file": "calendar-availability.json", "writtenBy": "agent", "description": "The booking page's availability config. Authored by the agent under the calendar-site skill, which is also the only path that changes it; the publish-availability script reads it to refresh the live booking page."}]
 tools:
   - name: schedule-event
     publicAllowlist: false

package/payload/platform/plugins/x-import/skills/x-import/SKILL.md

@@ -57,7 +57,7 @@ Dispatch the existing librarian / document-ingest pipeline against the rendered
 - `mimeType = "text/markdown"`
 
 The dispatch brief names:
-- **Anchor:** `:AdminUser` (the confirmed owner from Phase 0). Adam Mackay / Joel Smalley etc. resolved in Phase 0 appear in the **key entities to connect** list — `wire-brief-entities` writes the `MENTIONED` / `REPLIED_TO` / `QUOTED` edges from the new KD to each `:Person`.
+- **Anchor:** `:AdminUser` (the confirmed owner from Phase 0). Every `:Person` resolved in Phase 0 appears in the **key entities to connect** list — `wire-brief-entities` writes the `MENTIONED` / `REPLIED_TO` / `QUOTED` edges from the new KD to each `:Person`.
 - **`sourceUrl`:** `https://x.com/<handle>`
 - **`sourceType`:** `'x'` (carried into `:KnowledgeDocument.source`)
 - **`scope`:** `'admin'` (the tweet stream is the operator's authored content)

package/payload/platform/scripts/__tests__/account-schema-owned-dirs.test.sh

@@ -395,5 +395,31 @@ for _n in e-sign data-portal.json calendar-availability.json wa-channel-bindings
   assert_grep "$_n" "$ALLOWED_SHIP" "ship-allow-$_n"
 done
 
+# --- declared-files fence: one name<TAB>plugin line per declared FILE -------
+# The allowed-top-level fence is a layout list: it says a name may exist at the
+# account root, not that an agent may author it. The write guard needs the file
+# set apart from the bucket set, plus the owning plugin to name in its block
+# message, so the merge emits it as its own fence.
+DECL_SHIP="$(awk '/^```declared-files$/{f=1;next} /^```$/{f=0} f' "$A_SHIP/SCHEMA.md")"
+for _n in wa-channel-bindings.json telegram-channel-bindings.json webchat-channel-bindings.json \
+          canonical-webchat-session.json session-titles.json agents-disabled.json; do
+  assert_grep "$(printf '%s\tadmin' "$_n")" "$DECL_SHIP" "ship-decl-$_n"
+done
+# An agent-written declaration (writtenBy: agent) stays OUT of the fence: the
+# calendar-site and data-portal skills author these two files with Write, so
+# denying them would break the only path that creates them. They remain in the
+# allowed set (asserted above), so the reconcile still never calls them strays.
+assert_nogrep "data-portal.json" "$DECL_SHIP" "ship-decl-excludes-agent-written-portal"
+assert_nogrep "calendar-availability.json" "$DECL_SHIP" "ship-decl-excludes-agent-written-availability"
+# A declared DIR never enters the file fence.
+assert_nogrep "e-sign" "$DECL_SHIP" "ship-decl-excludes-dirs"
+assert_grep "declared-files:start" "$(cat "$A_SHIP/SCHEMA.md")" "ship-decl-marker"
+# Idempotent: a second merge leaves the file byte-identical.
+B_SHIP="$(shasum "$A_SHIP/SCHEMA.md" | awk '{print $1}')"
+merge_owned_dirs_into_schema "$A_SHIP" >/dev/null
+assert_eq "$(shasum "$A_SHIP/SCHEMA.md" | awk '{print $1}')" "$B_SHIP" "ship-decl-idempotent"
+# A brand whose payload declares no owned file emits no region at all.
+assert_nogrep "declared-files:start" "$(cat "$A_MX/SCHEMA.md")" "mx-no-decl-region"
+
 echo "PASS=$PASS FAIL=$FAIL"
 if [ "$FAIL" -ne 0 ]; then printf '%s\n' "${FAILED[@]}"; exit 1; fi

package/payload/platform/scripts/check-no-esm-require.mjs

@@ -44,6 +44,12 @@ const ALLOWLIST = new Set([
   // Same vi.hoisted pattern: Task 549's sidebar-sessions test pre-builds a
   // tmpdir before the module-under-test's ACCOUNTS_DIR mock is wired.
   'platform/ui/server/routes/admin/__tests__/sidebar-sessions.test.ts',
+  // Same vi.hoisted pattern: Task 2035's sidebar-sessions walk test pre-builds
+  // its projects tmpdir before the ACCOUNTS_DIR mock is wired.
+  'platform/ui/server/routes/admin/__tests__/sidebar-sessions-walk.test.ts',
+  // Same vi.hoisted pattern: Task 2035's reader title-cache test pre-builds its
+  // accounts tmpdir before the ACCOUNTS_DIR mock is wired.
+  'platform/ui/server/routes/__tests__/whatsapp-reader-title-cache.test.ts',
   // Same vi.hoisted pattern: Task 684's sidebar-artefacts test pre-builds an
   // empty tmpdir for ACCOUNTS_DIR/PLATFORM_ROOT before the module's mocks fire.
   'platform/ui/server/routes/admin/__tests__/sidebar-artefacts.test.ts',

package/payload/platform/scripts/lib/account-schema-owned-dirs.py

@@ -8,6 +8,13 @@ by kind:
     account-owned-dirs:  [{"dir": "quoting", "description": "..."}]
     account-owned-files: [{"file": "data-portal.json", "description": "..."}]
 
+A file entry may add "writtenBy": "agent" to say the agent authors it under a
+skill's instruction rather than platform code writing it whole. Such a file is
+still declared — the reconcile must not call it a stray — but it is left out of
+the declared-files fence the write guard denies on, because denying it would
+block the only path that creates it. Absent or any other value means platform
+code is the writer.
+
 The owned-entry set for a brand is the union declared by every platform plugin
 ($PROJECT_DIR/plugins/*/PLUGIN.md) and every premium sub-plugin of a bundle the
 brand ships ($PREMIUM_ROOT/<bundle>/plugins/*/PLUGIN.md, gated by brand.json
@@ -30,6 +37,8 @@ MARK_START = "<!-- plugin-owned-dirs:start -->"
 MARK_END = "<!-- plugin-owned-dirs:end -->"
 ONT_START = "<!-- ontology-buckets:start -->"
 ONT_END = "<!-- ontology-buckets:end -->"
+DECL_START = "<!-- declared-files:start -->"
+DECL_END = "<!-- declared-files:end -->"
 
 # Base top-level names shipped in the account template plus `.quarantine`. This
 # set is prune-protection only: a reconcile never *adds* a missing seed entry,
@@ -109,7 +118,9 @@ def _read_vertical(project_dir):
 
 
 def _parse_plugin_md(path):
-    """Return (name, [ {name, kind, description} ]) from a PLUGIN.md, or (None, []).
+    """Return (name, [ {name, kind, description, writtenBy} ]) from a PLUGIN.md,
+    or (None, []). `writtenBy` is '' unless the entry states one; 'agent' keeps
+    the name out of the declared-files fence (see the module docstring).
     Two frontmatter keys, one list: `account-owned-dirs` yields kind='dir',
     `account-owned-files` yields kind='file'. A key whose value is not a JSON
     array of objects is skipped WHOLE: entries are staged and committed only once
@@ -145,7 +156,8 @@ def _parse_plugin_md(path):
                 n = (e.get(field) or "").strip()
                 if n and "/" not in n:
                     staged.append({"name": n, "kind": kind,
-                                   "description": (e.get("description") or "").strip()})
+                                   "description": (e.get("description") or "").strip(),
+                                   "writtenBy": (e.get("writtenBy") or "").strip()})
         except Exception:
             continue
         owned.extend(staged)
@@ -190,7 +202,8 @@ def resolve(project_dir):
             if e["name"] in seen:
                 continue
             seen[e["name"]] = {"name": e["name"], "kind": e["kind"],
-                               "description": e["description"], "plugin": name or "unknown"}
+                               "description": e["description"], "plugin": name or "unknown",
+                               "writtenBy": e["writtenBy"]}
             order.append(e["name"])
     return [seen[n] for n in order]
 
@@ -355,9 +368,10 @@ def merge(project_dir, account_dir):
         lines = text.split("\n")
         lines[start + 1:end] = new_entries
         text = "\n".join(lines)
-    # Regenerate both descriptive regions wholesale (idempotent).
+    # Regenerate every generated region wholesale (idempotent).
     text = _strip_region(text, MARK_START, MARK_END)
     text = _strip_region(text, ONT_START, ONT_END)
+    text = _strip_region(text, DECL_START, DECL_END)
     if owned:
         region = [MARK_START, "## Plugin-owned top-level entries", "",
                   "A plugin declares the account-root entries its feature owns. A",
@@ -393,6 +407,28 @@ def merge(project_dir, account_dir):
                           f"(owned by `{b['owner']}`), not a root bucket.")
         region.append(ONT_END)
         text = text.rstrip("\n") + "\n\n" + "\n".join(region) + "\n"
+    # The declared-file set, machine-readable and separate from the
+    # allowed-top-level fence. That fence is a layout list — it says a name may
+    # exist at the account root — and the write guard reads it as its allow-list,
+    # so a name unioned into it becomes agent-writable. This fence carries the
+    # other half the guard needs: which of those names is written whole by
+    # platform code, and which plugin to name when it blocks the write. An
+    # agent-written declaration is excluded: its skill authors it with Write, so
+    # denying it would block the only path that creates it.
+    declared = [e for e in owned if e["kind"] == "file" and e["writtenBy"] != "agent"]
+    if declared:
+        region = [DECL_START, "## Declared files (written by platform code, owned by a plugin)", "",
+                  "Each file below is written whole by platform code and owned by the",
+                  "plugin named beside it. It is control-plane state, not operator data:",
+                  "never hand-edit one, because the next platform write overwrites the",
+                  "edit. The write guard reads this block and blocks a write whose first",
+                  "path segment is one of these names.", "",
+                  "```declared-files"]
+        for e in declared:
+            region.append(f"{e['name']}\t{e['plugin']}")
+        region.append("```")
+        region.append(DECL_END)
+        text = text.rstrip("\n") + "\n\n" + "\n".join(region) + "\n"
     with open(schema_path, "w") as f:
         f.write(text)
     root_dirs = [b["dir"] for b in domain if _is_root(b["owner"])]