@lightupai/polaris 0.0.114 → 0.0.117

package/hooks/statusline.sh

@@ -57,8 +57,28 @@ if [ -f "$INSTALLED_PKG" ]; then
     ) &
   fi
 
-  if [ -n "$CACHED_LATEST" ] && [ -n "$INSTALLED_VERSION" ] && [ "$CACHED_LATEST" != "$INSTALLED_VERSION" ]; then
-    UPDATE_MSG=" [update available: v${CACHED_LATEST}]"
+  # Only notify when the registry version is strictly newer (prevents false
+  # positives when a freshly-updated client's cache still shows an older latest).
+  if [ -n "$CACHED_LATEST" ] && [ -n "$INSTALLED_VERSION" ]; then
+    _ver_gt() {
+      # Returns true (0) when $1 is semver-greater than $2
+      # Works for the "0.0.NNN" format used by polaris.
+      IFS=. read -r _a1 _a2 _a3 <<_EOF_
+$1
+_EOF_
+      IFS=. read -r _b1 _b2 _b3 <<_EOF_
+$2
+_EOF_
+      [ "${_a1:-0}" -gt "${_b1:-0}" ] && return 0
+      [ "${_a1:-0}" -lt "${_b1:-0}" ] && return 1
+      [ "${_a2:-0}" -gt "${_b2:-0}" ] && return 0
+      [ "${_a2:-0}" -lt "${_b2:-0}" ] && return 1
+      [ "${_a3:-0}" -gt "${_b3:-0}" ] && return 0
+      return 1
+    }
+    if _ver_gt "$CACHED_LATEST" "$INSTALLED_VERSION"; then
+      UPDATE_MSG=" [v${INSTALLED_VERSION}, update available]"
+    fi
   fi
 fi
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightupai/polaris",
-  "version": "0.0.114",
+  "version": "0.0.117",
   "description": "Record and stream Claude Code sessions to Slack. Like Gong for AI coding — capture every prompt, response, and tool call. Multiplayer collaboration across AI coding agents.",
   "keywords": [
     "claude-code",

package/src/client/client.ts

@@ -143,6 +143,18 @@ mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
         properties: {},
       },
     },
+    {
+      name: "polaris_send",
+      description: "Send a message directly to a sibling session in the same project. The message is injected into that session's next prompt and logged in both sessions' Polaris timelines.",
+      inputSchema: {
+        type: "object" as const,
+        properties: {
+          session: { type: "string", description: "Target session name (e.g. 'feedback')" },
+          message: { type: "string", description: "Message to send" },
+        },
+        required: ["session", "message"],
+      },
+    },
     {
       name: "polaris_reply",
       description: "Send a message to the project floor (visible to all advisors, and to the linked Slack channel if a floor is connected).",
@@ -338,6 +350,23 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
     }
   }
 
+  if (name === "polaris_send") {
+    if (!currentProject) {
+      return { content: [{ type: "text", text: "Not connected to a Polaris session. Use polaris_connect first." }] };
+    }
+    const { session: targetSession, message } = args as { session: string; message: string };
+    try {
+      const res = await daemonPost("/send", { ccSessionId: CC_SESSION_ID, targetSession, message });
+      if (res.ok) {
+        return { content: [{ type: "text", text: `Message sent to session '${targetSession}'.` }] };
+      }
+      const body = await res.json();
+      return { content: [{ type: "text", text: `Failed to send: ${(body as { error?: string }).error ?? res.status}` }] };
+    } catch {
+      return { content: [{ type: "text", text: "Failed to reach the daemon." }] };
+    }
+  }
+
   if (name === "polaris_reply") {
     if (!currentProject) {
       return { content: [{ type: "text", text: "Not connected to a Polaris session. Use polaris_connect first." }] };

package/src/daemon/daemon.ts

@@ -1139,6 +1139,79 @@ export function startDaemon(port = Number(process.env.POLARIS_DAEMON_PORT ?? 432
         }
       }
 
+      // POST /send — deliver a message to a sibling session and log it on both timelines
+      if (method === "POST" && pathname === "/send") {
+        try {
+          const body = (await req.json()) as { ccSessionId: string; targetSession: string; message: string };
+          if (!body.ccSessionId || !body.targetSession || !body.message) {
+            return error("ccSessionId, targetSession, and message required", 400);
+          }
+          const sender = sessions.get(body.ccSessionId);
+          if (!sender || !sender.project) return error("Not connected", 400);
+
+          // Find the target session by name within the same project
+          const target = Array.from(sessions.values()).find(
+            (m) => m.project === sender.project && m.session === body.targetSession && m.ccSessionId !== body.ccSessionId
+          );
+          if (!target) {
+            return error(`Session '${body.targetSession}' is not connected in project '${sender.project}'`, 404);
+          }
+
+          const serviceUrl = getServiceUrlForProfile(sender.profile);
+          const headers = await authHeadersForProfile(sender.profile);
+          const timestamp = new Date().toISOString();
+
+          // 1. Log outbound event on sender's timeline
+          await fetch(`${serviceUrl}/projects/${sender.project}/sessions/${sender.session}/events`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({
+              sender: sender.agent,
+              payload: {
+                hook_event_name: "SendMessage",
+                session_id: body.ccSessionId,
+                to: body.targetSession,
+                message: body.message,
+              },
+            }),
+          });
+
+          // 2. Log inbound event on target's timeline (attributed to the sender's session name)
+          await fetch(`${serviceUrl}/projects/${target.project}/sessions/${target.session}/events`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({
+              sender: sender.agent,
+              payload: {
+                hook_event_name: "ReceiveMessage",
+                session_id: target.ccSessionId,
+                from: sender.session,
+                message: body.message,
+              },
+            }),
+          });
+
+          // 3. Inject into target's local queue for delivery on next UserPromptSubmit
+          let queue = injectQueues.get(target.ccSessionId);
+          if (!queue) {
+            queue = [];
+            injectQueues.set(target.ccSessionId, queue);
+          }
+          // Also register under any alias ccSessionId the target may be using
+          for (const [id, m] of sessions) {
+            if (m.project === target.project && m.session === target.session && !injectQueues.has(id)) {
+              injectQueues.set(id, queue);
+            }
+          }
+          queue.push({ from: sender.session, content: body.message, timestamp });
+
+          await logEvent("/send", body, undefined, { project: sender.project, session: sender.session, ccSessionId: body.ccSessionId });
+          return json({ status: "delivered", from: sender.session, to: body.targetSession });
+        } catch {
+          return error("Invalid JSON", 400);
+        }
+      }
+
       // GET /context/:ccSessionId/:session — proxy context fetch from cloud API
       if (method === "GET" && pathname.match(/^\/context\/[^/]+\/[^/]+$/)) {
         const parts = pathname.split("/");