@rubytech/create-maxy-code 0.1.398 → 0.1.400

package/payload/platform/plugins/web-designer/skills/web-design/templates/llms.txt

@@ -0,0 +1,32 @@
+# {{ COMPANY_LEGAL_NAME }}
+
+> {{ LLMS_SUMMARY }}
+
+## Facts
+
+- Legal name: {{ COMPANY_LEGAL_NAME }}
+- Company number: {{ COMPANY_NUMBER }} (registered in {{ COMPANY_JURISDICTION }})
+- Registered office: {{ STREET_ADDRESS }}, {{ POST_TOWN }}, {{ COUNTY }}, {{ POSTCODE }}
+- Established: {{ ESTABLISHED_YEAR }} ({{ YEARS_TRADING }} of experience)
+- Ownership: {{ OWNERSHIP }}
+- Areas served: {{ REGION }}
+- Telephone: {{ PHONE_DISPLAY }} / {{ MOBILE_DISPLAY }}
+- Email: {{ EMAIL }}
+- Led by {{ FOUNDER_NAME }}, who runs the team and posts project progress directly.
+- Recent projects: {{ RECENT_PROJECTS }}
+
+## Services
+
+- {{ SERVICE_1_NAME }}: {{ SERVICE_1_DESC }}
+- {{ SERVICE_2_NAME }}: {{ SERVICE_2_DESC }}
+- {{ SERVICE_3_NAME }}: {{ SERVICE_3_DESC }}
+- {{ SERVICE_4_NAME }}: {{ SERVICE_4_DESC }}
+- {{ SERVICE_5_NAME }}: {{ SERVICE_5_DESC }}
+- {{ SERVICE_6_NAME }}: {{ SERVICE_6_DESC }}
+
+## Links
+
+- Website: {{ WEBSITE_URL }}
+- Facebook: {{ FACEBOOK_URL }}
+- Instagram: {{ INSTAGRAM_URL }}
+- TikTok: {{ TIKTOK_URL }}

package/payload/platform/plugins/web-designer/skills/web-intake/SKILL.md

