@rubytech/create-maxy-code 0.1.129 → 0.1.132

package/payload/platform/templates/agents/public/IDENTITY.md

@@ -14,9 +14,15 @@ Three rules govern every turn. They are load-bearing — when they conflict with
 
 *Failure symptoms:* unrequested summary, three-paragraph answer to a one-line question, pasting a raw tool result verbatim into chat.
 
-**EVIDENCE-BASED.** The graph is the single, canonical source of truth about this account. Consult it — via `memory-search`, `memory-read`, or `profile-read` — before answering factual questions or embarking on activity. When the graph is wrong, correct it via `memory-write` or `memory-update`, then answer. Never substitute training-data recall for a graph read when the graph holds the canonical version. When the graph has no answer and you must rely on training knowledge, say so explicitly. *Failure symptoms:* factual claim without a prior graph read this turn, training-data fallback when the graph has the canonical version.
+**EVIDENCE-BASED.** The graph is the single, canonical source of truth about this account. Consult it — via `memory-search` — before answering factual questions or embarking on activity. Never substitute training-data recall for a graph read when the graph holds the canonical version. When the graph has no answer and you must rely on training knowledge, say so explicitly. You are read-only by design (see Boundaries); corrections to the graph are not your job — surface the gap so the operator can address it. *Failure symptoms:* factual claim without a prior graph read this turn, training-data fallback when the graph has the canonical version.
 
-A landfill graph defeats EVIDENCE-BASED: search returns noise, the agent re-writes the noise, the noise compounds. Compress on write; filter on read.
+The 4-step brain-first loop, every turn that needs information:
+1. **Classify the question** — known entity, temporal fact, event, general knowledge, or none. The inbound gateway provides this as `retrievalClass` when available.
+2. **Read the graph** — `memory-search` is the first tool call of any informational turn. The server scopes every read to `scope: "public"`, so what comes back is exactly what the operator chose to expose.
+3. **Hydrate on partial hit** — when a result names but does not contain what you need, walk one hop (re-search by `elementId` or scan related neighbours) before assuming a miss.
+4. **Fall back honestly on a confirmed miss** — say the graph has no answer, then offer to take a message or suggest direct contact. Never invent the missing fact.
+
+A landfill graph defeats EVIDENCE-BASED: search returns noise, the agent relays the noise, the visitor sees noise. Filter on read.
 
 ---
 

package/payload/platform/templates/specialists/agents/content-producer.md

@@ -22,6 +22,10 @@ These three rules win when anything else in this prompt conflicts with them.
 
 Producing reads from the graph; it never writes external input to it. All ingestion (PDFs, text, transcripts, web pages, audio, video, archives) routes to `specialists:database-operator`. If a brief asks you to ingest, return immediately and tell admin to redispatch.
 
+## Brain-first read before produce
+
+Every artifact you generate is grounded in graph content the operator already curated. The first action of any production turn is `memory-search` against the brief — for a brochure, that means searching for the `:LocalBusiness` and its `:DEPICTS`-linked `:ImageObject`s; for a chart, the `:Project` and its `:Task` and `:Event` neighbours; for an image prompt, the operator's `:UserProfile` or the named subject. Compose the artifact from properties the search returned. Image generation (`image-generate`) is the only outward call in your surface and is conditional on having confirmed the subject from the graph first — never call `image-generate` with a prompt assembled from the brief's free text alone when a graph subject could ground it.
+
 ## Image generation
 
 Three models via `image-generate`. Pick by output need: `recraft-v4` for design-quality and branded compositions (supports SVG); `nano-banana-pro` for photorealistic or text-heavy images; `flux-schnell` for fast drafts.

package/payload/platform/templates/specialists/agents/database-operator.md

@@ -16,4 +16,6 @@ Node `name` and `title` properties are short identifiers, never denormalised com
 
 The `accountId` property is supplied by the writers from server-side environment state (the `ACCOUNT_ID` env var) — never refuse a write because accountId is absent from admin's brief.
 
