@rubytech/create-maxy 1.0.421 → 1.0.422

package/package.json

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

package/payload/maxy/server.js

@@ -3822,7 +3822,7 @@ async function loadSessionContext(accountId) {
   try {
     const summaryResult = await session.run(
       `MATCH (n:CreativeWork {accountId: $accountId})
-       WHERE n.title STARTS WITH 'Session Summary'
+       WHERE n.title STARTS WITH 'Session Summary' OR n.title = 'Session Snapshot'
        RETURN n.title AS title, n.createdAt AS createdAt, n.abstract AS abstract
        ORDER BY n.createdAt DESC LIMIT 1`,
       { accountId }
@@ -3852,14 +3852,24 @@ async function loadSessionContext(accountId) {
       { accountId, limit: neo4j.int(MAX_SESSION_TASKS) }
     );
     const sections = [];
+    const STALENESS_LIMIT_MS = 48 * 60 * 60 * 1e3;
     if (summaryResult.records.length > 0) {
       const rec = summaryResult.records[0];
       const title = rec.get("title");
       const createdAt = rec.get("createdAt");
       const abstract = rec.get("abstract");
-      const dateSuffix = createdAt ? ` (${createdAt.slice(0, 10)})` : "";
-      sections.push(`## Last Session${dateSuffix}
+      let isStale = false;
+      if (createdAt) {
+        const ageMs = Date.now() - new Date(createdAt).getTime();
+        isStale = !isNaN(ageMs) && ageMs > STALENESS_LIMIT_MS;
+      }
+      if (isStale) {
+        console.error(`[session-context] Skipped stale summary for ${accountId.slice(0, 8)}\u2026: title="${title}" createdAt=${createdAt}`);
+      } else {
+        const dateSuffix = createdAt ? ` (${createdAt.slice(0, 10)})` : "";
+        sections.push(`## Last Session${dateSuffix}
 ${abstract}`);
+      }
     }
     if (digestResult.records.length > 0) {
       const rec = digestResult.records[0];
@@ -3885,8 +3895,9 @@ ${abstract}`);
 ${taskLines.join("\n")}`);
     }
     if (sections.length === 0) return null;
+    const summaryCreatedAt = summaryResult.records.length > 0 ? summaryResult.records[0].get("createdAt") ?? "unknown" : "n/a";
     console.error(
-      `[session-context] Loaded for ${accountId.slice(0, 8)}\u2026: summary=${summaryResult.records.length > 0 ? "yes" : "no"}, digest=${digestResult.records.length > 0 ? "yes" : "no"}, tasks=${tasksResult.records.length}`
+      `[session-context] Loaded for ${accountId.slice(0, 8)}\u2026: summary=${summaryResult.records.length > 0 ? "yes" : "no"}, summaryDate=${summaryCreatedAt}, digest=${digestResult.records.length > 0 ? "yes" : "no"}, tasks=${tasksResult.records.length}`
     );
     return `<previous-context>
 ${sections.join("\n\n")}
@@ -3898,6 +3909,22 @@ ${sections.join("\n\n")}
     await session.close();
   }
 }
+async function writeSessionSummary(accountId, summary) {
+  const session = getSession();
+  try {
+    const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+    await session.run(
+      `MERGE (n:CreativeWork {accountId: $accountId, title: 'Session Snapshot'})
+       SET n.abstract = $summary, n.createdAt = $createdAt, n.scope = 'admin'`,
+      { accountId, summary, createdAt }
+    );
+    console.error(`[session-summary] Written for ${accountId.slice(0, 8)}\u2026`);
+  } catch (err) {
+    console.error(`[session-summary] Failed for ${accountId.slice(0, 8)}\u2026: ${err instanceof Error ? err.message : String(err)}`);
+  } finally {
+    await session.close();
+  }
+}
 async function loadOnboardingStep(accountId) {
   const session = getSession();
   try {
@@ -4777,7 +4804,16 @@ function validateSession(sessionKey, agentType) {
   if (!session) return false;
   if (session.agentType !== agentType) return false;
   if (Date.now() - session.createdAt > 24 * 60 * 60 * 1e3) {
+    const history = session.messageHistory;
+    const expiredAccountId = session.accountId;
     sessionStore.delete(sessionKey);
+    if (history && history.length >= 2) {
+      writeEndOfTurnSummary(expiredAccountId, history).catch(
+        (err) => console.error(`[session-summary] expiry write failed: ${err instanceof Error ? err.message : String(err)}`)
+      );
+    } else {
+      console.error(`[session-summary] Session ${sessionKey.slice(0, 8)}\u2026 expired without summary \u2014 ${history?.length ?? 0} messages`);
+    }
     return false;
   }
   if (session.grantExpiresAt && Date.now() > session.grantExpiresAt) {
@@ -5061,6 +5097,80 @@ function getAdminAllowedTools(enabledPlugins) {
   }
   return tools;
 }
+var QUERY_CLASSIFIER_MODEL = "claude-haiku-4-5-20251001";
+var QUERY_CLASSIFIER_TIMEOUT_MS = 3e3;
+var QUERY_CLASSIFIER_MSG_CAP = 500;
+var QUERY_CLASSIFIER_HISTORY_TURNS = 4;
+var QUERY_CLASSIFIER_FALLBACK = {
+  search: true,
+  query: null,
+  // null means "use raw message"
+  reason: "classifier-fallback"
+};
+var QUERY_CLASSIFIER_SYSTEM = `You decide whether a user message to a business assistant requires a knowledge base search.
+
+The knowledge base contains the business's products, services, pricing, policies, and domain expertise. It does NOT contain conversation history \u2014 the assistant already has that.
+
+Respond with ONLY a JSON object: {"search": boolean, "query": string | null, "reason": string}
+
+Set search to false when:
+- The message is a greeting, farewell, acknowledgement, or filler ("hello", "thanks", "ok", "bye")
+- The message is about session state ("continue where we left off", "what were we discussing")
+- The conversation history already contains sufficient information to answer the question
+- The message is a conversational response that doesn't require new factual knowledge
+
+Set search to true when:
+- The message asks about products, services, pricing, capabilities, or business information
+- The message introduces a new topic not already covered in the conversation
+- The message requires factual knowledge the assistant wouldn't have from conversation alone
+
+When search is true, set query to a search-optimised phrase that captures the information need. Resolve references from conversation history \u2014 e.g. if the user says "tell me more about the first one" and the history mentions "property valuations", set query to "property valuations details". If the raw message is already a good search query, use it as-is.
+
+When search is false, set query to null and reason to a brief category (e.g. "greeting", "acknowledgement", "session-reference", "context-sufficient").`;
+async function classifyMemoryQuery(message, history) {
+  let apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) {
+    try {
+      apiKey = readFileSync5(API_KEY_FILE, "utf-8").trim();
+    } catch {
+    }
+  }
+  if (!apiKey) return QUERY_CLASSIFIER_FALLBACK;
+  const recentHistory = history.slice(-QUERY_CLASSIFIER_HISTORY_TURNS);
+  const transcript = recentHistory.length > 0 ? recentHistory.map((m) => `[${m.role}] ${m.content.slice(0, QUERY_CLASSIFIER_MSG_CAP)}`).join("\n") : "(no conversation history \u2014 this is the first message)";
+  const userContent = [
+    `Conversation history:
+${transcript}`,
+    `
+Current message:
+${message.slice(0, QUERY_CLASSIFIER_MSG_CAP)}`
+  ].join("\n");
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), QUERY_CLASSIFIER_TIMEOUT_MS);
+  try {
+    const client = new Anthropic({ apiKey });
+    const response = await client.messages.create({
+      model: QUERY_CLASSIFIER_MODEL,
+      max_tokens: 150,
+      system: QUERY_CLASSIFIER_SYSTEM,
+      messages: [{ role: "user", content: userContent }]
+    }, { signal: controller.signal });
+    const text = response.content.filter((b) => b.type === "text").map((b) => "text" in b ? b.text : "").join("").trim();
+    if (!text) return QUERY_CLASSIFIER_FALLBACK;
+    const jsonStr = text.replace(/^```json\s*/i, "").replace(/```\s*$/, "").trim();
+    const parsed = JSON.parse(jsonStr);
+    if (typeof parsed.search !== "boolean") return QUERY_CLASSIFIER_FALLBACK;
+    return {
+      search: parsed.search,
+      query: parsed.search && typeof parsed.query === "string" ? parsed.query.slice(0, QUERY_CLASSIFIER_MSG_CAP) : null,
+      reason: typeof parsed.reason === "string" ? parsed.reason.replace(/[\n\r]/g, " ").slice(0, 100) : "unknown"
+    };
+  } catch {
+    return QUERY_CLASSIFIER_FALLBACK;
+  } finally {
+    clearTimeout(timer);
+  }
+}
 async function fetchMemoryContext(accountId, query, sessionKey, options) {
   const serverPath = resolve4(PLATFORM_ROOT3, "plugins/memory/mcp/dist/index.js");
   if (!existsSync5(serverPath)) {
@@ -5456,6 +5566,65 @@ Extract preference updates as JSON array.`
     clearTimeout(timer);
   }
 }
+var SESSION_SUMMARY_PROMPT = `You are summarising a conversation between a business assistant and its owner. Write a 3-5 sentence summary covering:
+- What was discussed and accomplished this session
+- Any tasks created, decisions made, or state changes
+- Current state of any ongoing work
+- What the owner is likely to want to continue next
+
+Be factual and specific. Use present tense for current state. Do not include greetings or meta-commentary.`;
+var SESSION_SUMMARY_TIMEOUT_MS = 1e4;
+var lastSummaryWrite = /* @__PURE__ */ new Map();
+var SUMMARY_RATE_LIMIT_MS = 5 * 60 * 1e3;
+async function generateSessionSummary(history) {
+  if (history.length < 2) return null;
+  let apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) {
+    try {
+      apiKey = readFileSync5(API_KEY_FILE, "utf-8").trim();
+    } catch {
+      return null;
+    }
+  }
+  if (!apiKey) {
+    console.error("[session-summary] Skipping \u2014 no API key available");
+    return null;
+  }
+  const transcript = history.slice(-20).map((m) => `[${m.role}] ${m.content}`).join("\n\n");
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), SESSION_SUMMARY_TIMEOUT_MS);
+  try {
+    const client = new Anthropic({ apiKey });
+    const response = await client.messages.create({
+      model: REFLECTION_MODEL,
+      max_tokens: 500,
+      system: SESSION_SUMMARY_PROMPT,
+      messages: [{ role: "user", content: `Conversation:
+${transcript}` }]
+    }, { signal: controller.signal });
+    return response.content.filter((b) => b.type === "text").map((b) => "text" in b ? b.text : "").join("");
+  } catch (err) {
+    if (err instanceof Error && err.name === "AbortError") {
+      console.error(`[session-summary] Haiku call timed out after ${SESSION_SUMMARY_TIMEOUT_MS}ms`);
+    } else {
+      console.error(`[session-summary] Haiku call failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function writeEndOfTurnSummary(accountId, history) {
+  const now = Date.now();
+  const lastWrite = lastSummaryWrite.get(accountId) ?? 0;
+  if (now - lastWrite < SUMMARY_RATE_LIMIT_MS) {
+    return;
+  }
+  const summary = await generateSessionSummary(history);
+  if (!summary) return;
+  await writeSessionSummary(accountId, summary);
+  lastSummaryWrite.set(accountId, Date.now());
+}
 var MANAGED_WORK_BUDGET_RATIO = 0.5;
 var TOOL_SCHEMA_OVERHEAD_TOKENS = 15e3;
 function estimateTokens(text) {
@@ -6503,6 +6672,9 @@ async function* invokeManagedAdminAgent(message, systemPrompt, accountDir, accou
             if (responseText) persistMessage(convId, "assistant", responseText, accountId, capturedTokens, assistantTimestamp).catch(() => {
             });
           }
+          writeEndOfTurnSummary(accountId, afterHistory).catch(
+            (err) => console.error(`[session-summary] end-of-turn write failed: ${err instanceof Error ? err.message : String(err)}`)
+          );
         }
         yield event;
       }
@@ -6581,18 +6753,32 @@ async function* invokePublicAgent(message, systemPrompt, accountId, accountDir,
       }
     }
   }
+  const history = sessionKey ? getMessageHistory(sessionKey) : [];
   const fetchOptions = {
     ...agentSlug ? { agentSlug } : {},
     ...knowledgeKeywords && knowledgeKeywords.length > 0 ? { knowledgeKeywords } : {}
   };
+  const needsClassification = !(knowledgeBaked && !liveMemory);
+  const classifyStartMs = Date.now();
+  const classification = needsClassification ? await classifyMemoryQuery(message, history) : QUERY_CLASSIFIER_FALLBACK;
+  const classifyMs = Date.now() - classifyStartMs;
+  const effectiveQuery = classification.query ?? message;
+  if (needsClassification) {
+    streamLog.write(`[${isoTs()}] [public-query-classifier] search=${classification.search} effectiveQuery=${JSON.stringify(effectiveQuery.slice(0, 200))} reason=${classification.reason} latencyMs=${classifyMs}
+`);
+  }
   let system;
   if (knowledgeBaked && !liveMemory) {
     streamLog.write(`[${isoTs()}] [public-knowledge-source] baked \u2014 skipping memory-search (liveMemory=false)
+`);
+    system = systemPrompt;
+  } else if (!classification.search) {
+    streamLog.write(`[${isoTs()}] [public-knowledge-source] skipped \u2014 classifier (reason=${classification.reason})
 `);
     system = systemPrompt;
   } else if (knowledgeBaked && liveMemory) {
-    const memoryContext = await fetchMemoryContext(accountId, message, sessionKey, fetchOptions);
-    streamLog.write(`[${isoTs()}] [public-knowledge-source] baked+live agentSlug=${agentSlug ?? "none"} keywords=${knowledgeKeywords?.length ?? 0} result=${memoryContext ? `ok (${memoryContext.length} chars)` : "null"}
+    const memoryContext = await fetchMemoryContext(accountId, effectiveQuery, sessionKey, fetchOptions);
+    streamLog.write(`[${isoTs()}] [public-knowledge-source] baked+live agentSlug=${agentSlug ?? "none"} keywords=${knowledgeKeywords?.length ?? 0} effectiveQuery=${JSON.stringify(effectiveQuery.slice(0, 200))} result=${memoryContext ? `ok (${memoryContext.length} chars)` : "null"}
 `);
     system = memoryContext ? `${systemPrompt}
 
@@ -6600,8 +6786,8 @@ async function* invokePublicAgent(message, systemPrompt, accountId, accountDir,
 ${memoryContext}
 </live-memory>` : systemPrompt;
   } else {
-    const memoryContext = await fetchMemoryContext(accountId, message, sessionKey, fetchOptions);
-    streamLog.write(`[${isoTs()}] [public-knowledge-source] memory-search agentSlug=${agentSlug ?? "none"} keywords=${knowledgeKeywords?.length ?? 0} result=${memoryContext ? `ok (${memoryContext.length} chars)` : "null \u2014 agent has no knowledge"}
+    const memoryContext = await fetchMemoryContext(accountId, effectiveQuery, sessionKey, fetchOptions);
+    streamLog.write(`[${isoTs()}] [public-knowledge-source] memory-search agentSlug=${agentSlug ?? "none"} keywords=${knowledgeKeywords?.length ?? 0} effectiveQuery=${JSON.stringify(effectiveQuery.slice(0, 200))} result=${memoryContext ? `ok (${memoryContext.length} chars)` : "null \u2014 agent has no knowledge"}
 `);
     if (memoryContext) {
       streamLog.write(`[${isoTs()}] [public-memory-context] ${JSON.stringify(memoryContext.slice(0, 500))}${memoryContext.length > 500 ? "\u2026" : ""}
@@ -6613,7 +6799,6 @@ ${memoryContext}
 ${memoryContext}
 </memory>` : systemPrompt;
   }
-  const history = sessionKey ? getMessageHistory(sessionKey) : [];
   const sdkMessages = [
     ...history.map((m) => ({ role: m.role, content: m.content })),
     { role: "user", content: message }

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

@@ -87,9 +87,14 @@ For the most recent session: call `session-list` with `limit: 1`, then call `ses
 
 ## Session Memory
 
-The platform automatically injects recalled context into your system prompt as a `<previous-context>` section. This includes the most recent session summary and all open/active tasks. Treat this as background context — it informs your awareness but does not override the current conversation.
+The platform automatically injects recalled context into your system prompt as a `<previous-context>` section. This includes the most recent session summary and all open/active tasks. The platform rejects stale summaries (older than 48 hours) — when present, the summary is recent and trustworthy.
 
-When `<previous-context>` is present, use it to orient yourself and greet the owner with awareness of prior work and outstanding tasks. When absent, Neo4j was unreachable or no prior context exists — proceed normally.
+When `<previous-context>` is present:
+- **Trust the session summary for state orientation.** It reflects the end of the most recent session. Do not re-verify claims already described — if the summary says onboarding is complete, do not call `onboarding-get`. If it names tasks in progress, acknowledge and resume them.
+- **Do not re-research context captured in the summary.** When the summary describes work in progress, outstanding tasks, or recent decisions, pick up from that state. Redundant memory-search or tool calls for information already in the summary waste the owner's time.
+- Use it to greet the owner with awareness of prior work and outstanding tasks.
+
+When `<previous-context>` is absent, Neo4j was unreachable or no prior context exists — proceed normally, using tool calls to establish state.
 
 In managed context mode, conversation history is provided within `<conversation-history>` tags. Use `session-compact-status` to retrieve older archived context if needed.