@rubytech/create-maxy-code 0.1.182 → 0.1.184

package/payload/platform/plugins/email/mcp/dist/scripts/send-transactional.js

@@ -0,0 +1,56 @@
+/**
+ * Transactional email send — one-shot script invoked by the UI server
+ * for system emails (magic-link delivery, etc.) that must not carry the
+ * `email-send` tool's AI-generated disclosure footer.
+ *
+ * Stdin JSON payload: { accountId, to, subject, body, html? }
+ * Stdout on success: `ok messageId=<id>`
+ * Stderr on failure: error message
+ * Exit code: 0 on success, 1 on any failure.
+ *
+ * Spawned via `node dist/scripts/send-transactional.js` from a child
+ * process; reuses the email plugin's existing nodemailer + credentials
+ * loaders so no new dependency travels into the UI bundle.
+ */
+import { readFileSync } from "node:fs";
+import { loadCredentials } from "../lib/credentials.js";
+import { sendEmail } from "../lib/smtp.js";
+function readStdin() {
+    // Block until EOF on fd 0 — simpler than the async stream pattern for a
+    // one-shot script. Throws if no payload arrived.
+    try {
+        return readFileSync(0, "utf-8");
+    }
+    catch (err) {
+        throw new Error(`failed to read stdin: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+async function main() {
+    const raw = readStdin();
+    if (!raw.trim()) {
+        throw new Error("empty stdin payload");
+    }
+    const payload = JSON.parse(raw);
+    for (const field of ["accountId", "to", "subject", "body"]) {
+        if (typeof payload[field] !== "string" || !payload[field].length) {
+            throw new Error(`missing required field: ${field}`);
+        }
+    }
+    const result = await loadCredentials(payload.accountId);
+    if ("error" in result)
+        throw new Error(result.error);
+    const { config, password } = result.credentials;
+    const { messageId } = await sendEmail(config, password, {
+        to: payload.to,
+        subject: payload.subject,
+        body: payload.body,
+        html: payload.html,
+        headers: payload.headers,
+    });
+    process.stdout.write(`ok messageId=${messageId}\n`);
+}
+main().catch((err) => {
+    process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+    process.exit(1);
+});
+//# sourceMappingURL=send-transactional.js.map

package/payload/platform/plugins/email/mcp/dist/scripts/send-transactional.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"send-transactional.js","sourceRoot":"","sources":["../../src/scripts/send-transactional.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAW3C,SAAS,SAAS;IAChB,wEAAwE;IACxE,iDAAiD;IACjD,IAAI,CAAC;QACH,OAAO,YAAY,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;IAClC,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,IAAI,KAAK,CAAC,yBAAyB,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAC/F,CAAC;AACH,CAAC;AAED,KAAK,UAAU,IAAI;IACjB,MAAM,GAAG,GAAG,SAAS,EAAE,CAAC;IACxB,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,EAAE,CAAC;QAChB,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAC;IACzC,CAAC;IACD,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAY,CAAC;IAC3C,KAAK,MAAM,KAAK,IAAI,CAAC,WAAW,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,CAAU,EAAE,CAAC;QACpE,IAAI,OAAO,OAAO,CAAC,KAAK,CAAC,KAAK,QAAQ,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,CAAC;YACjE,MAAM,IAAI,KAAK,CAAC,2BAA2B,KAAK,EAAE,CAAC,CAAC;QACtD,CAAC;IACH,CAAC;IAED,MAAM,MAAM,GAAG,MAAM,eAAe,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IACxD,IAAI,OAAO,IAAI,MAAM;QAAE,MAAM,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACrD,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,MAAM,CAAC,WAAW,CAAC;IAEhD,MAAM,EAAE,SAAS,EAAE,GAAG,MAAM,SAAS,CAAC,MAAM,EAAE,QAAQ,EAAE;QACtD,EAAE,EAAE,OAAO,CAAC,EAAE;QACd,OAAO,EAAE,OAAO,CAAC,OAAO;QACxB,IAAI,EAAE,OAAO,CAAC,IAAI;QAClB,IAAI,EAAE,OAAO,CAAC,IAAI;QAClB,OAAO,EAAE,OAAO,CAAC,OAAO;KACzB,CAAC,CAAC;IACH,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,gBAAgB,SAAS,IAAI,CAAC,CAAC;AACtD,CAAC;AAED,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;IACnB,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC9E,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC,CAAC,CAAC"}

package/payload/platform/plugins/memory/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "memory",
-  "description": "Graph memory plugin. Provides memory-search (with optional `fields` projection for known-shape lookups), memory-write, memory-update, and the :Report surface (memory-report-write / memory-report-read-latest / memory-report-list) for reading from, writing to, and updating the Neo4j knowledge graph. Includes conversational memory — organic preference learning, evidence-backed recall, and transparent 'what do you know about me?' responses. Document ingestion goes through memory-ingest; the dispatched specialist produces typed-section JSON in-turn from the loaded ontology. Operator-solicited reclassify of an already-stored thread-shaped KD (today: email-thread KDs) is exposed as `kd-classify <attachmentId>` — runs a body-growth gate (proceed iff body grew ≥25% since the last classify, or first-ever classify), stages the body to a temp file under `$ACCOUNT_DIR/tmp/`, and returns a dispatch envelope for the `librarian`; on success `memory-ingest` replaces the prior :Section children and stamps `lastClassifiedAt` + `lastClassifiedBodyLength` on the parent KD. Two modes: `document` (default) for unstructured PDF/web content → :KnowledgeDocument (keyed on `attachmentId`) + :Section, and `chat` for conversation transcripts → :ConversationArchive (keyed on `conversationIdentity`) + :Section chunks; two parent labels, two writer paths chosen by which identity property is set. Conversation-archive Phase 2 splits across two read-only tools (Task 433): `conversation-archive-list-chunks` pages chunk bodies for the dispatched specialist to read in-turn; `conversation-archive-derive-insights` converts the specialist's per-chunk claims into operator-facing proposals with per-kind cypher. `conversation-archive-enrich-rejection` records (or undoes) durable per-row rejections so already-triaged claims do not re-surface on re-runs. Ships five skills: `conversational-memory`, `document-ingest`, `conversation-archive` (source-agnostic transcript ingest for WhatsApp, Telegram, Signal, LinkedIn DMs, Zoom, meeting minutes, iMessage, Slack), `conversation-archive-mcp` (operator-initiated MCP-driven ingest for Granola, Otter, Circleback meetings — sibling of `conversation-archive` sharing the same writer surface and identity formula), and `conversation-archive-enrich` (per-row operator-gated insight derivation over a named archive's chunks).",
+  "description": "Graph memory plugin. Provides memory-search (with optional `fields` projection for known-shape lookups), memory-write, memory-update, memory-update-by-name (repair surface that resolves an elementId from a (label, name, accountId) tuple when search cannot return one), and the :Report surface (memory-report-write / memory-report-read-latest / memory-report-list) for reading from, writing to, and updating the Neo4j knowledge graph. Includes conversational memory — organic preference learning, evidence-backed recall, and transparent 'what do you know about me?' responses. Document ingestion goes through memory-ingest; the dispatched specialist produces typed-section JSON in-turn from the loaded ontology. Operator-solicited reclassify of an already-stored thread-shaped KD (today: email-thread KDs) is exposed as `kd-classify <attachmentId>` — runs a body-growth gate (proceed iff body grew ≥25% since the last classify, or first-ever classify), stages the body to a temp file under `$ACCOUNT_DIR/tmp/`, and returns a dispatch envelope for the `librarian`; on success `memory-ingest` replaces the prior :Section children and stamps `lastClassifiedAt` + `lastClassifiedBodyLength` on the parent KD. Two modes: `document` (default) for unstructured PDF/web content → :KnowledgeDocument (keyed on `attachmentId`) + :Section, and `chat` for conversation transcripts → :ConversationArchive (keyed on `conversationIdentity`) + :Section chunks; two parent labels, two writer paths chosen by which identity property is set. Conversation-archive Phase 2 splits across two read-only tools (Task 433): `conversation-archive-list-chunks` pages chunk bodies for the dispatched specialist to read in-turn; `conversation-archive-derive-insights` converts the specialist's per-chunk claims into operator-facing proposals with per-kind cypher. `conversation-archive-enrich-rejection` records (or undoes) durable per-row rejections so already-triaged claims do not re-surface on re-runs. Ships five skills: `conversational-memory`, `document-ingest`, `conversation-archive` (source-agnostic transcript ingest for WhatsApp, Telegram, Signal, LinkedIn DMs, Zoom, meeting minutes, iMessage, Slack), `conversation-archive-mcp` (operator-initiated MCP-driven ingest for Granola, Otter, Circleback meetings — sibling of `conversation-archive` sharing the same writer surface and identity formula), and `conversation-archive-enrich` (per-row operator-gated insight derivation over a named archive's chunks).",
   "version": "0.1.0",
   "author": {
     "name": "Rubytech LLC"

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

@@ -1,6 +1,6 @@
 ---
 name: memory
-description: "Graph memory plugin. Provides memory-search (with optional `fields` projection for known-shape lookups), memory-write, memory-update, and the :Report surface (memory-report-write / memory-report-read-latest / memory-report-list) for reading from, writing to, and updating the Neo4j knowledge graph. Includes conversational memory — organic preference learning, evidence-backed recall, and transparent 'what do you know about me?' responses. Document ingestion goes through memory-ingest; the dispatched specialist produces typed-section JSON in-turn from the loaded ontology. Operator-solicited reclassify of an already-stored thread-shaped KD (today: email-thread KDs) is exposed as `kd-classify <attachmentId>` — runs a body-growth gate (proceed iff body grew ≥25% since the last classify, or first-ever classify), stages the body to a temp file under `$ACCOUNT_DIR/tmp/`, and returns a dispatch envelope for the `librarian`; on success `memory-ingest` replaces the prior :Section children and stamps `lastClassifiedAt` + `lastClassifiedBodyLength` on the parent KD. Two modes: `document` (default) for unstructured PDF/web content → :KnowledgeDocument (keyed on `attachmentId`) + :Section, and `chat` for conversation transcripts → :ConversationArchive (keyed on `conversationIdentity`) + :Section chunks; two parent labels, two writer paths chosen by which identity property is set. Conversation-archive Phase 2 splits across two read-only tools (Task 433): `conversation-archive-list-chunks` pages chunk bodies for the dispatched specialist to read in-turn; `conversation-archive-derive-insights` converts the specialist's per-chunk claims into operator-facing proposals with per-kind cypher. `conversation-archive-enrich-rejection` records (or undoes) durable per-row rejections so already-triaged claims do not re-surface on re-runs. Ships five skills: `conversational-memory`, `document-ingest`, `conversation-archive` (source-agnostic transcript ingest for WhatsApp, Telegram, Signal, LinkedIn DMs, Zoom, meeting minutes, iMessage, Slack), `conversation-archive-mcp` (operator-initiated MCP-driven ingest for Granola, Otter, Circleback meetings — sibling of `conversation-archive` sharing the same writer surface and identity formula), and `conversation-archive-enrich` (per-row operator-gated insight derivation over a named archive's chunks)."
+description: "Graph memory plugin. Provides memory-search (with optional `fields` projection for known-shape lookups), memory-write, memory-update, memory-update-by-name (repair surface that resolves an elementId from a (label, name, accountId) tuple when search cannot return one), and the :Report surface (memory-report-write / memory-report-read-latest / memory-report-list) for reading from, writing to, and updating the Neo4j knowledge graph. Includes conversational memory — organic preference learning, evidence-backed recall, and transparent 'what do you know about me?' responses. Document ingestion goes through memory-ingest; the dispatched specialist produces typed-section JSON in-turn from the loaded ontology. Operator-solicited reclassify of an already-stored thread-shaped KD (today: email-thread KDs) is exposed as `kd-classify <attachmentId>` — runs a body-growth gate (proceed iff body grew ≥25% since the last classify, or first-ever classify), stages the body to a temp file under `$ACCOUNT_DIR/tmp/`, and returns a dispatch envelope for the `librarian`; on success `memory-ingest` replaces the prior :Section children and stamps `lastClassifiedAt` + `lastClassifiedBodyLength` on the parent KD. Two modes: `document` (default) for unstructured PDF/web content → :KnowledgeDocument (keyed on `attachmentId`) + :Section, and `chat` for conversation transcripts → :ConversationArchive (keyed on `conversationIdentity`) + :Section chunks; two parent labels, two writer paths chosen by which identity property is set. Conversation-archive Phase 2 splits across two read-only tools (Task 433): `conversation-archive-list-chunks` pages chunk bodies for the dispatched specialist to read in-turn; `conversation-archive-derive-insights` converts the specialist's per-chunk claims into operator-facing proposals with per-kind cypher. `conversation-archive-enrich-rejection` records (or undoes) durable per-row rejections so already-triaged claims do not re-surface on re-runs. Ships five skills: `conversational-memory`, `document-ingest`, `conversation-archive` (source-agnostic transcript ingest for WhatsApp, Telegram, Signal, LinkedIn DMs, Zoom, meeting minutes, iMessage, Slack), `conversation-archive-mcp` (operator-initiated MCP-driven ingest for Granola, Otter, Circleback meetings — sibling of `conversation-archive` sharing the same writer surface and identity formula), and `conversation-archive-enrich` (per-row operator-gated insight derivation over a named archive's chunks)."
 tools:
   - name: memory-search
     publicAllowlist: true
@@ -11,6 +11,9 @@ tools:
   - name: memory-update
     publicAllowlist: false
     adminAllowlist: true
+  - name: memory-update-by-name
+    publicAllowlist: false
+    adminAllowlist: true
   - name: memory-reindex
     publicAllowlist: false
     adminAllowlist: false
@@ -140,6 +143,8 @@ mcp:
     PLATFORM_ROOT: ${PLATFORM_ROOT}
     ACCOUNT_ID: ${ACCOUNT_ID}
     SESSION_ID: ${SESSION_ID}
+    AGENT_SLUG: ${AGENT_SLUG}
+    AGENT_SLUG_SCOPE: ${AGENT_SLUG_SCOPE}
 mcp-manifest: auto
 ---
 

package/payload/platform/plugins/memory/mcp/dist/index.js

@@ -25,6 +25,7 @@ import { obsidianVaultImport, } from "./tools/obsidian-vault-import.js";
 // whatsapp-export-insight-pass deleted (Phase 2 deferred).
 import { memoryIngestWeb } from "./tools/memory-ingest-web.js";
 import { memoryUpdate } from "./tools/memory-update.js";
+import { memoryUpdateByName } from "./tools/memory-update-by-name.js";
 import { memoryDelete } from "./tools/memory-delete.js";
 import { memoryFindCandidates } from "./tools/memory-find-candidates.js";
 import { memoryNodeExists, ALLOWED_LABELS as MEMORY_NODE_EXISTS_LABELS } from "./tools/memory-node-exists.js";
@@ -66,7 +67,12 @@ const readOnly = process.env.READ_ONLY === "true";
 // Module-init must never throw; plugin-system spawn enumerates tools/list
 // before ACCOUNT_ID is set. Per-call refusal preserves account isolation.
 const accountId = process.env.ACCOUNT_ID ?? null;
-process.stderr.write(`[memory] boot accountId=${accountId ?? "null"}\n`);
+// Task 476/487 — extended boot signal: sessionId, agentSlug (provenance),
+// and agentScope (read-scope) land here so a stale spawn-env contract is
+// visible at the first byte of stderr. Regression shapes: `sessionId ===
+// accountId`; `agentSlug` empty on a specialist spawn (provenance lost);
+// `agentScope` non-empty on the admin operator spawn (search wrongly scoped).
+process.stderr.write(`[memory] boot accountId=${accountId ?? "null"} sessionId=${process.env.SESSION_ID || "-"} agentSlug=${process.env.AGENT_SLUG || "-"} agentScope=${process.env.AGENT_SLUG_SCOPE || "-"}\n`);
 function refuseNoAccount(toolName) {
     process.stderr.write(`[memory] tool=${toolName} refuse reason=no-account-context\n`);
     return {
@@ -139,6 +145,15 @@ const userId = process.env.USER_ID; // Optional — present for admin sessions w
 const allowedScopes = process.env.ALLOWED_SCOPES
     ? process.env.ALLOWED_SCOPES.split(",").map((s) => s.trim()).filter(Boolean)
     : undefined;
+// Task 485 — per-visitor slice ringfence. Stamped by pty-spawner on
+// gated public-agent spawns. When present, every memory-search WHERE
+// composes `(n.sliceToken = $sliceToken OR n.scope IN $allowedScopes)`
+// so the agent sees its visitor's user-scoped nodes alongside public-scope
+// rows. When absent (admin path + open-mode public), behaviour is
+// unchanged.
+const accessSliceToken = typeof process.env.ACCESS_SLICE_TOKEN === "string" && process.env.ACCESS_SLICE_TOKEN.length > 0
+    ? process.env.ACCESS_SLICE_TOKEN
+    : undefined;
 // Per-handler session resolution. Module-load env capture was
 // wrong: when the admin agent didn't set SESSION_ID on MCP spawn, `sessionId`
 // was undefined for the entire process lifetime — every subsequent
@@ -151,10 +166,17 @@ function resolveSessionId(override) {
     const fromEnv = process.env.SESSION_ID;
     return fromEnv && fromEnv.trim() ? fromEnv.trim() : undefined;
 }
-// Per-agent knowledge scoping: when set, memory-search only returns nodes whose
-// `agents` array contains this slug. For public agents, set via env var (server-level
-// enforcement). For admin queries, passed as an optional tool param.
+// Provenance stamp: AGENT_SLUG is the agent identity recorded as
+// `createdByAgent` on every write. The admin operator gets the 'admin'
+// sentinel (Task 487); specialists/public get their slug.
 const envAgentSlug = process.env.AGENT_SLUG || undefined;
+// Per-agent knowledge scoping (Task 487 split this off AGENT_SLUG): when set,
+// memory-search only returns nodes whose `agents` array contains this slug.
+// Specialists/public get their slug here (server-level enforcement); the admin
+// operator gets EMPTY so search stays wide-open. For admin, an optional tool
+// param can still scope a single query. Read-scope and provenance are now
+// independent — admin writes stamp 'admin' while admin reads stay unscoped.
+const envAgentScopeSlug = process.env.AGENT_SLUG_SCOPE || undefined;
 // Keyword subscriptions: comma-separated list of keywords for BM25-based reactive
 // knowledge inclusion. When set, memory-search runs a BM25 query per keyword and
 // unions results with directly-tagged nodes. Capped at 5 for Pi performance.
@@ -225,8 +247,10 @@ eagerTool(server, "memory-search", "Search the knowledge graph using semantic ve
 }, async ({ query, labels, limit, expandHops, keywords, keywordMatch, agentSlug: toolAgentSlug, fields, retrievalClass }) => {
     if (!accountId)
         return refuseNoAccount("memory-search");
-    // Env var takes precedence over tool param (security: public agent server-level enforcement)
-    const effectiveAgentSlug = envAgentSlug ?? toolAgentSlug;
+    // AGENT_SLUG_SCOPE takes precedence over the tool param (security: public
+    // agent server-level enforcement). Empty for the admin operator, so admin
+    // falls through to the optional tool param (default: unscoped).
+    const effectiveAgentSlug = envAgentScopeSlug ?? toolAgentSlug;
     try {
         const results = await memorySearch({
             query,
@@ -235,6 +259,7 @@ eagerTool(server, "memory-search", "Search the knowledge graph using semantic ve
             limit,
             expandHops,
             allowedScopes,
+            sliceToken: accessSliceToken,
             keywords,
             keywordMatch,
             agentSlug: effectiveAgentSlug,
@@ -242,6 +267,23 @@ eagerTool(server, "memory-search", "Search the knowledge graph using semantic ve
             fields,
             retrievalClass,
         });
+        // Task 485 — per-call slice/public/user breakdown so the
+        // `[memory-search] sliceFilter=…|none publicCount=… userCount=…` grep
+        // proves the gated filter fired on the right turn. Inspects results
+        // after hybrid() applied the WHERE, so the counts reflect what the
+        // agent actually saw, not the unscoped corpus.
+        let publicCount = 0;
+        let userCount = 0;
+        for (const r of results) {
+            const scope = r.properties.scope;
+            const sliceTokenRow = r.properties.sliceToken;
+            if (scope === "public")
+                publicCount += 1;
+            if (typeof sliceTokenRow === "string" && sliceTokenRow.length > 0)
+                userCount += 1;
+        }
+        process.stderr.write(`[memory-search] sliceFilter=${accessSliceToken ? accessSliceToken.slice(0, 8) : "none"} ` +
+            `resultCount=${results.length} publicCount=${publicCount} userCount=${userCount}\n`);
         if (results.length === 0) {
             return {
                 content: [
@@ -779,7 +821,49 @@ if (!readOnly) {
             };
         }
     });
-    server.tool("memory-update", "Update properties on an existing node in the knowledge graph. Finds the node by element ID, verifies account ownership, sets the provided properties, and recomputes the embedding. To refresh `compiledTruth` / `compiledTruthPublic` on :Person / :Organization / :Concept / :Project / :LocalBusiness, dispatch the `compiled-truth-rewriter` specialist via the Task tool — admin sends the nodeId plus any `operatorHint` / `publicOperatorHint`; the specialist reads the node + 90-day timeline, computes the new summary, and writes it back via memory-update. Direct writes to compiled-truth properties via this tool are refused unless the caller is the compiled-truth-rewriter specialist (gated by MAXY_SPECIALIST env).", {
+    server.tool("memory-update-by-name", "Update an existing node addressed by (label, name, accountId) instead of elementId. Use this as a repair surface when memory-search cannot return an elementId for a node you know exists by name — typically an ingest-created :Organization the search route is failing to surface. Resolves the unique node matching the tuple, then delegates to memory-update (embedding refresh, write gates, compiled-truth refusal, and provenance stamping all carry over). Rejects loudly on zero matches (the row does not exist) and on two-or-more matches (ambiguous — the rejection lists candidate elementIds so you can pick one and call memory-update directly). Trashed nodes are excluded from the lookup. For one-off updates where you already have the elementId from a successful memory-search, prefer memory-update — this tool is the fallback when search hides the node.", {
+        label: z.string().describe("The single label to MATCH on (e.g. 'Organization', 'Person', 'Project'). Must be exactly the label carried by the target node — the tool does not iterate label variants."),
+        name: z.string().describe("The exact `name` property of the target node (case-sensitive). Forbidden-property rules still apply downstream — if the label rejects `name`, use memory-update with the correct identifier instead."),
+        properties: z
+            .record(z.string(), z.unknown())
+            .describe("Properties to set or overwrite. Same restrictions as memory-update — embedding/accountId/createdAt are silently stripped; compiled-truth fields are refused unless the caller is the compiled-truth-rewriter specialist."),
+    }, async ({ label, name, properties }) => {
+        if (!accountId)
+            return refuseNoAccount("memory-update-by-name");
+        try {
+            const result = await memoryUpdateByName({
+                label,
+                name,
+                accountId,
+                properties: properties,
+                createdBy: {
+                    agent: envAgentSlug,
+                    session: resolveSessionId(),
+                    tool: "memory-update-by-name",
+                },
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Node updated: [${result.labels.join(", ")}] (ID: ${result.nodeId})`,
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Update failed: ${err instanceof Error ? err.message : String(err)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool("memory-update", "Update properties on an existing node in the knowledge graph. Finds the node by element ID, verifies account ownership, sets the provided properties, and recomputes the embedding. To refresh `compiledTruth` / `compiledTruthPublic` on :Person / :Organization / :Concept / :Project / :LocalBusiness, dispatch the `compiled-truth-rewriter` specialist via the Task tool — admin sends the nodeId plus any `operatorHint` / `publicOperatorHint`; the specialist reads the node + 90-day timeline, computes the new summary, and writes it back via memory-update. Direct writes to compiled-truth properties via this tool are refused unless the caller is the compiled-truth-rewriter specialist (gated by MAXY_SPECIALIST env). When you only have the node's name (typically because memory-search couldn't return it), use memory-update-by-name instead.", {
         nodeId: z.string().describe("Element ID of the node to update (from memory-search results)"),
         properties: z
             .record(z.string(), z.unknown())