@rubytech/create-maxy-code 0.1.33 → 0.1.35

package/payload/server/{chunk-KVGTWNKQ.js → chunk-NNHHGQJL.js}

@@ -229,7 +229,7 @@ async function persistMessage(conversationId, role, content, accountId, tokens,
        OPTIONAL MATCH (tail:Message)-[:PART_OF]->(c)
          WHERE NOT (tail)-[:NEXT]->(:Message)
            AND (tail:UserMessage OR tail:AssistantMessage)
-       // Task 857 \u2014 sublabel-scope the tail to the agent-path's own sublabels.
+       // sublabel-scope the tail to the agent-path's own sublabels.
        // Without this, a Task-857 :WhatsAppMessage row (no outgoing :NEXT)
        // would be picked as tail and the agent-path would chain
        // :WhatsAppMessage\u2192:UserMessage, crossing the live-channel chain.
@@ -277,7 +277,7 @@ async function persistMessage(conversationId, role, content, accountId, tokens,
            textOffset: comp.textOffset,
            submitted: false,
            createdAt: datetime(),
-           // Task 942 \u2014 store the artefact attachmentId on the :Component
+           // store the artefact attachmentId on the:Component
            // itself when this is a PERSISTENT_COMPONENTS write whose disk
            // write succeeded. Field is null for non-persistent / mime-skip
            // / disk-fail components. Lets the audit + backfill scripts
@@ -288,7 +288,7 @@ async function persistMessage(conversationId, role, content, accountId, tokens,
            attachmentId: comp.artefactAttachmentId
          })
        )
-       // Task 942 \u2014 for PERSISTENT_COMPONENTS whose disk write succeeded
+       // for PERSISTENT_COMPONENTS whose disk write succeeded
        // (artefactAttachmentId is non-null), MERGE the sibling
        // :KnowledgeDocument projection AND a :HAS_KNOWLEDGE_DOCUMENT edge
        // from the parent :Message in the same Cypher tx. ON CREATE stamps
@@ -346,13 +346,13 @@ async function persistMessage(conversationId, role, content, accountId, tokens,
           data: comp.data,
           ordinal: neo4j.int(comp.ordinal),
           textOffset: neo4j.int(comp.textOffset),
-          // Task 942 — null for non-persistent / mime-skip / disk-fail
+          // null for non-persistent / mime-skip / disk-fail
           // components; the FOREACH stamps this directly onto the
           // :Component row so audit + backfill read attachmentId without
           // re-deriving from componentId.
           artefactAttachmentId: comp.artefactAttachmentId ?? null
         })),
-        // Task 942 — :KnowledgeDocument MERGE list. One row per
+        //:KnowledgeDocument MERGE list. One row per
         // PERSISTENT_COMPONENTS component whose disk write succeeded;
         // text-only / mime-skip / disk-fail components are absent so
         // the FOREACH no-ops on them. attachmentId here matches the
@@ -860,6 +860,10 @@ async function renameConversation(conversationId, label) {
     await session.close();
   }
 }