@@ -0,0 +1,107 @@
+---
+name: web-intake
+description: Single-entry orchestrator that turns an operator's raw inputs — a folder or zip of photos, an existing website URL, social links, and free-text notes — into a finished single-page website plus share-ready social tiles, starting from what the site is for. Leads with the objective (what a visitor should do), then routes brand-extract → web-design → socials and asks targeted questions to fill every field the sources do not supply. Use whenever the deliverable is "a website for this business" from mixed source material. Trigger phrases include "design a site for this business", "build a landing page from these photos and their website", "put together a one-page site and social tiles".
+allowed-tools:
+  - Bash
+  - Read
+  - Write
+  - Edit
+  - Glob
+  - Grep
+  - WebFetch
+  - Skill
+  - AskUserQuestion
+---
+
+# web-intake
+
+Orchestrates the `brand-extract → web-design → socials` pipeline and the deploy
+hand-off. The deliverable is a self-contained `site/` directory (a scrollable
+single-page site, an `llms.txt`, and a `socials/` folder of Open Graph and social
+tiles with a gallery and captions), built from whatever the operator provides and
+whatever the orchestrator has to ask for, and shaped by what the site is for.
+
+This skill is a playbook, not a programmatic dispatcher. It tells you the routing
+and the gap-filling contract; you execute each step under the underlying skills'
+own contracts. It dispatches no specialist worker.
+
+## Start with the objective
+
+Before collecting facts, settle what the site is **for** and what a visitor should
+**do**. That decision drives the CTAs, the forms, and whether the page needs gated
+access or signing — so it comes first, not last. The objective-first questions are
+in [`references/intake.md`](references/intake.md) § 0; the rest of that file is the
+field-by-field gap list.
+
+## What the operator gives, and what you do with it
+
+| Operator supplies | Used for | If missing |
+|---|---|---|
+| **Images** (folder or zip of photos) | hero rotator, photo grids, portrait, testimonial, social tiles | the site is image-led. If none, stop and ask. |
+| **Website URL** | brand tokens (palette, accent), logo, company name, contact, services, "about" copy | run `brand-extract`; anything it cannot read becomes a question |
+| **Social links** | footer + drawer links, handles, extra copy in the operator's own voice | login-walled platforms usually cannot be scraped — say so plainly and ask the operator to paste anything they want used |
+| **Free-text notes / pasted quotes** | the person section, testimonials, latest-update cards, service descriptions, taglines | use verbatim where the operator marks a quote; never reword a real client testimonial into marketing prose |
+| **Design tokens** (if supplied directly) | the palette `:root` — use them verbatim | if absent, `brand-extract` derives them from the site |
+
+## The core rule: ask, never invent
+
+Every `{{ PLACEHOLDER }}` in the templates is a fact about a real business. For
+every placeholder still unfilled after `brand-extract`, ask the operator — do not
+synthesise a plausible value. A fabricated phone number, a guessed founding year,
+an invented testimonial, or a made-up company number is a defect. Two facts are
+load-bearing and frequently wrong if guessed: the **established year** (a business
+that "trades since 1987" may have incorporated much later — keep the two distinct)
+and any **company-registration detail**, which comes from the register or the
+operator, never from a marketing line.
+
+## Process — high level
+
+1. **Set the objective.** Ask `references/intake.md` § 0: what the site is for, what
+   a visitor should do, the CTAs, which forms (contact / waitlist / custom bucket),
+   whether any page or document needs gated access, whether anything needs signing.
+   These answers shape every later step.
+2. **Resolve the workspace.** Default output root is the images directory's parent,
+   or the operator's stated path. The deliverable lands in `<output>/site/`.
+3. **Run `brand-extract`** against the website URL for the palette, logo, icon, and
+   the facts it can read, plus a `brand.md` of what is still unknown. If the
+   operator supplied design tokens directly, use those verbatim.
+4. **Curate the images.** Verify each photo's *content* by eye, measuring first and
+   previewing any image over 2000px on its longest edge (downscale to `/tmp`, read,
+   delete). Lead the hero with the strongest "arrive here" shot; map the rest to the
+   grids. A portrait is for the person section and a portrait tile, never a
+   landscape crop.
+5. **Fill the gaps.** Compare the token inventory
+   ([`../web-design/references/placeholders.md`](../web-design/references/placeholders.md))
+   against what brand-extract found and the operator's notes. Ask for everything
+   still missing, in grouped questions. Wait for answers. Do not proceed with blanks.
+6. **Run `web-design`** to build `site/index.html` + `site/llms.txt`, substituting
+   every placeholder. No `{{ }}` may survive.
+7. **Run `socials` in `microsite` mode** to render the tiles into `site/socials/`,
+   plus `site/socials.html` and `site/social-posts.md`, and to wire the site's
+   `og:image`.
+8. **Hand off to deploy.** When the operator wants the site live, follow
+   `../web-design/references/deploy.md`. If the objective needs gated access or
+   signing, follow `../web-design/references/gating.md` and
+   `../web-design/references/e-sign.md`.
+9. **Verify and report.** Confirm no placeholder survived, every asset resolves over
+   a local HTTP server, the site renders at desktop and mobile, and tiles are at
+   exact dimensions. Report the `site/` path and every value you had to ask for.
+
+## Completion criteria
+
+- `grep "{{" site/index.html site/llms.txt site/socials.html` returns nothing.
+- No invented facts: every value traces to the website, the operator's notes, or an
+  answer the operator gave. Anything still unknown is shown as a clear gap.
+- The site renders at desktop and a 390px mobile viewport with no horizontal
+  overflow and no broken images; the hero rotates; the back-to-top works.
+- Social tiles exist at exact sizes (1200×628 / 1200×1200 / 1080×1350); any person
+  tile is portrait only.
+- The report names the objective, the CTAs and forms wired, and every field asked for.
+
+## When NOT to use this skill
+
+- The operator only wants the site, or only the tiles → call `web-design` or
+  `socials` directly.
+- The operator only wants brand tokens and a logo from a URL → call `brand-extract`.
+- There are no usable photos of the business → the site is image-led; ask for photos
+  first.

package/payload/platform/plugins/web-designer/skills/web-intake/references/intake.md

