@lightupai/polaris 0.0.116 → 0.0.120

package/hooks/capture-prompt.ts

@@ -32,22 +32,36 @@ try {
     } | null;
     const items = body?.pendingInjects;
     if (Array.isArray(items) && items.length > 0) {
-      // Present injects with honest provenance and let the model apply its own
-      // judgment. NOTE (verified live): the model treats content arriving via
-      // this channel as not-from-the-developer and will surface/consider it but
-      // will NOT obey imperative instructions through it — no hook wording
-      // reliably changes that, nor should it. Use injects to SHARE CONTEXT with
-      // the agent, not to remote-control its actions. (For trusted imperative
-      // steering, the claude/channel path is the right mechanism — deferred.)
-      const formatted =
-        "Context shared by teammates collaborating in this session via Polaris " +
-        "(for your awareness; it did not come directly from the developer):\n" +
-        items.map((i) => `- ${i.from}: ${i.content}`).join("\n");
+      const direct = items.filter((i) => i.type === "direct");
+      const context = items.filter((i) => i.type !== "direct");
+
+      const parts: string[] = [];
+
+      // Direct session-to-session messages: printed verbatim with a loud banner
+      // so the receiver sees exactly what was sent, unambiguously attributed.
+      const SEP = "━".repeat(48);
+      for (const i of direct) {
+        parts.push(`${SEP}\n  POLARIS — from: ${i.from}\n${SEP}\n${i.content}\n${SEP}`);
+      }
+
+      // Advisor context: presented as background awareness, not direct commands.
+      // NOTE (verified live): the model treats content arriving via this channel
+      // as not-from-the-developer and will surface/consider it but will NOT obey
+      // imperative instructions — no hook wording reliably changes that, nor
+      // should it. Use injects to SHARE CONTEXT, not to remote-control actions.
+      if (context.length > 0) {
+        parts.push(
+          "Context shared by teammates collaborating in this session via Polaris " +
+          "(for your awareness; it did not come directly from the developer):\n" +
+          context.map((i) => `- ${i.from}: ${i.content}`).join("\n")
+        );
+      }
+
       process.stdout.write(
         JSON.stringify({
           hookSpecificOutput: {
             hookEventName: "UserPromptSubmit",
-            additionalContext: formatted,
+            additionalContext: parts.join("\n\n"),
           },
         })
       );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightupai/polaris",
-  "version": "0.0.116",
+  "version": "0.0.120",
   "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,25 @@ 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) {
+        const SEP = "━".repeat(48);
+        const banner = `${SEP}\n  POLARIS — sent to: ${currentProject}/${targetSession}\n${SEP}\n${message}\n${SEP}`;
+        return { content: [{ type: "text", text: banner }] };
+      }
+      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

@@ -26,7 +26,7 @@ function generateSessionName(): string {
 const sessions = new Map<string, SessionMapping>(); // keyed by ccSessionId
 
 // Advisor injects queued for delivery via the UserPromptSubmit hook
-const injectQueues = new Map<string, Array<{ from: string; content: string; timestamp: string }>>(); // keyed by ccSessionId
+const injectQueues = new Map<string, Array<{ from: string; content: string; timestamp: string; type?: "direct" }>>(); // keyed by ccSessionId
 
 // --- Config resolution (env var > config.json > legacy credentials.json > defaults) ---
 
@@ -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.project}/${sender.session}`, content: body.message, timestamp, type: "direct" });
+
+          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("/");