+var DECAY_THRESHOLD_DAYS = 14;
+var DECAY_RATE_PER_DAY = 0.05;
+var INJECTION_THRESHOLD = 0.4;
+var MAX_SUMMARY_PREFERENCES = 30;
 async function getUserTimezone(accountId, userId) {
   const session = getSession();
   try {
@@ -968,6 +972,14 @@ async function writeAdminUserAndPerson(params) {
     await session.close();
   }
 }
+var PROFILE_CATEGORIES = [
+  "communication",
+  "scheduling",
+  "decision",
+  "workflow",
+  "content",
+  "interaction"
+];
 var PROFILE_FIELD_TEMPLATES = {
   communication: [
     "preferredChannel",
@@ -1014,6 +1026,302 @@ var TOTAL_PROFILE_FIELDS = Object.values(PROFILE_FIELD_TEMPLATES).reduce(
   (n, fs) => n + fs.length,
   0
 );
+function computeAbsentFields(preferences, extraTemplates = {}) {
+  const covered = /* @__PURE__ */ new Set();
+  for (const pref of preferences) {
+    const isCovered = pref.notApplicable === true || pref.confidence >= INJECTION_THRESHOLD;
+    if (isCovered) covered.add(`${pref.category}.${pref.key}`);
+  }
+  const absent = [];
+  for (const [category, fields] of Object.entries(PROFILE_FIELD_TEMPLATES)) {
+    for (const field of fields) {
+      const dotted = `${category}.${field}`;
+      if (!covered.has(dotted)) absent.push(dotted);
+    }
+  }
+  for (const [category, fields] of Object.entries(extraTemplates)) {
+    if (category in PROFILE_FIELD_TEMPLATES) continue;
+    for (const field of fields) {
+      const dotted = `${category}.${field}`;
+      if (!covered.has(dotted)) absent.push(dotted);
+    }
+  }
+  return absent;
+}
+function parsePluginProfileKeys(manifest) {
+  const fm = manifest.match(/^---\n([\s\S]*?)\n---/);
+  if (!fm) return [];
+  const out = [];
+  let inBlock = false;
+  for (const line of fm[1].split("\n")) {
+    if (/^profileKeys:/.test(line)) {
+      inBlock = true;
+      continue;
+    }
+    if (inBlock) {
+      const m = line.match(/^\s+-\s+(.+?)\s*$/);
+      if (m) out.push(m[1]);
+      else break;
+    }
+  }
+  return out;
+}
+function loadEnabledPluginProfileKeys(accountId) {
+  const accountFile = resolve(PLATFORM_ROOT, "..", "data/accounts", accountId, "account.json");
+  if (!existsSync(accountFile)) return {};
+  let enabled;
+  try {
+    const raw = readFileSync(accountFile, "utf-8");
+    const parsed = JSON.parse(raw);
+    enabled = Array.isArray(parsed.enabledPlugins) ? parsed.enabledPlugins.filter((p) => typeof p === "string") : [];
+  } catch (err) {
+    console.error(
+      `[profile-keys] account.json read failed for ${accountId.slice(0, 8)}\u2026: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return {};
+  }
+  const merged = {};
+  for (const pluginName of enabled) {
+    const manifestPath = resolve(PLATFORM_ROOT, "plugins", pluginName, "PLUGIN.md");
+    if (!existsSync(manifestPath)) continue;
+    let manifest;
+    try {
+      manifest = readFileSync(manifestPath, "utf-8");
+    } catch {
+      continue;
+    }
+    for (const dotted of parsePluginProfileKeys(manifest)) {
+      const dot = dotted.indexOf(".");
+      if (dot <= 0 || dot === dotted.length - 1) {
+        console.error(`[profile-keys] malformed dotted key in ${pluginName}: ${dotted}`);
+        continue;
+      }
+      const category = dotted.slice(0, dot);
+      const key = dotted.slice(dot + 1);
+      if (!merged[category]) merged[category] = /* @__PURE__ */ new Set();
+      merged[category].add(key);
+    }
+  }
+  const out = {};
+  for (const [cat, set] of Object.entries(merged)) out[cat] = [...set];
+  return out;
+}
+var sparseStateLogged = /* @__PURE__ */ new Set();
+async function loadUserProfile(accountId, userId, conversationId) {
+  console.error(
+    `[profile] loadUserProfile entry accountId=${accountId.slice(0, 8)}\u2026 userId=${userId} conversationId=${conversationId ? `${conversationId.slice(0, 8)}\u2026` : "<none>"}`
+  );
+  const session = getSession();
+  try {
+    const serverTimezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    const mergeResult = await session.run(
+      `MATCH (au:AdminUser {userId: $userId})
+       MERGE (au)-[:HAS_PROFILE]->(up:UserProfile {accountId: $accountId, userId: $userId})
+       ON CREATE SET
+         up.createdAt = $now,
+         up.updatedAt = $now,
+         up.profileVersion = 0,
+         up.scope = 'admin',
+         up.timezone = $serverTimezone
+       ON MATCH SET
+         up.timezone = CASE WHEN up.timezone IS NULL OR trim(up.timezone) = '' THEN $serverTimezone ELSE up.timezone END
+       RETURN up.createdAt = $now AS isNew`,
+      { accountId, userId, now: (/* @__PURE__ */ new Date()).toISOString(), serverTimezone }
+    );
+    if (mergeResult.records.length === 0) {
+      console.error(`[profile] loadUserProfile: AdminUser not found for userId=${userId} accountId=${accountId.slice(0, 8)}\u2026 \u2014 profile not created, invariant violated`);
+      return null;
+    }
+    const isNew = mergeResult.records[0].get("isNew");
+    if (isNew) {
+      console.error(`[profile] created new profile: userId=${userId} accountId=${accountId.slice(0, 8)}\u2026 timezone=${serverTimezone}`);
+    }
+    const nowMs = Date.now();
+    const thresholdMs = DECAY_THRESHOLD_DAYS * 24 * 60 * 60 * 1e3;
+    const staleResult = await session.run(
+      `MATCH (up:UserProfile {accountId: $accountId, userId: $userId})-[:HAS_PREFERENCE]->(pref:Preference)
+       WHERE pref.observedAt IS NOT NULL
+       RETURN pref.preferenceId AS preferenceId,
+              pref.observedAt AS observedAt,
+              pref.confidence AS confidence`,
+      { accountId, userId }
+    );
+    let decayCount = 0;
+    for (const record of staleResult.records) {
+      const observedAt = record.get("observedAt");
+      const confidence = record.get("confidence");
+      const observedMs = new Date(observedAt).getTime();
+      const ageMs = nowMs - observedMs;
+      if (ageMs > thresholdMs && confidence > 0) {
+        const daysPastThreshold = (ageMs - thresholdMs) / (24 * 60 * 60 * 1e3);
+        const decayedConfidence = Math.max(0, confidence - DECAY_RATE_PER_DAY * daysPastThreshold);
+        if (decayedConfidence !== confidence) {
+          await session.run(
+            `MATCH (pref:Preference {preferenceId: $preferenceId, accountId: $accountId})
+             SET pref.confidence = $confidence`,
+            {
+              preferenceId: record.get("preferenceId"),
+              accountId,
+              confidence: decayedConfidence
+            }
+          );
+          decayCount++;
+        }
+      }
+    }
+    const result = await session.run(
+      `MATCH (up:UserProfile {accountId: $accountId, userId: $userId})
+       OPTIONAL MATCH (au:AdminUser {userId: $userId})-[:OWNS]->(p:Person {accountId: $accountId})
+       OPTIONAL MATCH (up)-[:HAS_PREFERENCE]->(pref:Preference)
+       WHERE pref.confidence >= $threshold OR pref.notApplicable = true
+       WITH up, p, pref
+       ORDER BY pref.confidence DESC
+       WITH up, p, collect(pref) AS allPrefs
+       WITH up, p, allPrefs[0..$limit] AS prefs
+       RETURN up, p AS person, prefs`,
+      { accountId, userId, threshold: INJECTION_THRESHOLD, limit: MAX_SUMMARY_PREFERENCES }
+    );
+    if (result.records.length === 0 || !result.records[0].get("up")) {
+      return null;
+    }
+    const upNode = result.records[0].get("up");
+    const profileProps = { ...upNode.properties };
+    const personNode = result.records[0].get("person");
+    if (personNode?.properties) {
+      if (personNode.properties.givenName !== void 0) profileProps.givenName = personNode.properties.givenName;
+      if (personNode.properties.familyName !== void 0) profileProps.familyName = personNode.properties.familyName;
+      if (personNode.properties.email !== void 0) profileProps.email = personNode.properties.email;
+      if (personNode.properties.telephone !== void 0) profileProps.telephone = personNode.properties.telephone;
+    }
+    const prefNodes = result.records[0].get("prefs");
+    const preferences = prefNodes.map((p) => ({
+      preferenceId: p.properties.preferenceId,
+      category: p.properties.category,
+      key: p.properties.key,
+      value: p.properties.value,
+      confidence: p.properties.confidence,
+      source: p.properties.source,
+      observedAt: p.properties.observedAt,
+      notApplicable: p.properties.notApplicable === true
+    }));
+    const extraTemplates = loadEnabledPluginProfileKeys(accountId);
+    const extraFieldCount = Object.values(extraTemplates).reduce((n, fs) => n + fs.length, 0);
+    const summary = formatProfileSummary(profileProps, preferences, extraTemplates);
+    const absentFields = computeAbsentFields(preferences, extraTemplates);
+    const totalFields = TOTAL_PROFILE_FIELDS + extraFieldCount;
+    const fieldCoverageCount = totalFields - absentFields.length;
+    const presentCategories = new Set(
+      preferences.filter((p) => p.notApplicable === true || p.confidence >= INJECTION_THRESHOLD).map((p) => p.category)
+    );
+    const absentCategories = PROFILE_CATEGORIES.filter((c) => !presentCategories.has(c));
+    const categoryCoverage = PROFILE_CATEGORIES.length - absentCategories.length;
+    console.error(
+      `[profile] loaded for userId=${userId} accountId=${accountId.slice(0, 8)}\u2026 preferences=${preferences.length} fieldCoverage=${fieldCoverageCount}/${totalFields} categoryCoverage=${categoryCoverage}/${PROFILE_CATEGORIES.length} (decay: ${decayCount} updated)`
+    );
+    const identityKeys = [
+      { prop: "email", token: "email" },
+      // Schema-canonical name. `phone` is the synonym (rejected at tool
+      // surface); the log uses `telephone` to keep grep aligned with
+      // schema-base.md doctrine the brief enforces.
+      { prop: "telephone", token: "telephone" },
+      { prop: "givenName", token: "givenName" },
+      { prop: "familyName", token: "familyName" },
+      { prop: "role", token: "role" }
+    ];
+    const absentIdentity = identityKeys.filter((k) => {
+      const v = profileProps[k.prop];
+      return typeof v !== "string" || v.trim().length === 0;
+    });
+    const sparseFired = absentCategories.length > 0 || absentFields.length > 0 || absentIdentity.length > 0;
+    if (conversationId && sparseFired) {
+      const dedupeKey = `${accountId}:${userId}:${conversationId}`;
+      if (!sparseStateLogged.has(dedupeKey)) {
+        sparseStateLogged.add(dedupeKey);
+        const FIELDS_LOG_CAP = 10;
+        const absentFieldsTruncated = absentFields.length <= FIELDS_LOG_CAP ? absentFields.join(",") : `${absentFields.slice(0, FIELDS_LOG_CAP).join(",")}+${absentFields.length - FIELDS_LOG_CAP} more`;
+        console.error(
+          `[profile] sparse-state injected accountId=${accountId.slice(0, 8)}\u2026 userId=${userId} conversationId=${conversationId.slice(0, 8)}\u2026 absentCategories=${absentCategories.join(",")} absentFields=${absentFieldsTruncated || "none"} absentIdentity=${absentIdentity.map((k) => k.token).join(",") || "none"}`
+        );
+      }
+    }
+    return summary;
+  } catch (err) {
+    console.error(`[profile] loadUserProfile failed: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  } finally {
+    await session.close();
+  }
+}
+function formatProfileSummary(profile, preferences, extraTemplates = {}) {
+  const givenName = typeof profile.givenName === "string" ? profile.givenName.trim() : "";
+  const familyName = typeof profile.familyName === "string" ? profile.familyName.trim() : "";
+  const joined = familyName ? `${givenName} ${familyName}` : givenName;
+  const name = joined || "Owner";
+  const role = profile.role ? ` (${profile.role})` : "";
+  const tz = profile.timezone ? ` \u2014 ${profile.timezone}` : "";
+  const locale = profile.locale ? `, ${profile.locale}` : "";
+  const expertise = profile.expertise ? `
+Expertise: ${typeof profile.expertise === "string" ? profile.expertise : JSON.stringify(profile.expertise)}` : "";
+  const lines = [`## About the Owner
+`];
+  lines.push(`${name}${role}${tz}${locale}${expertise}
+`);
+  const categories = {};
+  for (const pref of preferences) {
+    if (pref.notApplicable === true) continue;
+    if (!categories[pref.category]) categories[pref.category] = [];
+    categories[pref.category].push(pref);
+  }
+  const categoryLabels = {
+    communication: "Communication",
+    scheduling: "Scheduling",
+    decision: "Decisions",
+    workflow: "Workflow",
+    content: "Content",
+    interaction: "Interaction patterns"
+  };
+  const workCategories = ["communication", "scheduling", "decision", "workflow", "content"];
+  const workPrefs = workCategories.filter((c) => categories[c]);
+  if (workPrefs.length > 0) {
+    lines.push(`### How they work`);
+    for (const cat of workPrefs) {
+      const label = categoryLabels[cat] || cat;
+      const items = categories[cat].map((p) => p.value).join("; ");
+      lines.push(`- ${label}: ${items}`);
+    }
+    lines.push("");
+  }
+  if (categories.interaction) {
+    lines.push(`### Interaction patterns`);
+    for (const pref of categories.interaction) {
+      lines.push(`- ${pref.value}`);
+    }
+    lines.push("");
+  }
+  const identityFields = [
+    { key: "email", label: "email" },
+    { key: "telephone", label: "phone" },
+    { key: "givenName", label: "first name" },
+    { key: "familyName", label: "last name" },
+    { key: "role", label: "role" }
+  ];
+  const absentIdentity = identityFields.filter((f) => {
+    const v = profile[f.key];
+    return typeof v !== "string" || v.trim().length === 0;
+  });
+  if (absentIdentity.length > 0) {
+    lines.push(`### Identity coverage`);
+    lines.push(`Missing: ${absentIdentity.map((f) => f.label).join(", ")}`);
+    lines.push("");
+  }
+  const absentFields = computeAbsentFields(preferences, extraTemplates);
+  if (absentFields.length > 0) {
+    lines.push(`### Coverage`);
+    lines.push(`Missing: ${absentFields.join(", ")}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
 var RECENT_FAILURES_TAIL_BYTES = 10 * 1024;
 var AGENT_FILE_ROLES = [
   { filename: "IDENTITY.md", role: "identity" },
@@ -1205,6 +1513,7 @@ export {
   getUserTimezone,
   loadAdminUserName,
   writeAdminUserAndPerson,
+  loadUserProfile,
   projectAgent,
   deleteAgentProjection
 };

package/payload/server/{chunk-RZQMYJVY.js → chunk-QC5LHYPH.js}

@@ -1,6 +1,6 @@
 import {
   getSession
-} from "./chunk-KVGTWNKQ.js";
+} from "./chunk-NNHHGQJL.js";
 import {
   __commonJS,
   __toESM
@@ -219,7 +219,7 @@ var require_dist = __commonJS({
         const actionToolField = reviewDigestActionTool ? "review-digest-compose" : "n/a";
         process.stderr.write(`[graph-write] reject reason=removed-feature labels=${labelCsv} actionTool=${actionToolField} agent=${agentLabel}
 `);
-        throw new Error("Write doctrine violated: review-detector feature removed (Task 884) \u2014 `:ReviewAlert` and `:Event {actionTool:'review-digest-compose'}` writes are not allowed.");
+        throw new Error("Write doctrine violated: review-detector feature removed \u2014 `:ReviewAlert` and `:Event {actionTool:'review-digest-compose'}` writes are not allowed.");
       }
       if (!relationships || relationships.length < 1) {
         process.stderr.write(`[graph-write] reject reason=zero-relationships labels=${labelCsv} agent=${agentLabel}
@@ -468,7 +468,7 @@ async function completeCloudflareTask(params) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   if (status === "failed" && (!errorMessage || errorMessage.trim().length === 0)) {
     throw new Error(
-      "cloudflare-task-tracker: errorMessage is required when status='failed' (Task 885 process-provenance contract)."
+      "cloudflare-task-tracker: errorMessage is required when status='failed' (process-provenance contract)."
     );
   }
   const session = getSession();

package/payload/server/{cloudflare-task-tracker-4PKOLE4H.js → cloudflare-task-tracker-NEB3X6O2.js}

@@ -7,8 +7,8 @@ import {
   readTunnelState,
   recoverRunningCloudflareTasks,
   resolveUnitGoneVerdict
-} from "./chunk-RZQMYJVY.js";
-import "./chunk-KVGTWNKQ.js";
+} from "./chunk-QC5LHYPH.js";
+import "./chunk-NNHHGQJL.js";
 import "./chunk-JSBRDJBE.js";
 export {
   CLOUDFLARE_TASK_DIAGNOSTICS,

package/payload/server/maxy-edge.js

@@ -18,8 +18,8 @@ import {
   streamActionEvents,
   vncLog,
   websockifyLog
-} from "./chunk-ZGJ6CUU2.js";
-import "./chunk-KVGTWNKQ.js";
+} from "./chunk-3G6JMV7N.js";
+import "./chunk-NNHHGQJL.js";
 import "./chunk-JSBRDJBE.js";
 
 // server/edge.ts

package/payload/server/public/assets/{Checkbox-C6zXApx_.js → Checkbox-8mOR8-gV.js}

@@ -1 +1 @@
-import{a as e}from"./brand-B-bNrpwc.js";var t=e();function n({checked:e,onChange:n,label:r,disabled:i}){return(0,t.jsxs)(`label`,{className:`maxy-checkbox${i?` maxy-checkbox--disabled`:``}`,children:[(0,t.jsx)(`input`,{type:`checkbox`,checked:e,onChange:e=>n(e.target.checked),disabled:i}),(0,t.jsx)(`span`,{className:`maxy-checkbox__box`,children:`✱`}),r&&(0,t.jsx)(`span`,{className:`maxy-checkbox__label`,children:r})]})}export{n as t};
+import{a as e}from"./brand-CENN2zdq.js";var t=e();function n({checked:e,onChange:n,label:r,disabled:i}){return(0,t.jsxs)(`label`,{className:`maxy-checkbox${i?` maxy-checkbox--disabled`:``}`,children:[(0,t.jsx)(`input`,{type:`checkbox`,checked:e,onChange:e=>n(e.target.checked),disabled:i}),(0,t.jsx)(`span`,{className:`maxy-checkbox__box`,children:`✱`}),r&&(0,t.jsx)(`span`,{className:`maxy-checkbox__label`,children:r})]})}export{n as t};