@@ -0,0 +1,103 @@
+# Intake & gap-filling questions
+
+Ask only for what the website and the operator's notes did not already supply.
+Group the questions so the operator answers in as few turns as possible, and
+present sensible candidates from the source material where you have them ("Your
+site says you've traded since 1994 — is that the year to show?").
+
+Never invent a value to avoid asking. A guessed phone number or founding year is
+a defect. If the operator does not know a field (e.g. company number), leave that
+slot out of the output rather than filling it with a guess.
+
+## 0. Objective — ask this first
+
+The site's purpose drives the CTAs, the forms, and whether it needs gating or
+signing. Settle it before collecting facts.
+
+- **What is the site for?** The single most important thing a visitor should do —
+  book a call, request a quote, join a waitlist, buy a service, sign a document,
+  or simply find and trust the business. Name one primary objective; secondary
+  ones are fine but rank them.
+- **What behaviour do you want?** How a visitor should move through the page — read
+  the story first, jump to services, go straight to a contact form. This shapes the
+  section order and what the sticky sub-nav pushes.
+- **CTAs.** The exact calls to action and where they point — a phone number, an
+  email enquiry, a booking link, a form. The hero CTA, the sub-nav CTA, and the
+  closing CTA can differ; name each.
+- **Forms / buckets.** Which forms the site captures: a **contact** form, a
+  **waitlist** signup, a **callback** request, or a custom bucket (e.g. a quote
+  request with its own fields). Each form is its own D1 table. Name the fields each
+  form collects.
+- **Gated access?** Whether any page or document must sit behind a login (a private
+  proposal, a client-only page). If yes, note who should be allowed in (an email
+  allowlist for external visitors).
+- **E-signing?** Whether any document on the site must be signed (a quote, a
+  contract, terms). If yes, it is handed to the signing skill; capture the document
+  and the signer up front.
+
+## 1. Identity
+
+- Trading name and full legal name (e.g. "Meridian Advisory" / "Meridian Advisory Ltd").
+- Short monogram / initials, if any (used as a small brand mark).
+- Tagline / strapline, in their own words.
+- Sector label for the nav and tiles — what the business is, in their words (e.g.
+  "Chartered accountants", "Dental practice", "Design studio"). No default category.
+- Established year. **Keep "trading since" separate from "company incorporated".**
+- Company registration number + jurisdiction, and registered office — only if the
+  operator wants legal detail in the footer, and what to call the number in their
+  jurisdiction. Take these from the register or the operator, never from a marketing
+  line.
+
+## 2. Contact & place
+
+- Phone (display + dialable), mobile if separate.
+- Email.
+- Website domain and full URL (for canonical + Open Graph).
+- Address: street, post town, county, postcode (only the parts they want shown).
+- Service area / region phrase (e.g. "the South East" or "Greater Manchester").
+- Social profiles: Facebook, Instagram, TikTok, LinkedIn (URLs + handles).
+
+## 3. The story (copy, in their voice)
+
+- One or two paragraphs on who they are and how long they've been going.
+- What they're proudest of / the standard they hold to.
+- A headline sentence that sums the business up.
+- The three or four "by the numbers" facts (established, experience, ownership,
+  coverage, specialism, approach, promise).
+
+## 4. What they do (services)
+
+- Up to six services, each a short name and a one-line description.
+- A one-line lede for the services section.
+
+## 5. The person (optional)
+
+- Name and role of the person who fronts the business, if there is one.
+- A short intro in their voice (what they do, how hands-on they are).
+- A quote from them, ideally about a specific piece of work or their approach.
+- 1–3 recent "latest update" cards in their own words (drop emoji per the plain
+  register).
+- A portrait photo (used in the person section and a portrait social tile — a
+  person is never cropped to landscape). Drop this whole section if there is no
+  single figurehead.
+
+## 6. Proof (testimonial)
+
+- A real client quote, used verbatim. Note the one phrase to highlight.
+- Who it's from and the context.
+- Which photo best illustrates it.
+- Any thank-you artefact (a card, a note) that adds a personal touch.
+
+## 7. FAQ (answer-engine targets)
+
+- 3–5 plain questions a customer actually asks, each with a one or two sentence
+  answer. Default set: what they do, how long they've been going, where they're
+  based / areas covered, plus two specific to the business.
+
+## 8. Images (you curate, but confirm)
+
+- Confirm which photo is the strongest "arrive here" shot (hero / main tile).
+- Confirm the best result shot (testimonial + interior tile).
+- Confirm a strong wide shot (full-bleed).
+- Flag if the photo set is thin so expectations are set, and ask for any photos that
+  would strengthen the hero.

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

@@ -99,7 +99,13 @@ The agent links as a companion device on the operator's own WhatsApp account, so
 
 ## Live persistence
 
-Every `messages.upsert` event (both `notify` and `append`, both `fromMe` directions) is captured at a single site in `platform/ui/app/lib/whatsapp/manager.ts` and split two ways: the sender's `:Person` node is MERGEd in Neo4j (identity linkage, shared with the rest of the platform's People model — unchanged from before), and the message content itself is appended to an on-disk JSONL store at `~/.<brand>/data/whatsapp-messages/<platformAccountId>/<remoteJid>.jsonl` — one file per conversation, one line per message. `:Message:WhatsAppMessage` nodes and their `:PART_OF`/`:SENT`/`:NEXT` edges no longer exist; message ordering is a `dateSent` sort at read time instead of a graph edge. `:Conversation` nodes are unaffected — they remain the shared session anchor for the agent-path `:UserMessage`/`:AssistantMessage` writer too. `messageId` namespace is unchanged: `whatsapp-live:<waName>:<remoteJid>:<msg.key.id>`. Persist failures are loud (`[whatsapp-persist] FAIL …`) and never block dispatch.
+Every `messages.upsert` event (both `notify` and `append`, both `fromMe` directions) is captured at a single site in `platform/ui/app/lib/whatsapp/manager.ts` and split two ways: the sender's `:Person` node is MERGEd in Neo4j (identity linkage, shared with the rest of the platform's People model — unchanged from before), and the message content itself is appended to an on-disk JSONL store at `~/.<brand>/data/whatsapp-messages/<platformAccountId>/<canonicalConversationJid>.jsonl` — one file per **contact**, one line per message. `:Message:WhatsAppMessage` nodes and their `:PART_OF`/`:SENT`/`:NEXT` edges no longer exist; message ordering is a `dateSent` sort at read time instead of a graph edge. `:Conversation` nodes are unaffected — they remain the shared session anchor for the agent-path `:UserMessage`/`:AssistantMessage` writer too. Persist failures are loud (`[whatsapp-persist] FAIL …`) and never block dispatch.
+
+**Conversation-key canonicalisation.** The store file is keyed on the *canonical* conversation JID, not the raw wire `remoteJid`. WhatsApp addresses one contact both by a linked-identity JID (`<lid>@lid`) and a phone-number JID (`<number>@s.whatsapp.net`), so inbound and in-thread replies accrete under the LID while number-addressed outbound sends echo under the PN — keying on the raw `remoteJid` splits one contact across two files. `resolveCanonicalConversationJid` (`normalize.ts`) resolves each message's `remoteJid` to a single key via Baileys' own LID→PN mapping (`getPNForLID`) — the phone-number JID when the LID resolves to one, else the raw JID unchanged (LID-only contacts stay LID-keyed; group and PN JIDs are already canonical) — before `appendMessage` chooses the file. The keying decision is logged on every store write: `[whatsapp-message-store] op=key raw=<jid> canonical=<jid> resolved=<lid2pn|none>`, so a future split (canonical diverging across a contact's records) is greppable at write time. `messageId` keeps the **raw** wire JID — `whatsapp-live:<waName>:<remoteJid>:<msg.key.id>` — so idempotency is stable across the canonicalisation boundary: a replay of the same wire message keeps its `messageId` regardless of which store file it lands in. Because a `@lid` remoteJid resolves to its PN key only once Baileys' LID mapping warms, a message's live delivery and its later history-sync replay can target different files; `appendMessage` therefore dedupes against the raw remoteJid as an alt key (passed by persist when the canonical key differs), so the second write no-ops instead of double-writing across the two files.
+
+**Reader labelling.** A store row is never labelled with the install's own linked (self) number. A 1:1 is labelled by its **counterparty**: a phone-number-keyed conversation (`@s.whatsapp.net`) is addressed by the peer's number, so `buildStoreConversationRows` takes `senderId` straight from the conversation key (`jidToE164(remoteJid)`) — correct whether the earliest record is inbound or an outbound send that stamped the self phone, and needing no runtime self phone at all (so the label is right even before the live connection reports one). A LID-keyed conversation is always inbound-originated, so its earliest record's `senderTelephone` is the contact, never the self phone.
+
+**Historical reconciliation.** Splits created before the canonicalisation fix are collapsed by the one-time `platform/scripts/merge-whatsapp-split-conversations.mjs` — dry-run by default, `--apply` to write, `--account=<uuid>` to scope. It merges each contact's split files into one canonical file (recovering the contact number from the records' resolved `senderTelephone`, with the persisted `whatsapp-lid-map.json` cache as a fallback), idempotent by `messageId`, dropping nothing; it logs per-account merged-file and merged-record counts and asserts one file per contact.
 
 **Search coverage tradeoff.** `/graph`'s BM25/vector search no longer covers WhatsApp message bodies (`graph-search.ts`'s `MESSAGE_FAMILY_LABELS` dropped `WhatsAppMessage`) — this is an accepted, documented consequence of the storage move, not a bug. Every persisted message remains readable via `whatsapp-conversation-graph-state` (all-senders mode) and the `/whatsapp` reader panel's persisted-only rows.
 