+**Brain-first read before write.** Resolve parents and existing nodes via `memory-search` before composing the write. The hierarchy rule (`LocalBusiness → Project → Task | Person | Organisation | KnowledgeDocument`) requires a parent `elementId`, and edges to existing entities require their `elementId` too — both come from a `memory-search` against the brief, not from a guess. When the brief names an entity that could plausibly already exist (a Person, a Project, an Organisation), the first action of the dispatch is a `memory-search` against that name; only on a confirmed miss do you create a new node. External-knowledge tools are absent from your surface by design — your job ends at the graph.
+
 Decide the precise operations against the schema, execute them with the writers in your tool surface, and report each write back to admin as `{label, elementId}` so admin can confirm the outcome to the operator. If admin's brief is ambiguous about which label, which edge type, or which existing node to attach to, name the ambiguity in your reply rather than guessing.

package/payload/platform/templates/specialists/agents/personal-assistant.md

@@ -28,6 +28,8 @@ Each domain has a small set of tools and, where it exists, a skill that drives t
 
 ## Cross-domain rules
 
+**Brain-first read before action.** The graph is the canonical store for everyone the operator works with, every scheduled commitment, and every channel configuration. Before composing a message, scheduling an event, or looking up a contact, run `memory-search` (and `profile-read` when the question is about the operator) against the brief. Resolve recipient `elementId`s from the graph, not from the brief's free text — wrapped writers (`schedule-event`, `contact-create`, `work-create`) reject zero-edge calls, and the resolved id is what satisfies them. External lookups (`outlook-mail-search`, `email-search`, Telegram message history, browser navigation) are step 2: run them when the graph confirms there is no local record of the thing you need. Each external result worth keeping goes back to admin so the Recording route on admin's side can persist it.
+
 **Credentials never leave a tool.** If you store an API key, password, or token via a tool, report only that storage succeeded or failed. Never repeat the secret in your output, even partially.
 
 **Timezones are not optional.** Scheduling output is rendered in the user's locale timezone from `UserProfile.timezone` (IANA). Storage is UTC. If timezone is unset, the scheduling tool errors; set it via `profile-update` with `profileFields: { timezone: "Europe/London" }`. There is no UTC fallback.

package/payload/server/server.js

@@ -4441,6 +4441,10 @@ function defaultResult(rawText, latencyMs) {
     language: "en",
     requiresHistory: false,
     complexity: "complex",
+    // Fallthrough defaults to "general" so the brain-first loop still runs a
+    // graph read — safer than "none", which would skip retrieval entirely on
+    // every Haiku failure.
+    retrievalClass: "general",
     latencyMs,
     fallthrough: true
   };
@@ -4476,7 +4480,14 @@ LANGUAGE \u2014 detect the language and return its ISO 639-1 code (e.g. "en", "e
 
 REQUIRES HISTORY \u2014 set to true if the message references prior conversation context ("we discussed", "last time", "that thing", "the proposal", "earlier")
 
-COMPLEXITY \u2014 "simple" for greetings, yes/no answers, brief confirmations; "complex" for multi-part requests, detailed questions, nuanced instructions`;
+COMPLEXITY \u2014 "simple" for greetings, yes/no answers, brief confirmations; "complex" for multi-part requests, detailed questions, nuanced instructions
+
+RETRIEVAL CLASS \u2014 classify what kind of graph read this message warrants (brain-first lookup loop). One of:
+- "entity": names or asks about a specific person, organisation, place, listing, project, document \u2014 anything the graph might already know about ("who is Adam Langley", "tell me about Acme Ltd", "what do we have on 5 Glan Honddu Close")
+- "temporal": references a time-bound fact \u2014 past events, schedule, what happened when ("what did we agree last Tuesday", "what's on today", "when did the contract land")
+- "event": references something a tool returned earlier in this or a prior session ("did the upload finish", "what did the search find", "the result from earlier")
+- "general": a question or task that needs information from the graph but doesn't fall into the three categories above (open-ended ask, broad topic, free-form question)
+- "none": greeting, meta-instruction, complaint, acknowledgement, or any message that does not warrant a graph lookup ("hi", "thanks", "stop doing that", "this is broken")`;
 }
 var GATEWAY_TOOL = {
   name: "classify_message",
@@ -4522,6 +4533,11 @@ var GATEWAY_TOOL = {
         type: "string",
         enum: ["simple", "complex"],
         description: "Message complexity level"
+      },
+      retrievalClass: {
+        type: "string",
+        enum: ["entity", "temporal", "event", "general", "none"],
+        description: "Brain-first retrieval class. entity=named entity lookup, temporal=time-bound fact, event=prior tool result reference, general=other informational, none=greeting/meta/complaint with no graph lookup warranted"
       }
     },
     required: [
@@ -4532,7 +4548,8 @@ var GATEWAY_TOOL = {
       "intent",
       "language",
       "requiresHistory",
-      "complexity"
+      "complexity",
+      "retrievalClass"
     ]
   }
 };
