@rubytech/create-maxy 1.0.884 → 1.0.886

package/package.json

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

package/payload/platform/neo4j/schema.cypher

@@ -498,9 +498,16 @@ OPTIONS {
 CREATE CONSTRAINT message_id_unique IF NOT EXISTS
 FOR (m:Message) REQUIRE m.messageId IS UNIQUE;
 
+// Task 1007 — Message.sessionKey is the canonical conversation pointer.
+// The legacy m.conversationId index stays until follow-up Task 1011 (final
+// cutover, after the full code-rename slice lands and no path reads
+// m.conversationId).
 CREATE INDEX message_conversation IF NOT EXISTS
 FOR (m:Message) ON (m.conversationId);
 
+CREATE INDEX message_session_key IF NOT EXISTS
+FOR (m:Message) ON (m.sessionKey);
+
 CREATE VECTOR INDEX message_embedding IF NOT EXISTS
 FOR (m:Message) ON (m.embedding)
 OPTIONS {

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

@@ -52,7 +52,7 @@ Tools are available via the `admin` MCP server.
 
 `logs-read { type: "agent-stream" }` is the canonical name for the per-conversation tool-use/tool-result archive previously called `system`; both names work and the legacy alias is preserved.
 
-**Stream log is the primary diagnostic surface for an in-progress conversation.** The parent-process console fan-out tee in [`platform/ui/app/lib/claude-agent/logging.ts`](../../ui/app/lib/claude-agent/logging.ts) appends every `[<tag>]`-prefixed `console.error` / `console.log` line to every active conversation's stream log alongside `server.log`. For diagnosing an in-conversation issue (WhatsApp inbound, Cloudflare action, persist write, baileys error), call `logs-read { type: "agent-stream" }` first — the stream log carries both the agent lifecycle AND the parent-process events that occurred during the session window. `logs-read { type: "server" }` becomes the cross-session escape hatch (filtering across conversations or for events outside any session window), not the default.
+**Stream log is the primary diagnostic surface for an in-progress session.** Every stream log is named by sessionKey and exists from the first token. The parent-process console fan-out tee in [`platform/ui/app/lib/claude-agent/logging.ts`](../../ui/app/lib/claude-agent/logging.ts) appends every `[<tag>]`-prefixed `console.error` / `console.log` line to every active session's stream log alongside `server.log`. For diagnosing an in-session issue (WhatsApp inbound, Cloudflare action, persist write, baileys error), call `logs-read { sessionKey: "<…>" }` first — the stream log carries both the agent lifecycle AND the parent-process events that occurred during the session window. The `conversationId` parameter remains a legacy alias resolving to the same sessionKey-named file. `logs-read { type: "server" }` is the cross-session escape hatch for events outside any single session window.
 
 ## Skills
 

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

@@ -1255,7 +1255,7 @@ server.tool("agent-list", "List all public (non-admin) agents with their full co
         };
     }
 });