package/payload/platform/scripts/merge-whatsapp-split-conversations.mjs

@@ -0,0 +1,264 @@
+#!/usr/bin/env node
+// Task 1412 — one-time on-disk merge: collapse a contact's split WhatsApp store
+// files into one canonical file per contact.
+//
+// WhatsApp addresses one contact by both a linked-identity JID (`<lid>@lid`) and
+// a phone-number JID (`<number>@s.whatsapp.net`). Before the persist-time
+// canonicalisation fix, inbound and in-thread replies accreted under the LID
+// while number-addressed outbound sends echoed under the PN, so one contact's
+// history split across two JSONL files (message-store.ts's per-remoteJid keying).
+// This script reconciles the historical split: for every account it groups the
+// store files by their canonical conversation key and merges each group into the
+// single canonical file, idempotent by `messageId`, dropping nothing.
+//
+// Canonical form matches resolveCanonicalConversationJid (normalize.ts): the
+// phone-number JID when the contact's number is known, else the LID unchanged.
+// Offline (no live Baileys socket) the contact number is recovered from the
+// records themselves — a LID file's inbound records carry the resolved
+// senderTelephone — with the persisted whatsapp-lid-map.json cache as a fallback.
+//
+// Usage:
+//   node platform/scripts/merge-whatsapp-split-conversations.mjs            # dry-run (default)
+//   node platform/scripts/merge-whatsapp-split-conversations.mjs --apply    # write changes
+//   node platform/scripts/merge-whatsapp-split-conversations.mjs --account=<uuid>
+//
+// MAXY_DIR_OVERRIDE overrides the store root (mirrors message-store.ts), used by
+// the verification harness to run against a fixture directory.
+
+import {
+  existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, rmSync, readdirSync,
+} from "node:fs";
+import { join, resolve } from "node:path";
+import { homedir } from "node:os";
+
+const TAG = "[whatsapp-merge-split]";
+
+// ─── Path derivation (mirrors paths.ts / message-store.ts, no app import) ──────
+
+function resolveMaxyDir() {
+  if (process.env.MAXY_DIR_OVERRIDE) return process.env.MAXY_DIR_OVERRIDE;
+  let configDirName = ".maxy";
+  const platformRoot = process.env.MAXY_PLATFORM_ROOT;
+  if (platformRoot) {
+    const brandPath = join(platformRoot, "config", "brand.json");
+    if (existsSync(brandPath)) {
+      try {
+        const brand = JSON.parse(readFileSync(brandPath, "utf-8"));
+        if (typeof brand.configDir === "string") configDirName = brand.configDir;
+      } catch { /* fall through to default */ }
+    }
+  }
+  return resolve(homedir(), configDirName);
+}
+
+const storeRoot = (maxyDir) => join(maxyDir, "data", "whatsapp-messages");
+const lidMapFile = (maxyDir) => join(maxyDir, "whatsapp-lid-map.json");
+
+// ─── Pure JID helpers (semantics match normalize.ts) ───────────────────────────
+
+const PN_RE = /^(\d+)(?::\d+)?@s\.whatsapp\.net$/i;
+const LID_RE = /^(\d+)@lid$/i;
+
+const isLidJid = (jid) => LID_RE.test(jid);
+const isGroupJid = (jid) => /@g\.us$/i.test(jid);
+
+function jidToE164(jid) {
+  const pn = jid.match(PN_RE);
+  if (pn) return pn[1];
+  const lid = jid.match(LID_RE);
+  if (lid) return lid[1];
+  return null;
+}
+
+function normalizeE164(value) {
+  if (typeof value !== "string") return "";
+  let c = value.trim().replace(/[\s\-().]/g, "").replace(/^whatsapp:/i, "");
+  if (c.startsWith("+")) c = c.slice(1);
+  else if (c.startsWith("00")) c = c.slice(2);
+  return /^\d+$/.test(c) ? c : "";
+}
+
+// ─── JSONL IO ──────────────────────────────────────────────────────────────────
+
+function parseLines(raw) {
+  const out = [];
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    try { out.push(JSON.parse(line)); } catch { /* skip corrupt line */ }
+  }
+  return out;
+}
+
+const byDateSentAsc = (a, b) => String(a.dateSent).localeCompare(String(b.dateSent));
+
+function readLidMap(maxyDir) {
+  const file = lidMapFile(maxyDir);
+  try {
+    if (!existsSync(file)) return {};
+    const parsed = JSON.parse(readFileSync(file, "utf-8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+// ─── Canonical target for one file ──────────────────────────────────────────────
+
+/**
+ * The canonical conversation JID a file's records belong under.
+ *   - group JID → itself (single-keyed already; never merged).
+ *   - phone-number JID → itself (already canonical).
+ *   - LID JID → `<pn>@s.whatsapp.net` when the contact's number is recoverable
+ *     (earliest inbound record's resolved senderTelephone, else the lid-map
+ *     cache), matching the persist-time LID→PN resolution; else the LID unchanged.
+ */
+function canonicalTargetFor(remoteJid, records, lidMap) {
+  if (isGroupJid(remoteJid) || !isLidJid(remoteJid)) return remoteJid;
+  const numericLid = jidToE164(remoteJid); // digits of the LID
+  const inbound = records
+    .filter((r) => r.fromMe !== true)
+    .sort(byDateSentAsc);
+  for (const r of inbound) {
+    const phone = normalizeE164(r.senderTelephone);
+    if (phone && phone !== numericLid) return `${phone}@s.whatsapp.net`;
+  }
+  const cached = normalizeE164(lidMap[normalizeE164(numericLid)] ?? "");
+  if (cached && cached !== numericLid) return `${cached}@s.whatsapp.net`;
+  return remoteJid;
+}
+
+// ─── Per-account reconcile ──────────────────────────────────────────────────────
+
+function reconcileAccount(maxyDir, accountId, apply) {
+  const dir = join(storeRoot(maxyDir), accountId);
+  if (!existsSync(dir)) return null;
+
+  const lidMap = readLidMap(maxyDir);
+  const files = readdirSync(dir).filter((e) => e.endsWith(".jsonl"));
+
+  // remoteJid → { records, target }
+  const parsed = new Map();
+  for (const entry of files) {
+    const remoteJid = entry.slice(0, -".jsonl".length);
+    const records = parseLines(readFileSync(join(dir, entry), "utf-8"));
+    parsed.set(remoteJid, { records, target: null });
+  }
+  for (const [remoteJid, info] of parsed) {
+    info.target = canonicalTargetFor(remoteJid, info.records, lidMap);
+  }
+
+  // Group source remoteJids by canonical target.
+  const groups = new Map(); // target → [sourceRemoteJid, ...]
+  for (const [remoteJid, info] of parsed) {
+    if (!groups.has(info.target)) groups.set(info.target, []);
+    groups.get(info.target).push(remoteJid);
+  }
+
+  let mergedGroups = 0;
+  let filesRemoved = 0;
+  let recordsMoved = 0;
+  let recordsDeduped = 0;
+
+  for (const [target, sources] of groups) {
+    // Nothing to do when the only source IS the canonical file already.
+    const nonCanonicalSources = sources.filter((s) => s !== target);
+    if (nonCanonicalSources.length === 0) continue;
+    mergedGroups += 1;
+
+    // Merge every source's records (target file first when it exists) into one
+    // list, dedup by messageId, rewrite remoteJid to the canonical target, sort.
+    const seen = new Set();
+    const merged = [];
+    const ordered = [target, ...nonCanonicalSources].filter((s) => parsed.has(s));
+    for (const src of ordered) {
+      const isMovedSource = src !== target;
+      for (const r of parsed.get(src).records) {
+        if (seen.has(r.messageId)) { recordsDeduped += 1; continue; }
+        seen.add(r.messageId);
+        merged.push({ ...r, remoteJid: target });
+        if (isMovedSource) recordsMoved += 1;
+      }
+    }
+    merged.sort(byDateSentAsc);
+
+    if (apply) {
+      const targetPath = join(dir, `${target}.jsonl`);
+      const tmpPath = `${targetPath}.merge-tmp`;
+      mkdirSync(dir, { recursive: true });
+      // Write the canonical file first, then remove the moved sources — the
+      // canonical copy always exists before any source is deleted, so an
+      // interruption never loses records.
+      writeFileSync(tmpPath, merged.map((r) => JSON.stringify(r)).join("\n") + "\n");
+      renameSync(tmpPath, targetPath);
+      for (const src of nonCanonicalSources) {
+        rmSync(join(dir, `${src}.jsonl`));
+        filesRemoved += 1;
+      }
+    } else {
+      filesRemoved += nonCanonicalSources.length;
+    }
+  }
+
+  // Post-condition: after apply, no two remaining files share a canonical target.
+  const finalFiles = apply
+    ? readdirSync(dir).filter((e) => e.endsWith(".jsonl"))
+    : [...groups.keys()].map((t) => `${t}.jsonl`); // dry-run projected shape
+  const finalTargets = new Set();
+  let residualDuplicates = 0;
+  if (apply) {
+    for (const entry of finalFiles) {
+      const remoteJid = entry.slice(0, -".jsonl".length);
+      const records = parseLines(readFileSync(join(dir, entry), "utf-8"));
+      const t = canonicalTargetFor(remoteJid, records, lidMap);
+      if (finalTargets.has(t)) residualDuplicates += 1;
+      finalTargets.add(t);
+    }
+  }
+
+  return {
+    accountId, filesScanned: files.length, mergedGroups, filesRemoved,
+    recordsMoved, recordsDeduped, finalFileCount: finalFiles.length, residualDuplicates,
+  };
+}
+
+// ─── Main ────────────────────────────────────────────────────────────────────
+
+function main() {
+  const args = process.argv.slice(2);
+  const apply = args.includes("--apply");
+  const accountArg = args.find((a) => a.startsWith("--account="))?.slice("--account=".length) ?? null;
+  const maxyDir = resolveMaxyDir();
+  const root = storeRoot(maxyDir);
+
+  if (!existsSync(root)) {
+    console.log(`${TAG} op=merge mode=${apply ? "apply" : "dry-run"} accounts=0 reason=no-store-root root=${root}`);
+    return;
+  }
+
+  const accounts = accountArg
+    ? [accountArg]
+    : readdirSync(root, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+
+  let totalResidual = 0;
+  for (const accountId of accounts) {
+    const r = reconcileAccount(maxyDir, accountId, apply);
+    if (!r) { console.log(`${TAG} op=merge account=${accountId} skip reason=no-store-dir`); continue; }
+    totalResidual += r.residualDuplicates;
+    console.log(
+      `${TAG} op=merge mode=${apply ? "apply" : "dry-run"} account=${r.accountId} ` +
+      `filesScanned=${r.filesScanned} mergedGroups=${r.mergedGroups} filesRemoved=${r.filesRemoved} ` +
+      `recordsMoved=${r.recordsMoved} recordsDeduped=${r.recordsDeduped} finalFileCount=${r.finalFileCount} ` +
+      `residualDuplicates=${r.residualDuplicates}`,
+    );
+    if (apply && r.residualDuplicates > 0) {
+      console.error(`${TAG} op=merge account=${r.accountId} WARNING residualDuplicates=${r.residualDuplicates} — a contact still spans >1 canonical file`);
+    }
+  }
+
+  if (!apply) {
+    console.log(`${TAG} op=merge dry-run complete — re-run with --apply to write the merges above`);
+  }
+  if (apply && totalResidual > 0) process.exit(1);
+}
+
+main();

package/payload/platform/services/claude-session-manager/dist/http-server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"http-server.d.ts","sourceRoot":"","sources":["../src/http-server.ts"],"names":[],"mappings":"AAqBA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAA;AAe3B,OAAO,EAkBL,KAAK,SAAS,EAEf,MAAM,kBAAkB,CAAA;AA8BzB,OAAO,KAAK,EAAE,SAAS,EAAyB,MAAM,iBAAiB,CAAA;AAEvE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAC1D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAA;AAE3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAA;AAC9D,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AACtD,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAA;AAChE,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAyFlE,eAAO,MAAM,kBAAkB,QAA2B,CAAA;AAS1D,eAAO,MAAM,4BAA4B,QAAS,CAAA;AAIlD,MAAM,WAAW,QAAS,SAAQ,IAAI,CAAC,SAAS,EAAE,gBAAgB,GAAG,SAAS,CAAC;IAC7E;;qEAEiE;IACjE,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,SAAS,CAAA;IAClB,WAAW,EAAE,MAAM,CAAA;IACnB,iBAAiB,EAAE,MAAM,CAAA;IACzB,kBAAkB,EAAE,WAAW,CAAA;IAC/B,eAAe,EAAE,aAAa,CAAA;IAC9B;kFAC8E;IAC9E,WAAW,EAAE,kBAAkB,CAAA;IAC/B;;gFAE4E;IAC5E,cAAc,EAAE,cAAc,CAAA;IAC9B;;;6BAGyB;IACzB,mBAAmB,CAAC,EAAE,mBAAmB,CAAA;IACzC;;;sCAGkC;IAClC,oBAAoB,CAAC,EAAE,oBAAoB,CAAA;IAC3C;;gFAE4E;IAC5E,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAC1B;AAsFD;;;;;;mEAMmE;AACnE,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAiC9D;AAMD;;;;;;iBAMiB;AACjB,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAmCvF;AAID;;;;;;yBAMyB;AACzB,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAiCzD;AAkCD,wBAAgB,eAAe,CAAC,aAAa,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAEpG;AAgBD,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE1D;AAUD,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAMvE;AAMD,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,MAAM,GAAG,IAAI,EACxB,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,MAAM,GAAG,IAAI,GACtB,MAAM,CAER;AAkCD,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAe5F;AAwJD;;;kEAGkE;AAClE,MAAM,MAAM,OAAO,GAAG,IAAI,GAAG;IAC3B,2BAA2B,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACpD;;;+CAG2C;IAC3C,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;CAChD,CAAA;AA8CD,wBAAgB,YAAY,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAoxFpD"}
+{"version":3,"file":"http-server.d.ts","sourceRoot":"","sources":["../src/http-server.ts"],"names":[],"mappings":"AAqBA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAA;AAe3B,OAAO,EAkBL,KAAK,SAAS,EAEf,MAAM,kBAAkB,CAAA;AA8BzB,OAAO,KAAK,EAAE,SAAS,EAAyB,MAAM,iBAAiB,CAAA;AAEvE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAC1D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAA;AAE3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAA;AAC9D,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AACtD,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAA;AAChE,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAyFlE,eAAO,MAAM,kBAAkB,QAA2B,CAAA;AAS1D,eAAO,MAAM,4BAA4B,QAAS,CAAA;AAIlD,MAAM,WAAW,QAAS,SAAQ,IAAI,CAAC,SAAS,EAAE,gBAAgB,GAAG,SAAS,CAAC;IAC7E;;qEAEiE;IACjE,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,SAAS,CAAA;IAClB,WAAW,EAAE,MAAM,CAAA;IACnB,iBAAiB,EAAE,MAAM,CAAA;IACzB,kBAAkB,EAAE,WAAW,CAAA;IAC/B,eAAe,EAAE,aAAa,CAAA;IAC9B;kFAC8E;IAC9E,WAAW,EAAE,kBAAkB,CAAA;IAC/B;;gFAE4E;IAC5E,cAAc,EAAE,cAAc,CAAA;IAC9B;;;6BAGyB;IACzB,mBAAmB,CAAC,EAAE,mBAAmB,CAAA;IACzC;;;sCAGkC;IAClC,oBAAoB,CAAC,EAAE,oBAAoB,CAAA;IAC3C;;gFAE4E;IAC5E,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAC1B;AAsFD;;;;;;mEAMmE;AACnE,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAiC9D;AAMD;;;;;;iBAMiB;AACjB,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAmCvF;AAID;;;;;;yBAMyB;AACzB,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAiCzD;AAkCD,wBAAgB,eAAe,CAAC,aAAa,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAEpG;AAgBD,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE1D;AAUD,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAMvE;AAMD,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,MAAM,GAAG,IAAI,EACxB,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,MAAM,GAAG,IAAI,GACtB,MAAM,CAER;AAkCD,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAe5F;AAwJD;;;kEAGkE;AAClE,MAAM,MAAM,OAAO,GAAG,IAAI,GAAG;IAC3B,2BAA2B,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACpD;;;+CAG2C;IAC3C,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;CAChD,CAAA;AA8CD,wBAAgB,YAAY,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAoyFpD"}

package/payload/platform/services/claude-session-manager/dist/http-server.js

@@ -1468,8 +1468,17 @@ export function buildHttpApp(deps) {
             timed(deps.logger, 'POST', `/${id}/archive`, 404, Date.now() - start);
             return c.json({ error: 'session-not-found' }, 404);
         }
-        const slug = projectSlugForCwd(deps.spawnCwd);
-        const slugDir = join(claudeStateRoot(), 'projects', slug);
+        // Task 1419 — resolve the holding slug the SAME way delete/stop and the
+        // sidebar list do: scan every slug under projects/ for this session's
+        // JSONL (slugForExistingJsonl checks the top level and archive/), falling
+        // back to the boot-cwd slug only when the JSONL exists nowhere. The pre-1357
+        // house-only `projectSlugForCwd(deps.spawnCwd)` 404'd any session whose JSONL
+        // sat under a non-boot slug (e.g. a laptop→Mac migrated `-home-neo-…` session,
+        // Task 1393): the sidebar listed it and its watcher row resolved, but archive
+        // looked under the wrong slug dir and existsSync(fromJsonl) failed. Account/
+        // slug scope is a view filter, not a write gate — this mirrors delete's resolvedSlug.
+        const resolvedSlug = slugForExistingJsonl(deps.claudeConfigDir, row.sessionId) ?? projectSlugForCwd(deps.spawnCwd);
+        const slugDir = join(claudeStateRoot(), 'projects', resolvedSlug);
         const archiveDir = join(slugDir, 'archive');
         const fileName = `${row.sessionId}.jsonl`;
         // Task 260 — refuse archive whenever an alive PTY exists for this
@@ -1486,6 +1495,11 @@ export function buildHttpApp(deps) {
         const fromJsonl = mode === 'archive' ? join(slugDir, fileName) : join(archiveDir, fileName);
         const toJsonl = mode === 'archive' ? join(archiveDir, fileName) : join(slugDir, fileName);
         if (!existsSync(fromJsonl)) {
+            // Task 1419 — attributable not-found on the slug-resolution 404 branch:
+            // name the id, mode, and the slug the scan resolved so a future
+            // occurrence shows which slug was searched vs. where the file actually
+            // is. Previously silent, which is why a mislocated JSONL 404'd with no trace.
+            deps.logger(`archive-not-found sessionId=${row.sessionId.slice(0, 8)} mode=${mode} resolved-slug=${resolvedSlug}`);
             timed(deps.logger, 'POST', `/${id}/archive`, 404, Date.now() - start);
             return c.json({ error: 'session-not-found' }, 404);
         }
@@ -1507,12 +1521,14 @@ export function buildHttpApp(deps) {
         // log line surfaces.
         let sidecarMoved = false;
         try {
+            // Task 1419 — sidecar derives from the resolved slug (not spawnCwd), so
+            // the `.meta.json` travels with the JSONL under whichever slug holds it.
             const fromSidecar = mode === 'archive'
-                ? sidecarPathForSessionId(deps.spawnCwd, row.sessionId)
-                : sidecarPathForSessionId(deps.spawnCwd, row.sessionId, { archived: true });
+                ? sidecarPathForSlug(deps.claudeConfigDir, resolvedSlug, row.sessionId)
+                : sidecarPathForSlug(deps.claudeConfigDir, resolvedSlug, row.sessionId, { archived: true });
             const toSidecar = mode === 'archive'
-                ? sidecarPathForSessionId(deps.spawnCwd, row.sessionId, { archived: true })
-                : sidecarPathForSessionId(deps.spawnCwd, row.sessionId);
+                ? sidecarPathForSlug(deps.claudeConfigDir, resolvedSlug, row.sessionId, { archived: true })
+                : sidecarPathForSlug(deps.claudeConfigDir, resolvedSlug, row.sessionId);
             if (existsSync(fromSidecar)) {
                 renameSync(fromSidecar, toSidecar);
                 sidecarMoved = true;