npm - @rubytech/create-maxy - Versions diffs - 1.0.658 → 1.0.659 - Mend

@rubytech/create-maxy 1.0.658 → 1.0.659

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/package.json +1 -1
package/payload/platform/plugins/cloudflare/scripts/list-cf-domains.ts +115 -61
package/payload/server/server.js +250 -156

package/package.json CHANGED Viewed

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

package/payload/platform/plugins/cloudflare/scripts/list-cf-domains.ts CHANGED Viewed

@@ -363,14 +363,24 @@ export const SCRAPE_EXPRESSION = `(${scrapeCurrentPage.toString()})(document, lo
 // constructing a full CdpClient + WebSocket.
 export type CdpEvaluator = (expression: string) => Promise<unknown>;
-// Number of consecutive polls returning an identical non-empty count that
-// proves the SPA zone-list has finished hydrating. Two iterations at 500 ms
-// each = 1 s of observed stability, which is the empirical ceiling on the
-// CF dashboard's lazy zone-list fetch post-document-ready. Shorter thresholds
-// risk returning a partial list; longer thresholds add user-visible latency
-// without proportional robustness.
+// Trailing-run length (consecutive polls at `max_count`) the complete-line
+// asserts before it declares `unstable=false`. Two iterations at 500 ms each
+// = 1 s of continuous observation at the high-water mark. Task 615 removed
+// the early-exit on this threshold (it shortcuts multi-zone accounts where
+// the first zone hydrates one poll ahead of the second — the plateau at the
+// intermediate count trips the threshold before the final zone arrives);
+// the threshold now only labels the exit, it does not gate it.
 const STABLE_POLL_THRESHOLD = 2;
+// Cap on `document.documentElement.outerHTML` captured into the dump file.
+// The observed Cloudflare dashboard outerHTML is ~1 MB; 5 MB is 5× headroom
+// and still fits comfortably in one `writeFile` syscall on the Pi. Pre-Task
+// 615 this was 100 KB — the dump ended mid-`<head>` CSS on every scrape,
+// rendering the forensic artifact premise of Task 608 silently broken: the
+// zone table lived past the cutoff and `grep <zone-host> <dump>` always
+// returned nothing, forcing re-scrapes to answer post-hoc questions.
+const OUTER_HTML_CAPTURE_MAX_CHARS = 5_000_000;
 // Cap the `domains=[…]` payload on per-poll and complete phase lines. The
 // extractor already implicitly bounds the list via the FQDN regex + Set
 // dedupe, but a pathological CF redesign could emit thousands of href
@@ -386,7 +396,7 @@ function formatDomains(domains: string[]): string {
 }
 type DumpMode = "stable" | "unstable" | "empty-or-drift";
-type DumpResult = { path: string } | { err: string };
+type DumpResult = { path: string; truncated: boolean } | { err: string };
 // Snapshot the operator's current dashboard HTML so post-hoc diagnosis of a
 // partial, unstable, or empty scrape has the exact DOM the scrape observed
@@ -404,7 +414,7 @@ async function dumpHtml(
 ): Promise<DumpResult> {
   try {
     const html = (await evaluator(
-      "document.documentElement.outerHTML.slice(0, 100000)",
+      `document.documentElement.outerHTML.slice(0, ${OUTER_HTML_CAPTURE_MAX_CHARS})`,
     )) as string;
     // CONFIG_DIR is set by list-cf-domains.sh before the spawn. A silent
     // fallback would dump logs into the wrong brand's directory on a Real
@@ -423,8 +433,19 @@ async function dumpHtml(
       logDir,
       `list-cf-domains-${ts}-count${count}-${mode}-pid${process.pid}.html`,
     );
-    await writeFile(dumpPath, typeof html === "string" ? html : String(html), "utf-8");
-    return { path: dumpPath };
+    const htmlStr = typeof html === "string" ? html : String(html);
+    await writeFile(dumpPath, htmlStr, "utf-8");
+    // Heuristic: if the slice returned exactly OUTER_HTML_CAPTURE_MAX_CHARS,
+    // the source outerHTML almost certainly exceeded the cap and we
+    // truncated mid-document. The false positive (outerHTML exactly at the
+    // ceiling) is a rounding coincidence on the order of 1-in-5M and is
+    // acceptable — a loud truncation signal with a ~10^-7 false-positive
+    // rate is strictly better than silent truncation (the pre-Task-615
+    // failure mode at the 100 KB ceiling, which silently broke every scrape
+    // for five months). A downstream investigator seeing `truncated=true`
+    // can re-scrape with a larger cap or `outerHTML` unsliced.
+    const truncated = htmlStr.length >= OUTER_HTML_CAPTURE_MAX_CHARS;
+    return { path: dumpPath, truncated };
   } catch (err) {
     return {
       err: (err instanceof Error ? err.message : String(err)).slice(0, 120),
@@ -437,7 +458,17 @@ async function dumpHtml(
 // complete line terse and routes every failure through the same observation
 // primitive so investigators have one grep pattern for all dump write errors.
 function dumpField(result: DumpResult, mode: DumpMode): string {
-  if ("path" in result) return `dump=${result.path}`;
+  if ("path" in result) {
+    if (result.truncated) {
+      // Loud separate phase line — an investigator grepping for truncation
+      // incidents across the stream log has one exact pattern to match.
+      logPhase(
+        `phase=dump-truncated mode=${mode} path=${result.path} captured_bytes=${OUTER_HTML_CAPTURE_MAX_CHARS}`,
+      );
+      return `dump=${result.path} dump_truncated=true`;
+    }
+    return `dump=${result.path}`;
+  }
   logPhase(
     `phase=dump-write-failed mode=${mode} detail="${result.err.replace(/"/g, "'")}"`,
   );