-eagerTool(server, "logs-read", "Read recent logs. Stream logs (type=agent-stream/error/session/public) are per-conversation — pass `conversationId` to retrieve a single conversation's log from first [spawn] to final [process-exit]. type=agent-stream: per-conversation tool-use/tool-result archive (every `[tool-use]` and `[tool-result]` pair with full input + output JSON, plus raw Claude stream-json, agent events, and MCP server stderr via tee). USE THIS when investigating what an agent ACTUALLY did with its tools — server.log only carries `[persist] tool-call persisted` markers, not bodies. (`type=system` is a backwards-compatible alias for the same archive.) type=session: SSE events sent to client. type=error: Claude subprocess stderr (raw — NODE_DEBUG HTTP/NET/UNDICI traces land in agent-stream via the stream tee, not here). type=heartbeat: platform event dispatcher (check-due-events cron). type=public: public agent diagnostic log. type=server: platform server log. type=mcp: MCP server stderr (per-plugin raw). type=vnc: VNC browser viewer lifecycle. sessionKey: grep legacy sessionKey-tagged lines across all logs (useful for pre-per-conversation artefacts). When conversationId is provided, reads the single per-conversation file for the requested type (or dumps all type files for that conversationId if type is omitted).", {
+eagerTool(server, "logs-read", "Read recent logs. Stream logs (type=agent-stream/error/session/public) are per-session — pass `sessionKey` (preferred) or the legacy `conversationId` alias to retrieve a single session's log from first [spawn] to final [process-exit]. type=agent-stream: per-session tool-use/tool-result archive (every `[tool-use]` and `[tool-result]` pair with full input + output JSON, plus raw Claude stream-json, agent events, and MCP server stderr via tee). USE THIS when investigating what an agent ACTUALLY did with its tools — server.log only carries `[persist] tool-call persisted` markers, not bodies. (`type=system` is a backwards-compatible alias for the same archive.) type=session: SSE events sent to client. type=error: Claude subprocess stderr (raw — NODE_DEBUG HTTP/NET/UNDICI traces land in agent-stream via the stream tee, not here). type=heartbeat: platform event dispatcher (check-due-events cron). type=public: public agent diagnostic log. type=server: platform server log. type=mcp: MCP server stderr (per-plugin raw). type=vnc: VNC browser viewer lifecycle.", {
     type: z.enum(["agent-stream", "system", "session", "error", "heartbeat", "public", "server", "mcp", "vnc"]).optional(),
     lines: z.number().optional(),
     sessionKey: z.string().optional(),
@@ -1263,28 +1263,11 @@ eagerTool(server, "logs-read", "Read recent logs. Stream logs (type=agent-stream
 }, async ({ type, lines = 50, sessionKey, conversationId }) => {
     try {
         const LOG_DIR = resolve(getAccountDir(), "logs");
-        // Task 532: conversationId mode — reads the exact per-conversation file.
-        // Precedes the sessionKey grep path because a conversationId is the
-        // tightest identity and answers single-conversation questions without
-        // a grep pass across every log file.
-        //
-        // Task 671: resolves two filename shapes from the same identifier —
-        //   FULL:     {prefix}-{conversationId}.log      (post first-completed-turn flush)
-        //   PREFLUSH: {prefix}-preflush-{id:0:12}.log    (pre-flush, first turn;
-        //                                                 slice is of the sessionKey)
-        // Full is tried first; if absent, preflush is the fallback. If both
-        // exist, full wins and the preflush sibling is logged to server.log
-        // as stale (best-effort housekeeping signal).
-        //
-        // Identity note: for the abrupt-exit case this branch exists to solve,
-        // the operator passes the sessionKey (no conversationId was ever
-        // assigned). For post-flush retrievals the operator passes the
-        // conversationId and the FULL file is expected to exist.
-        //
-        // MIRROR: keep the two-shape contract in sync with:
-        //   - platform/ui/app/lib/logs-read-resolve.ts (canonical TS helper + tests)
-        //   - platform/scripts/logs-read.sh            (per_conversation_mode)
-        if (conversationId) {
+        // Task 1006 — sessionKey is the single identifier on disk.
+        // `conversationId` is retained as a legacy alias that maps to the
+        // sessionKey-named file; Task 1007 will collapse the alias in the UI.
+        const idForResolve = sessionKey ?? conversationId;
+        if (idForResolve) {
             if (!existsSync(LOG_DIR)) {
                 return { content: [{ type: "text", text: `Log directory does not exist: ${LOG_DIR}` }] };
             }
@@ -1299,41 +1282,29 @@ eagerTool(server, "logs-read", "Read recent logs. Stream logs (type=agent-stream
             const prefix = prefixMap[resolvedType];
             if (!prefix) {
                 return {
-                    content: [{ type: "text", text: `type=${resolvedType} is not per-conversation. Valid per-conversation types: agent-stream, error, session, public. For platform-scoped types (server, vnc, heartbeat, mcp) omit conversationId.` }],
+                    content: [{ type: "text", text: `type=${resolvedType} is not per-session. Valid per-session types: agent-stream, error, session, public. For platform-scoped types (server, vnc, heartbeat, mcp) omit the id.` }],
                     isError: true,
                 };
             }
-            const fullName = `${prefix}-${conversationId}.log`;
-            const preflushName = `${prefix}-preflush-${conversationId.slice(0, 12)}.log`;
-            const fullPath = resolve(LOG_DIR, fullName);
-            const preflushPath = resolve(LOG_DIR, preflushName);
-            // Pass 1: full first. If present, emit stale-preflush signal on sibling.
-            if (existsSync(fullPath)) {
-                if (existsSync(preflushPath)) {
-                    // Best-effort housekeeping emit — retrieval must not fail if
-                    // server.log is unwritable.
-                    try {
-                        const ts = new Date().toISOString();
-                        appendFileSync(resolve(CONFIG_DIR, "logs", "server.log"), `${ts} [logs-read] stale-preflush-detected path=${preflushPath}\n`);
-                    }
-                    catch {
-                        // swallow
-                    }
-                }
-                const result = execFileSync("tail", ["-n", String(lines), fullPath], { timeout: 5000 }).toString();
-                return { content: [{ type: "text", text: `# ${fullName} (matched_shape=full)\n\n${result}` }] };
+            const fileName = `${prefix}-${idForResolve}.log`;
+            const filePath = resolve(LOG_DIR, fileName);
+            if (existsSync(filePath)) {
+                const result = execFileSync("tail", ["-n", String(lines), filePath], { timeout: 5000 }).toString();
+                return { content: [{ type: "text", text: `# ${fileName}\n\n${result}` }] };
+            }
+            // Emit missing-on-resolve so the writer-side existence contract is
+            // the authoritative signal. One such line on any device is a P0.
+            try {
+                const ts = new Date().toISOString();
+                appendFileSync(resolve(CONFIG_DIR, "logs", "server.log"), `${ts} [log-tee] missing-on-resolve sessionKey=${idForResolve.slice(0, 8)} surface=mcp-logs-read reason="file-not-found-in-LOG_DIR"\n`);
             }
-            // Pass 2: preflush fallback.
-            if (existsSync(preflushPath)) {
-                const result = execFileSync("tail", ["-n", String(lines), preflushPath], { timeout: 5000 }).toString();
-                return { content: [{ type: "text", text: `# ${preflushName} (matched_shape=preflush)\n\n${result}` }] };
+            catch {
+                // best-effort
             }
-            // Neither shape present: enumerate both filenames in the miss
-            // message so the reader sees exactly what was tried.
             return {
                 content: [{
                         type: "text",
-                        text: `No log file found for conversationId=${conversationId} type=${resolvedType}. tried=[${fullPath}, ${preflushPath}] reason=file-not-found-in-either-shape`,
+                        text: `No log file found for id=${idForResolve} type=${resolvedType}. tried=[${filePath}] reason=file-not-found`,
                     }],
             };
         }