@@ -4603,6 +4620,7 @@ async function processInbound(rawText, channel) {
     const requiresHistory = input.requiresHistory === true;
     const complexity = input.complexity === "simple" ? "simple" : "complex";
     const searchQuery = typeof input.searchQuery === "string" ? input.searchQuery : null;
+    const retrievalClass = ["entity", "temporal", "event", "general", "none"].includes(input.retrievalClass) ? input.retrievalClass : "general";
     const isAdmin = channel === "web-admin" || channel === "telegram-admin";
     const finalText = isAdmin ? rawText.trim() : processedText;
     const result = {
@@ -4613,11 +4631,12 @@ async function processInbound(rawText, channel) {
       language,
       requiresHistory,
       complexity,
+      retrievalClass,
       latencyMs,
       fallthrough: false
     };
     console.log(
-      `${TAG14} channel=${channel} verdict=${verdict} promptInjection=${promptInjectionRisk} intent=${intent} language=${language} complexity=${complexity} requiresHistory=${requiresHistory} rewrite=${!isAdmin && processedText !== rawText.trim()} searchQuery=${searchQuery ? "yes" : "null"} latency_ms=${latencyMs}`
+      `${TAG14} channel=${channel} verdict=${verdict} promptInjection=${promptInjectionRisk} intent=${intent} language=${language} complexity=${complexity} retrievalClass=${retrievalClass} requiresHistory=${requiresHistory} rewrite=${!isAdmin && processedText !== rawText.trim()} searchQuery=${searchQuery ? "yes" : "null"} latency_ms=${latencyMs}`
     );
     if (verdict !== "clean") {
       console.warn(
@@ -5078,6 +5097,9 @@ ${lines}]`;
   let gatewayResult = null;
   if (!isGreeting) {
     gatewayResult = await processInbound(message, "web-public");
+    console.log(
+      `[chat-route] session=${session_key.slice(0, 8)} retrievalClass=${gatewayResult.retrievalClass} intent=${gatewayResult.intent}`
+    );
     if (gatewayResult.screening.verdict === "discard") {
       console.log(
         `[chat-route] session=${session_key.slice(0, 8)} gateway=discard reason=${gatewayResult.screening.reason}`
@@ -6480,9 +6502,17 @@ function readUsersFile() {
   if (!raw) return [];
   return JSON.parse(raw);
 }
+function claudeSpawnPath() {
+  const base = process.env.PATH ?? "/usr/bin:/bin:/usr/sbin:/sbin";
+  return `${base}:/opt/homebrew/bin:/usr/local/bin`;
+}
 function checkAuthStatus() {
   try {
-    execFileSync2("claude", ["auth", "status"], { encoding: "utf-8", timeout: 5e3 });
+    execFileSync2("claude", ["auth", "status"], {
+      encoding: "utf-8",
+      timeout: 5e3,
+      env: { ...process.env, PATH: claudeSpawnPath() }
+    });
     return true;
   } catch {
     return false;
@@ -6537,22 +6567,34 @@ app4.post("/claude-auth", async (c) => {
     return c.json({ launched: cdpReady });
   }
   ensureLogDir();
+  writeFileSync6(logPath("claude-auth"), "");
+  const claudeAuthLogFd = openSync(logPath("claude-auth"), "a");
+  const onClaudeOutput = (chunk) => writeSync(claudeAuthLogFd, chunk);
+  if (process.platform === "darwin") {
+    vncLog("claude-auth", { action: "start", transport: "native", platform: "darwin" });
+    const claudeProc2 = spawn("claude", ["auth", "login"], {
+      env: { ...process.env, PATH: claudeSpawnPath() },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    claudeProc2.unref();
+    claudeProc2.stdout?.on("data", onClaudeOutput);
+    claudeProc2.stderr?.on("data", onClaudeOutput);
+    claudeProc2.once("close", () => closeSync(claudeAuthLogFd));
+    return c.json({ started: true, transport: "native" });
+  }
   if (transport === "vnc") {
     const vncReady = await ensureVnc();
     if (!vncReady) return c.json({ error: "VNC display failed to start" }, 500);
   }
   await ensureCdp(transport);
-  writeFileSync6(logPath("claude-auth"), "");
   const chromiumWrapper = writeChromiumWrapper();
   const x11Env = buildX11Env(chromiumWrapper, transport);
   vncLog("claude-auth", { action: "start", transport });
-  const claudeAuthLogFd = openSync(logPath("claude-auth"), "a");
   const claudeProc = spawn("claude", ["auth", "login"], {
     env: x11Env,
     stdio: ["ignore", "pipe", "pipe"]
   });
   claudeProc.unref();
-  const onClaudeOutput = (chunk) => writeSync(claudeAuthLogFd, chunk);
   claudeProc.stdout?.on("data", onClaudeOutput);
   claudeProc.stderr?.on("data", onClaudeOutput);
   claudeProc.once("close", () => closeSync(claudeAuthLogFd));
@@ -8537,7 +8579,12 @@ async function performSpawnWithInitialMessage(args) {
     dormantPlugins,
     activePlugins,
     specialistDomains,
-    tunnelUrl
+    tunnelUrl,
+    // Task 382 — thread the active conversation's UUID through to the
+    // manager so the PTY env carries CONVERSATION_NODE_ID. Undefined is
+    // legitimate (autonomous spawns); the manager's UUID gate filters
+    // unshapely values.
+    conversationNodeId: args.conversationNodeId
   });
   console.log(`${TAG18} forward-spawn-start managerBase=${managerBase2()} bytes=${upstreamPayload.length} hidden=${args.hidden} specialist=${args.specialist ?? "none"}`);
   const forwardStart = Date.now();
@@ -8632,6 +8679,7 @@ app15.post("/", async (c) => {
   const specialist = typeof body.specialist === "string" && /^[A-Za-z0-9_-]{1,64}$/.test(body.specialist) ? body.specialist : void 0;
   const model = typeof body.model === "string" && /^[A-Za-z0-9._-]{1,64}$/.test(body.model) ? body.model : void 0;
   console.log(`${TAG18} spawn-request-in surface=${authSurface} accountId=${senderId.slice(0, 8)} userId=${userId ? userId.slice(0, 8) : "absent"} channel=${channel} permissionMode=${permissionMode ?? "default"} specialist=${specialist ?? "none"} model=${model ?? "default"} initialMessage=${initialMessage ? "yes" : "no"}`);
+  const conversationNodeId = cacheKey ? getConversationIdForSession(cacheKey) : void 0;
   const { response, claudeSessionId } = await performSpawnWithInitialMessage({
     senderId,
     userId,
@@ -8641,7 +8689,8 @@ app15.post("/", async (c) => {
     hidden: false,
     specialist,
     model,
-    initialMessage
+    initialMessage,
+    conversationNodeId
   });
   mintTranscriptEdge(
     cacheKey ? getConversationIdForSession(cacheKey) : void 0,
@@ -8719,7 +8768,13 @@ app15.post("/resume", async (c) => {
       dormantPlugins,
       activePlugins,
       specialistDomains,
-      tunnelUrl
+      tunnelUrl,
+      // Task 382 — resume parity with /spawn: thread the active
+      // conversationId so the re-spawned PTY's MCP env carries
+      // CONVERSATION_NODE_ID. Undefined when no active conversation is
+      // bound to this cacheKey (rare for resume — the user is by
+      // definition continuing a known conversation).
+      conversationNodeId: getConversationIdForSession(cacheKey)
     })
   }).catch((err) => {
     console.error(`${TAG18} fetch-failed op=resume message=${err instanceof Error ? err.message : String(err)}`);
@@ -12133,7 +12188,11 @@ app32.post("/", requireAdminSession, async (c) => {
     hidden: true,
     specialist: "database-operator",
     model: void 0,
-    initialMessage
+    initialMessage,
+    // Task 382 — LinkedIn ingest is a hidden autonomous spawn with no
+    // parent admin conversation; the database-operator threads
+    // `producedByTaskId` via work-create instead. Leave undefined.
+    conversationNodeId: void 0
   });
   if (!response.ok) {
     const detail = await response.text().catch(() => "");