@@ -446,13 +477,30 @@ function dumpField(result: DumpResult, mode: DumpMode): string {
 export async function scrapeDomains(evaluator: CdpEvaluator): Promise<string[]> {
   const deadline = Date.now() + SCRAPE_POLL_MS;
+  // Task 615: pure poll-to-deadline. The earlier "first N stable polls wins"
+  // heuristic short-circuited on the first plateau a multi-zone dashboard
+  // rendered — a 2-zone account whose second zone hydrates one poll later
+  // than the first would lock `count=1` before the second zone arrived.
+  // Removing early-exit entirely is the only formulation that eliminates the
+  // class: any "N-consec-at-max wins" variant still fires on the intermediate
+  // plateau (`[] [] [a] [a] [a,b] …` → threshold met at poll 4 before zone B
+  // observed). The cost is ~9 s of happy-path latency under the 10 s budget
+  // (still within onboarding tolerance). `max_count` tracks the high-water
+  // count; `consecutiveAtMax` tracks the trailing run at that water-mark;
+  // `seenDecrease` tracks any mid-trajectory count drop. `unstable=false`
+  // requires reaching max, ending at max, at least STABLE_POLL_THRESHOLD
+  // consecutive trailing polls at max, and no mid-trajectory decrease — so a
+  // trajectory like `[a][a][a][a,b]{never reaches 2 consecutive}` correctly
+  // reports `unstable=true` even though `final_count === max_count`.
   let lastOutcome: ScrapeOutcome | null = null;
-  // Track the most recent non-empty observation so deadline-reached without
-  // stability returns the caller's best evidence rather than falling through
-  // to the drift-dump (which is reserved for the always-empty case).
-  let lastNonEmptyDomains: string[] = [];
-  let stableCount = -1;
-  let stableIterations = 0;
+  let maxCount = 0;
+  // Snapshot of the domains array at the most-recent observation of
+  // `maxCount`. Updated on every `>=` poll so it always reflects the latest
+  // capture at the high-water mark; returned at deadline when `maxCount > 0`.
+  let maxDomains: string[] = [];
+  let finalCount = 0;
+  let consecutiveAtMax = 0;
+  let seenDecrease = false;
   let polls = 0;
   while (Date.now() < deadline) {
@@ -460,40 +508,44 @@ export async function scrapeDomains(evaluator: CdpEvaluator): Promise<string[]>
     try {
       const outcome = (await evaluator(SCRAPE_EXPRESSION)) as ScrapeOutcome;
       lastOutcome = outcome;
+      const count = outcome.domains.length;
-      // Per-poll trajectory line (Task 608). Names the exact list captured at
-      // this iteration so a partial-capture scenario (e.g. 2-zone account
-      // rendering count=1 on poll K because zone B has not hydrated yet) is
-      // legible from the stream log alone. Emitted only on successful
-      // evaluator returns — the catch branch emits `phase=scrape-retry`
-      // instead, because "zero observed" and "failed to observe" are
-      // semantically distinct signals for a downstream reader.
       logPhase(
-        `phase=dom-scrape-poll n=${polls} count=${outcome.domains.length} domains=[${formatDomains(outcome.domains)}]`,
+        `phase=dom-scrape-poll n=${polls} count=${count} domains=[${formatDomains(outcome.domains)}]`,
       );
-      if (outcome.reason === "ok" && outcome.domains.length > 0) {
-        lastNonEmptyDomains = outcome.domains;
-        if (outcome.domains.length === stableCount) {
-          stableIterations += 1;
-          if (stableIterations >= STABLE_POLL_THRESHOLD) {
-            const dump = await dumpHtml(evaluator, outcome.domains.length, "stable");
-            logPhase(
-              `phase=dom-scrape-complete result=ok count=${outcome.domains.length} polls=${polls} stable_polls=${stableIterations} unstable=false domains=[${formatDomains(outcome.domains)}] ${dumpField(dump, "stable")}`,
-            );
-            return outcome.domains;
-          }
+      if (outcome.reason === "ok" && count > 0) {
+        if (count > maxCount) {
+          // New high-water mark. Post-stable increases reset the run counter —
+          // the new stable window must also satisfy the threshold to qualify
+          // as `unstable=false`.
+          maxCount = count;
+          maxDomains = outcome.domains;
+          consecutiveAtMax = 1;
+        } else if (count === maxCount) {
+          maxDomains = outcome.domains;
+          consecutiveAtMax += 1;
         } else {
-          stableCount = outcome.domains.length;
-          stableIterations = 1;
+          // count > 0 && count < maxCount — the page shrunk mid-poll
+          // (virtual-scroll pagination, zone deletion concurrent with scrape,
+          // SPA re-render collapsing rows). Preserve the high-water snapshot;
+          // flag the trajectory as unstable.
+          seenDecrease = true;
+          consecutiveAtMax = 0;
         }
+        finalCount = count;
       } else {
-        // `ok` with zero domains OR a non-ok reason: treat as still-hydrating.
-        // Keep polling; the final iteration's zero result is the empty-account
-        // signal. Reset stability tracking so a 0 → N → 0 sequence doesn't
-        // falsely satisfy the threshold.
-        stableCount = -1;
-        stableIterations = 0;
+        // Empty poll or non-ok reason (no-account-id — SPA mid-navigation):
+        // the page momentarily showed no zones, breaking any trailing at-max
+        // run. Don't flip `seenDecrease` — treating a hydration gap as a
+        // "shrink" would be a false positive on the leading empty polls of
+        // every scrape. `finalCount` reflects the last poll's observed count
+        // (always 0 in this branch, since `scrapeCurrentPage` returns empty
+        // domains on any non-ok reason), so the stream log's `final_count`
+        // field accurately names what the last poll saw, not a stale value
+        // from an earlier successful observation.
+        consecutiveAtMax = 0;
+        finalCount = count;
       }
     } catch (err) {
       logPhase(
@@ -503,31 +555,33 @@ export async function scrapeDomains(evaluator: CdpEvaluator): Promise<string[]>
     await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
   }
-  // Deadline reached. Two distinct branches:
+  // Deadline reached. Two branches:
   //
-  // (i) We saw non-empty results but they never stabilised across two
-  //     consecutive polls — the page is either paginating or re-rendering
-  //     the zone list. Return the last non-empty observation, flag
-  //     `unstable=true` on the phase line, and snapshot the DOM so
-  //     partial-capture-that-also-races is diagnosable (Task 608 extends
-  //     the dump to this path — pre-task, only empty-or-drift dumped).
+  // (i) We observed at least one non-empty poll. Return the max-count
+  //     snapshot (which, when `finalCount === maxCount`, is also the last
+  //     non-empty observation). `unstable=true` whenever any signal suggests
+  //     the page wasn't settled: shrinkage, end-below-max, or fewer than
+  //     STABLE_POLL_THRESHOLD consecutive trailing polls at max.
   //
-  // (ii) We never saw non-empty results — this is either a genuinely empty
-  //      account OR CF has drifted the href URL shape so Source A yields
-  //      nothing. The `empty-or-drift` body-dump branch snapshots the page
-  //      HTML so the operator can distinguish the two by inspecting the
-  //      dump file.
-  if (lastNonEmptyDomains.length > 0) {
-    const dump = await dumpHtml(evaluator, lastNonEmptyDomains.length, "unstable");
+  // (ii) Every poll was empty — either a genuinely empty account OR CF
+  //      drifted the href shape. The `empty-or-drift` dump is the operator's
+  //      single-artifact signal for distinguishing the two.
+  if (maxCount > 0) {
+    const unstable =
+      seenDecrease ||
+      finalCount !== maxCount ||
+      consecutiveAtMax < STABLE_POLL_THRESHOLD;
+    const mode: DumpMode = unstable ? "unstable" : "stable";
+    const dump = await dumpHtml(evaluator, maxCount, mode);
     logPhase(
-      `phase=dom-scrape-complete result=ok count=${lastNonEmptyDomains.length} polls=${polls} stable_polls=${stableIterations} unstable=true domains=[${formatDomains(lastNonEmptyDomains)}] ${dumpField(dump, "unstable")}`,
+      `phase=dom-scrape-complete result=ok count=${maxCount} total_polls=${polls} max_count=${maxCount} final_count=${finalCount} stable_polls=${consecutiveAtMax} unstable=${unstable} domains=[${formatDomains(maxDomains)}] ${dumpField(dump, mode)}`,
     );
-    return lastNonEmptyDomains;
+    return maxDomains;
   }
   const dump = await dumpHtml(evaluator, 0, "empty-or-drift");
   logPhase(
-    `phase=dom-scrape-complete result=empty-or-drift count=0 polls=${polls} lastReason=${lastOutcome?.reason ?? "unknown"} ${dumpField(dump, "empty-or-drift")}`,
+    `phase=dom-scrape-complete result=empty-or-drift count=0 total_polls=${polls} max_count=0 final_count=0 stable_polls=0 lastReason=${lastOutcome?.reason ?? "unknown"} ${dumpField(dump, "empty-or-drift")}`,
   );
   return [];
 }

package/payload/server/server.js CHANGED Viewed

@@ -20254,8 +20254,236 @@ function resolveDataPath(raw2) {
   return { ok: true, absolute: resolvedReal, dataRootReal, relative: relPath };
 }
-// server/routes/admin/files.ts
+// ../lib/graph-trash/src/index.ts
+var UNIQUE_KEYS_BY_LABEL = {
+  Person: ["email", "telephone"],
+  Service: ["serviceId"],
+  LocalBusiness: ["accountId"],
+  Task: ["taskId"],
+  Event: ["eventId"],
+  KnowledgeDocument: ["attachmentId"],
+  DigitalDocument: ["attachmentId"],
+  Conversation: ["conversationId", "sessionKey"],
+  Message: ["messageId"],
+  OnboardingState: ["accountId"],
+  Workflow: ["workflowId"],
+  WorkflowStep: ["stepId"],
+  WorkflowRun: ["runId"],
+  Preference: ["preferenceId"],
+  Email: ["emailId", "messageId"],
+  AdminUser: ["userId"],
+  ToolCall: ["callId"],
+  // Composite component nulls — frees the composite constraint:
+  AccessGrant: ["contactValue"],
+  // composite (contactValue, agentSlug, accountId)
+  UserProfile: ["userId"]
+  // composite (accountId, userId)
+};
+async function trashNode(params) {
+  const { session, accountId, elementId, by, reason } = params;
+  const lookup = await session.run(
+    `MATCH (n) WHERE elementId(n) = $eid AND n.accountId = $accountId
+     RETURN labels(n) AS labels, properties(n) AS props`,
+    { eid: elementId, accountId }
+  );
+  if (lookup.records.length === 0) {
+    throw new Error(
+      `trashNode: node not found (elementId=${elementId} accountId=${accountId.slice(0, 8)}\u2026)`
+    );
+  }
+  const allLabels = lookup.records[0].get("labels");
+  const props = lookup.records[0].get("props");
+  const baseLabels = allLabels.filter((l) => l !== "Trashed");
+  if (allLabels.includes("Trashed")) {
+    return {
+      trashed: false,
+      alreadyTrashed: true,
+      nodeId: elementId,
+      labels: baseLabels,
+      trashedAt: String(props.trashedAt ?? ""),
+      originalKeys: {}
+    };
+  }
+  const uniqueKeys = /* @__PURE__ */ new Set();
+  for (const label of baseLabels) {
+    for (const key of UNIQUE_KEYS_BY_LABEL[label] ?? []) uniqueKeys.add(key);
+  }
+  const originalKeys = {};
+  for (const k of uniqueKeys) {
+    if (props[k] !== void 0 && props[k] !== null) originalKeys[k] = props[k];
+  }
+  const setNullClauses = Object.keys(originalKeys).map((k) => `n.\`${k}\` = null`).join(", ");
+  const setNullSuffix = setNullClauses ? `, ${setNullClauses}` : "";
+  const trashedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await session.run(
+    `MATCH (n) WHERE elementId(n) = $eid
+     SET n:Trashed,
+         n.trashedAt = datetime($trashedAt),
+         n.trashedBy = $by,
+         n.trashReason = $reason,
+         n._trashedKeys = $trashedKeysJson${setNullSuffix}`,
+    {
+      eid: elementId,
+      trashedAt,
+      by,
+      reason: reason ?? null,
+      trashedKeysJson: JSON.stringify(originalKeys)
+    }
+  );
+  process.stderr.write(
+    `[trash:marked] accountId=${accountId} elementId=${elementId} labels=${baseLabels.join(",")} by=${by} reason=${reason ?? "null"}
+`
+  );
+  return {
+    trashed: true,
+    alreadyTrashed: false,
+    nodeId: elementId,
+    labels: baseLabels,
+    trashedAt,
+    originalKeys
+  };
+}
+async function restoreNode(params) {
+  const { session, accountId, elementId } = params;
+  const lookup = await session.run(
+    `MATCH (n:Trashed) WHERE elementId(n) = $eid
+     RETURN labels(n) AS labels, n._trashedKeys AS keysJson`,
+    { eid: elementId }
+  );
+  if (lookup.records.length === 0) {
+    throw new Error(
+      `restoreNode: trashed node not found (elementId=${elementId})`
+    );
+  }
+  const allLabels = lookup.records[0].get("labels");
+  const baseLabels = allLabels.filter((l) => l !== "Trashed");
+  const keysJson = lookup.records[0].get("keysJson");
+  const originalKeys = keysJson ? JSON.parse(keysJson) : {};
+  for (const label of baseLabels) {
+    const uniqueKeys = UNIQUE_KEYS_BY_LABEL[label] ?? [];
+    for (const k of uniqueKeys) {
+      const v = originalKeys[k];
+      if (v === void 0 || v === null) continue;
+      const conflict = await session.run(
+        `MATCH (other:\`${label}\`)
+         WHERE elementId(other) <> $eid
+           AND NOT other:Trashed
+           AND other.\`${k}\` = $val
+         RETURN elementId(other) AS otherId LIMIT 1`,
+        { eid: elementId, val: v }
+      );
+      if (conflict.records.length > 0) {
+        const otherId = conflict.records[0].get("otherId");
+        throw new Error(
+          `restoreNode: cannot restore ${label} elementId=${elementId} \u2014 active node elementId=${otherId} already holds ${k}=${JSON.stringify(v)}`
+        );
+      }
+    }
+  }
+  const setClauses = Object.keys(originalKeys).map((k) => `n.\`${k}\` = $val_${k}`).join(", ");
+  const setSuffix = setClauses ? `, ${setClauses}` : "";
+  const setParams = { eid: elementId };
+  for (const [k, v] of Object.entries(originalKeys)) setParams[`val_${k}`] = v;
+  await session.run(
+    `MATCH (n:Trashed) WHERE elementId(n) = $eid
+     REMOVE n:Trashed, n.trashedAt, n.trashedBy, n.trashReason, n._trashedKeys
+     SET n.restoredAt = datetime()${setSuffix}`,
+    setParams
+  );
+  process.stderr.write(
+    `[trash:restored] accountId=${accountId} elementId=${elementId} labels=${baseLabels.join(",")}
+`
+  );
+  return {
+    restored: true,
+    nodeId: elementId,
+    labels: baseLabels,
+    restoredKeys: originalKeys
+  };
+}
+// app/lib/file-delete-cascade.ts
 var UUID_RE2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function parseAttachmentPath(relPath) {
+  const segments = relPath.split("/").filter(Boolean);
+  if (segments.length !== 4) return null;
+  if (segments[0] !== "uploads") return null;
+  const accountId = segments[1];
+  const attachmentId = segments[2];
+  const filename = segments[3];
+  if (!UUID_RE2.test(accountId) || !UUID_RE2.test(attachmentId)) return null;
+  const dot = filename.lastIndexOf(".");
+  if (dot === -1) return null;
+  const stem = filename.slice(0, dot);
+  const ext = filename.slice(dot + 1);
+  if (stem !== attachmentId) return null;
+  if (ext === "meta" || filename.endsWith(".meta.json")) return null;
+  return { accountId, attachmentId };
+}
+async function cascadeDeleteDocument(params) {
+  const { accountId, attachmentId } = params;
+  const session = getSession();
+  try {
+    const lookup = await session.run(
+      `MATCH (d:KnowledgeDocument { accountId: $accountId, attachmentId: $attachmentId })
+       WHERE NOT d:Trashed
+       RETURN elementId(d) AS eid LIMIT 1`,
+      { accountId, attachmentId }
+    );
+    if (lookup.records.length === 0) return { nodes: 0 };
+    const docElementId = lookup.records[0].get("eid");
+    const childResult = await session.run(
+      `MATCH (d) WHERE elementId(d) = $eid
+       OPTIONAL MATCH (d)-[:HAS_SECTION]->(s:Section)
+       OPTIONAL MATCH (s)-[:HAS_CHUNK]->(c:Chunk)
+       WITH collect(DISTINCT s) AS sections, collect(DISTINCT c) AS chunks
+       RETURN [s IN sections WHERE s IS NOT NULL | elementId(s)] AS sectionIds,
+              [c IN chunks   WHERE c IS NOT NULL | elementId(c)] AS chunkIds`,
+      { eid: docElementId }
+    );
+    if (childResult.records.length === 0) {
+      throw new Error(
+        `cascadeDeleteDocument: child lookup returned zero rows for elementId=${docElementId} \u2014 concurrent trash or connection drop`
+      );
+    }
+    const sectionIds = childResult.records[0].get("sectionIds") ?? [];
+    const chunkIds = childResult.records[0].get("chunkIds") ?? [];
+    await trashNode({
+      session,
+      accountId,
+      elementId: docElementId,
+      by: "file-delete-cascade",
+      reason: "file deleted via /data"
+    });
+    for (const sid of sectionIds) {
+      await trashNode({
+        session,
+        accountId,
+        elementId: sid,
+        by: `file-delete-cascade:from-${docElementId}`,
+        reason: `cascade from KnowledgeDocument ${docElementId}`
+      });
+    }
+    for (const cid of chunkIds) {
+      await trashNode({
+        session,
+        accountId,
+        elementId: cid,
+        by: `file-delete-cascade:from-${docElementId}`,
+        reason: `cascade from KnowledgeDocument ${docElementId}`
+      });
+    }
+    return { nodes: 1 };
+  } finally {
+    try {
+      await session.close();
+    } catch {
+    }
+  }
+}
+// server/routes/admin/files.ts
+var UUID_RE3 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 async function readMeta(absDir, baseName) {
   try {
     const raw2 = await readFile4(join12(absDir, `${baseName}.meta.json`), "utf8");
@@ -20277,7 +20505,7 @@ async function readAccountNames() {
     return map;
   }
   for (const name of names) {
-    if (!UUID_RE2.test(name)) continue;
+    if (!UUID_RE3.test(name)) continue;
     const configPath2 = resolve29(accountsDir, name, "account.json");
     try {
       const raw2 = await readFile4(configPath2, "utf8");
@@ -20295,7 +20523,7 @@ async function readAccountNames() {
   return map;
 }
 async function enrich(absolute, entry, accountNames) {
-  if (entry.kind === "directory" && UUID_RE2.test(entry.name)) {
+  if (entry.kind === "directory" && UUID_RE3.test(entry.name)) {
     const meta = await readMeta(join12(absolute, entry.name), entry.name);
     if (meta?.filename) {
       entry.displayName = meta.filename;
@@ -20311,7 +20539,7 @@ async function enrich(absolute, entry, accountNames) {
   if (entry.kind === "file") {
     const dot = entry.name.lastIndexOf(".");
     const base = dot === -1 ? entry.name : entry.name.slice(0, dot);
-    if (UUID_RE2.test(base)) {
+    if (UUID_RE3.test(base)) {
       const meta = await readMeta(absolute, base);
       if (meta?.filename) {
         entry.displayName = meta.filename;
@@ -20323,7 +20551,7 @@ async function enrich(absolute, entry, accountNames) {
 function buildDisplayPath(relPath, accountNames) {
   if (relPath === "." || relPath === "") return [];
   return relPath.split("/").filter(Boolean).map((seg) => {
-    const dn = UUID_RE2.test(seg) ? accountNames.get(seg) : void 0;
+    const dn = UUID_RE3.test(seg) ? accountNames.get(seg) : void 0;
     return dn ? { name: seg, displayName: dn } : { name: seg };
   });
 }
@@ -20351,7 +20579,7 @@ app24.get("/", requireAdminSession, async (c) => {
     const names = await readdir2(absolute);
     const entries = [];
     for (const name of names) {
-      if (UUID_RE2.test(name.replace(/\.meta\.json$/, "")) && name.endsWith(".meta.json")) {
+      if (UUID_RE3.test(name.replace(/\.meta\.json$/, "")) && name.endsWith(".meta.json")) {
         continue;
       }
       try {
@@ -20497,7 +20725,8 @@ app24.post("/upload", requireAdminSession, async (c) => {
 });
 app24.delete("/", requireAdminSession, async (c) => {
   const sessionKey = c.var.sessionKey;
-  if (!getAccountIdForSession(sessionKey)) {
+  const accountId = getAccountIdForSession(sessionKey);
+  if (!accountId) {
     console.error(`[data] auth-rejected endpoint="DELETE /api/admin/files" reason="no account for session"`);
     return c.json({ error: "Account not found for session" }, 401);
   }
@@ -20527,7 +20756,7 @@ app24.delete("/", requireAdminSession, async (c) => {
     }
     const dot = base.lastIndexOf(".");
     const stem = dot === -1 ? base : base.slice(0, dot);
-    const sidecarPath = UUID_RE2.test(stem) && base !== `${stem}.meta.json` ? join12(dirname10(absolute), `${stem}.meta.json`) : null;
+    const sidecarPath = UUID_RE3.test(stem) && base !== `${stem}.meta.json` ? join12(dirname10(absolute), `${stem}.meta.json`) : null;
     await unlink2(absolute);
     if (sidecarPath) {
       try {
@@ -20536,6 +20765,19 @@ app24.delete("/", requireAdminSession, async (c) => {
       }
     }
     console.error(`[data] file-delete path="${relPath}" bytes=${info.size}`);
+    const parsed = parseAttachmentPath(relPath);
+    if (parsed) {
+      try {
+        const { nodes } = await cascadeDeleteDocument({
+          accountId,
+          attachmentId: parsed.attachmentId
+        });
+        console.error(`[data] file-delete graph-cascade path="${relPath}" nodes=${nodes}`);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`[data] file-delete graph-cascade-failed path="${relPath}" err="${message}"`);
+      }
+    }
     return c.json({ ok: true });
   } catch (err) {
     const code = err.code;
@@ -20884,154 +21126,6 @@ function pruneNode(node) {
 }
 var graph_subgraph_default = app26;
-// ../lib/graph-trash/src/index.ts
-var UNIQUE_KEYS_BY_LABEL = {
-  Person: ["email", "telephone"],
-  Service: ["serviceId"],
-  LocalBusiness: ["accountId"],
-  Task: ["taskId"],
-  Event: ["eventId"],
-  KnowledgeDocument: ["attachmentId"],
-  DigitalDocument: ["attachmentId"],
-  Conversation: ["conversationId", "sessionKey"],
-  Message: ["messageId"],
-  OnboardingState: ["accountId"],
-  Workflow: ["workflowId"],
-  WorkflowStep: ["stepId"],
-  WorkflowRun: ["runId"],
-  Preference: ["preferenceId"],
-  Email: ["emailId", "messageId"],
-  AdminUser: ["userId"],
-  ToolCall: ["callId"],
-  // Composite component nulls — frees the composite constraint:
-  AccessGrant: ["contactValue"],
-  // composite (contactValue, agentSlug, accountId)
-  UserProfile: ["userId"]
-  // composite (accountId, userId)
-};
-async function trashNode(params) {
-  const { session, accountId, elementId, by, reason } = params;
-  const lookup = await session.run(
-    `MATCH (n) WHERE elementId(n) = $eid AND n.accountId = $accountId
-     RETURN labels(n) AS labels, properties(n) AS props`,
-    { eid: elementId, accountId }
-  );
-  if (lookup.records.length === 0) {
-    throw new Error(
-      `trashNode: node not found (elementId=${elementId} accountId=${accountId.slice(0, 8)}\u2026)`
-    );
-  }
-  const allLabels = lookup.records[0].get("labels");
-  const props = lookup.records[0].get("props");
-  const baseLabels = allLabels.filter((l) => l !== "Trashed");
-  if (allLabels.includes("Trashed")) {
-    return {
-      trashed: false,
-      alreadyTrashed: true,
-      nodeId: elementId,
-      labels: baseLabels,
-      trashedAt: String(props.trashedAt ?? ""),
-      originalKeys: {}
-    };
-  }
-  const uniqueKeys = /* @__PURE__ */ new Set();
-  for (const label of baseLabels) {
-    for (const key of UNIQUE_KEYS_BY_LABEL[label] ?? []) uniqueKeys.add(key);
-  }
-  const originalKeys = {};
-  for (const k of uniqueKeys) {
-    if (props[k] !== void 0 && props[k] !== null) originalKeys[k] = props[k];
-  }
-  const setNullClauses = Object.keys(originalKeys).map((k) => `n.\`${k}\` = null`).join(", ");
-  const setNullSuffix = setNullClauses ? `, ${setNullClauses}` : "";
-  const trashedAt = (/* @__PURE__ */ new Date()).toISOString();
-  await session.run(
-    `MATCH (n) WHERE elementId(n) = $eid
-     SET n:Trashed,
-         n.trashedAt = datetime($trashedAt),
-         n.trashedBy = $by,
-         n.trashReason = $reason,
-         n._trashedKeys = $trashedKeysJson${setNullSuffix}`,
-    {
-      eid: elementId,
-      trashedAt,
-      by,
-      reason: reason ?? null,
-      trashedKeysJson: JSON.stringify(originalKeys)
-    }
-  );
-  process.stderr.write(
-    `[trash:marked] accountId=${accountId} elementId=${elementId} labels=${baseLabels.join(",")} by=${by} reason=${reason ?? "null"}
-`
-  );
-  return {
-    trashed: true,
-    alreadyTrashed: false,
-    nodeId: elementId,
-    labels: baseLabels,
-    trashedAt,
-    originalKeys
-  };
-}
-async function restoreNode(params) {
-  const { session, accountId, elementId } = params;
-  const lookup = await session.run(
-    `MATCH (n:Trashed) WHERE elementId(n) = $eid
-     RETURN labels(n) AS labels, n._trashedKeys AS keysJson`,
-    { eid: elementId }
-  );
-  if (lookup.records.length === 0) {
-    throw new Error(
-      `restoreNode: trashed node not found (elementId=${elementId})`
-    );
-  }
-  const allLabels = lookup.records[0].get("labels");
-  const baseLabels = allLabels.filter((l) => l !== "Trashed");
-  const keysJson = lookup.records[0].get("keysJson");
-  const originalKeys = keysJson ? JSON.parse(keysJson) : {};
-  for (const label of baseLabels) {
-    const uniqueKeys = UNIQUE_KEYS_BY_LABEL[label] ?? [];
-    for (const k of uniqueKeys) {
-      const v = originalKeys[k];
-      if (v === void 0 || v === null) continue;
-      const conflict = await session.run(
-        `MATCH (other:\`${label}\`)
-         WHERE elementId(other) <> $eid
-           AND NOT other:Trashed
-           AND other.\`${k}\` = $val
-         RETURN elementId(other) AS otherId LIMIT 1`,
-        { eid: elementId, val: v }
-      );
-      if (conflict.records.length > 0) {
-        const otherId = conflict.records[0].get("otherId");
-        throw new Error(
-          `restoreNode: cannot restore ${label} elementId=${elementId} \u2014 active node elementId=${otherId} already holds ${k}=${JSON.stringify(v)}`
-        );
-      }
-    }
-  }
-  const setClauses = Object.keys(originalKeys).map((k) => `n.\`${k}\` = $val_${k}`).join(", ");
-  const setSuffix = setClauses ? `, ${setClauses}` : "";
-  const setParams = { eid: elementId };
-  for (const [k, v] of Object.entries(originalKeys)) setParams[`val_${k}`] = v;
-  await session.run(
-    `MATCH (n:Trashed) WHERE elementId(n) = $eid
-     REMOVE n:Trashed, n.trashedAt, n.trashedBy, n.trashReason, n._trashedKeys
-     SET n.restoredAt = datetime()${setSuffix}`,
-    setParams
-  );
-  process.stderr.write(
-    `[trash:restored] accountId=${accountId} elementId=${elementId} labels=${baseLabels.join(",")}
-`
-  );
-  return {
-    restored: true,
-    nodeId: elementId,
-    labels: baseLabels,
-    restoredKeys: originalKeys
-  };
-}
 // server/routes/admin/graph-delete.ts
 var app27 = new Hono2();
 app27.post("/", requireAdminSession, async (c) => {