let-them-talk 3.5.1 → 3.6.0

package/office/outfits.js

@@ -0,0 +1,212 @@
+import * as THREE from 'three';
+
+// Build outfit overlays on top of the base character body.
+// Returns a group that gets added to the character group.
+// Outfit replaces/covers the base torso visually.
+export function buildOutfit(style, colors, charGroup) {
+  var outfitGroup = new THREE.Group();
+  outfitGroup.userData.isOutfit = true;
+  var shirtHex = new THREE.Color(colors.shirt_color || '#58a6ff').getHex();
+  var pantsHex = new THREE.Color(colors.pants_color || '#2d3748').getHex();
+  var mat = new THREE.MeshStandardMaterial({ color: shirtHex, roughness: 0.7 });
+  var mat2 = new THREE.MeshStandardMaterial({ color: shirtHex, roughness: 0.65 });
+
+  switch (style) {
+    case 'hoodie': {
+      // Hoodie body — slightly larger than torso, covers it
+      var hoodieMat = new THREE.MeshStandardMaterial({ color: shirtHex, roughness: 0.85 });
+      var hoodieBody = new THREE.Mesh(new THREE.BoxGeometry(0.34, 0.34, 0.21), hoodieMat);
+      hoodieBody.position.y = 0.58; hoodieBody.castShadow = true;
+      outfitGroup.add(hoodieBody);
+      // Hood (behind head)
+      var hood = new THREE.Mesh(new THREE.SphereGeometry(0.18, 12, 8, 0, Math.PI * 2, Math.PI * 0.3, Math.PI * 0.5), hoodieMat);
+      hood.position.set(0, 0.82, -0.08); hood.castShadow = true;
+      outfitGroup.add(hood);
+      // Kangaroo pocket
+      var pocketMat = new THREE.MeshStandardMaterial({ color: shirtHex, roughness: 0.9 });
+      pocketMat.color.multiplyScalar(0.85);
+      var pocket = new THREE.Mesh(new THREE.BoxGeometry(0.22, 0.1, 0.01), pocketMat);
+      pocket.position.set(0, 0.48, 0.11); pocket.castShadow = true;
+      outfitGroup.add(pocket);
+      // Drawstrings
+      var stringMat = new THREE.MeshStandardMaterial({ color: 0xdddddd, roughness: 0.5 });
+      [-0.04, 0.04].forEach(function(sx) {
+        var str = new THREE.Mesh(new THREE.CylinderGeometry(0.005, 0.005, 0.12, 4), stringMat);
+        str.position.set(sx, 0.7, 0.11);
+        outfitGroup.add(str);
+      });
+      // Arm sleeves (wider)
+      var sleeveMat = new THREE.MeshStandardMaterial({ color: shirtHex, roughness: 0.85 });
+      [-0.21, 0.21].forEach(function(sx) {
+        var sleeve = new THREE.Mesh(new THREE.BoxGeometry(0.11, 0.14, 0.11), sleeveMat);
+        sleeve.position.set(sx, 0.65, 0); sleeve.castShadow = true;
+        outfitGroup.add(sleeve);
+      });
+      break;
+    }
+    case 'suit': {
+      // Suit jacket — structured, slightly wider shoulders
+      var suitMat = new THREE.MeshStandardMaterial({ color: shirtHex, roughness: 0.5, metalness: 0.05 });
+      var jacket = new THREE.Mesh(new THREE.BoxGeometry(0.35, 0.34, 0.2), suitMat);
+      jacket.position.y = 0.58; jacket.castShadow = true;
+      outfitGroup.add(jacket);
+      // Lapels (v-shape on front)
+      var lapelMat = new THREE.MeshStandardMaterial({ color: shirtHex, roughness: 0.4 });
+      lapelMat.color.multiplyScalar(0.8);
+      var lapelGeo = new THREE.BufferGeometry();
+      var lv = new Float32Array([
+        -0.06, 0.08, 0.005,  0, -0.02, 0.005,  0, 0.08, 0.005,
+      ]);
+      lapelGeo.setAttribute('position', new THREE.BufferAttribute(lv, 3));
+      lapelGeo.computeVertexNormals();
+      var leftLapel = new THREE.Mesh(lapelGeo, lapelMat);
+      leftLapel.position.set(-0.05, 0.64, 0.1);
+      outfitGroup.add(leftLapel);
+      var rv = new Float32Array([
+        0.06, 0.08, 0.005,  0, -0.02, 0.005,  0, 0.08, 0.005,
+      ]);
+      var rLapelGeo = new THREE.BufferGeometry();
+      rLapelGeo.setAttribute('position', new THREE.BufferAttribute(rv, 3));
+      rLapelGeo.computeVertexNormals();
+      var rightLapel = new THREE.Mesh(rLapelGeo, lapelMat);
+      rightLapel.position.set(0.05, 0.64, 0.1);
+      outfitGroup.add(rightLapel);
+      // White shirt underneath (visible strip)
+      var shirtStrip = new THREE.Mesh(new THREE.BoxGeometry(0.06, 0.2, 0.005), new THREE.MeshStandardMaterial({ color: 0xf0f0f0, roughness: 0.4 }));
+      shirtStrip.position.set(0, 0.56, 0.103);
+      outfitGroup.add(shirtStrip);
+      // Buttons
+      var btnMat = new THREE.MeshStandardMaterial({ color: 0x222222, roughness: 0.3, metalness: 0.2 });
+      [0.6, 0.52].forEach(function(by) {
+        var btn = new THREE.Mesh(new THREE.SphereGeometry(0.01, 6, 4), btnMat);
+        btn.position.set(0, by, 0.105);
+        outfitGroup.add(btn);
+      });
+      // Shoulder pads
+      [-0.18, 0.18].forEach(function(sx) {
+        var pad = new THREE.Mesh(new THREE.BoxGeometry(0.08, 0.03, 0.16), suitMat);
+        pad.position.set(sx, 0.74, 0); pad.castShadow = true;
+        outfitGroup.add(pad);
+      });
+      break;
+    }
+    case 'dress': {
+      // Dress top (fitted torso)
+      var dressMat = new THREE.MeshStandardMaterial({ color: shirtHex, roughness: 0.6 });
+      var dressTop = new THREE.Mesh(new THREE.BoxGeometry(0.32, 0.3, 0.19), dressMat);
+      dressTop.position.y = 0.59; dressTop.castShadow = true;
+      outfitGroup.add(dressTop);
+      // Skirt (flared cylinder below torso)
+      var skirtGeo = new THREE.CylinderGeometry(0.12, 0.22, 0.22, 12);
+      var skirt = new THREE.Mesh(skirtGeo, dressMat);
+      skirt.position.y = 0.34; skirt.castShadow = true;
+      outfitGroup.add(skirt);
+      // Belt/waist band
+      var beltMat = new THREE.MeshStandardMaterial({ color: shirtHex, roughness: 0.4 });
+      beltMat.color.multiplyScalar(0.7);
+      var belt = new THREE.Mesh(new THREE.BoxGeometry(0.33, 0.03, 0.2), beltMat);
+      belt.position.y = 0.44; belt.castShadow = true;
+      outfitGroup.add(belt);
+      // Small bow at neckline
+      var bowMat = new THREE.MeshStandardMaterial({ color: shirtHex, roughness: 0.5 });
+      bowMat.color.multiplyScalar(0.75);
+      var bow = new THREE.Mesh(new THREE.SphereGeometry(0.02, 6, 4), bowMat);
+      bow.position.set(0, 0.74, 0.1);
+      outfitGroup.add(bow);
+      break;
+    }
+    case 'labcoat': {
+      // White lab coat over shirt
+      var coatMat = new THREE.MeshStandardMaterial({ color: 0xf5f5f0, roughness: 0.4 });
+      var coat = new THREE.Mesh(new THREE.BoxGeometry(0.36, 0.38, 0.21), coatMat);
+      coat.position.y = 0.56; coat.castShadow = true;
+      outfitGroup.add(coat);
+      // Coat extends lower (skirt portion)
+      var coatSkirt = new THREE.Mesh(new THREE.BoxGeometry(0.34, 0.12, 0.19), coatMat);
+      coatSkirt.position.y = 0.34; coatSkirt.castShadow = true;
+      outfitGroup.add(coatSkirt);
+      // Colored shirt underneath visible at collar
+      var underShirt = new THREE.Mesh(new THREE.BoxGeometry(0.12, 0.06, 0.005), new THREE.MeshStandardMaterial({ color: shirtHex, roughness: 0.6 }));
+      underShirt.position.set(0, 0.72, 0.108);
+      outfitGroup.add(underShirt);
+      // Pocket (left breast)
+      var pocketMat2 = new THREE.MeshStandardMaterial({ color: 0xe8e8e0, roughness: 0.5 });
+      var pocket2 = new THREE.Mesh(new THREE.BoxGeometry(0.08, 0.06, 0.005), pocketMat2);
+      pocket2.position.set(-0.1, 0.62, 0.108);
+      outfitGroup.add(pocket2);
+      // Pen in pocket
+      var pen = new THREE.Mesh(new THREE.CylinderGeometry(0.004, 0.004, 0.06, 4), new THREE.MeshStandardMaterial({ color: 0x2244aa, roughness: 0.3 }));
+      pen.position.set(-0.08, 0.66, 0.112);
+      outfitGroup.add(pen);
+      // Coat sleeves (white, over arms)
+      [-0.22, 0.22].forEach(function(sx) {
+        var sleeve = new THREE.Mesh(new THREE.BoxGeometry(0.1, 0.16, 0.1), coatMat);
+        sleeve.position.set(sx, 0.64, 0); sleeve.castShadow = true;
+        outfitGroup.add(sleeve);
+      });
+      break;
+    }
+    case 'vest': {
+      // Sleeveless vest over shirt
+      var vestMat = new THREE.MeshStandardMaterial({ color: shirtHex, roughness: 0.55 });
+      var vestBody = new THREE.Mesh(new THREE.BoxGeometry(0.32, 0.33, 0.19), vestMat);
+      vestBody.position.y = 0.58; vestBody.castShadow = true;
+      outfitGroup.add(vestBody);
+      // V-neck opening showing shirt
+      var vShirt = new THREE.Mesh(new THREE.BoxGeometry(0.1, 0.12, 0.005), new THREE.MeshStandardMaterial({ color: 0xf0f0f0, roughness: 0.5 }));
+      vShirt.position.set(0, 0.66, 0.098);
+      outfitGroup.add(vShirt);
+      // Buttons
+      var vBtnMat = new THREE.MeshStandardMaterial({ color: 0x222222, roughness: 0.3 });
+      [0.62, 0.56, 0.50].forEach(function(by) {
+        var btn = new THREE.Mesh(new THREE.SphereGeometry(0.008, 5, 4), vBtnMat);
+        btn.position.set(0.04, by, 0.1);
+        outfitGroup.add(btn);
+      });
+      break;
+    }
+    case 'jacket': {
+      // Casual zip-up jacket
+      var jacketMat = new THREE.MeshStandardMaterial({ color: shirtHex, roughness: 0.7 });
+      var jacketBody = new THREE.Mesh(new THREE.BoxGeometry(0.34, 0.34, 0.2), jacketMat);
+      jacketBody.position.y = 0.58; jacketBody.castShadow = true;
+      outfitGroup.add(jacketBody);
+      // Zipper (metallic line down center)
+      var zipMat = new THREE.MeshStandardMaterial({ color: 0xcccccc, roughness: 0.2, metalness: 0.6 });
+      var zip = new THREE.Mesh(new THREE.BoxGeometry(0.01, 0.28, 0.005), zipMat);
+      zip.position.set(0, 0.58, 0.105);
+      outfitGroup.add(zip);
+      // Zip pull tab
+      var tab = new THREE.Mesh(new THREE.BoxGeometry(0.015, 0.02, 0.008), zipMat);
+      tab.position.set(0, 0.66, 0.11);
+      outfitGroup.add(tab);
+      // Collar (standing)
+      var collarMat = new THREE.MeshStandardMaterial({ color: shirtHex, roughness: 0.65 });
+      collarMat.color.multiplyScalar(0.9);
+      var collar = new THREE.Mesh(new THREE.BoxGeometry(0.3, 0.06, 0.16), collarMat);
+      collar.position.set(0, 0.78, 0); collar.castShadow = true;
+      outfitGroup.add(collar);
+      // Sleeves
+      [-0.22, 0.22].forEach(function(sx) {
+        var sleeve = new THREE.Mesh(new THREE.BoxGeometry(0.1, 0.14, 0.1), jacketMat);
+        sleeve.position.set(sx, 0.65, 0); sleeve.castShadow = true;
+        outfitGroup.add(sleeve);
+      });
+      break;
+    }
+  }
+
+  charGroup.add(outfitGroup);
+  return outfitGroup;
+}
+
+export function removeOutfit(charGroup) {
+  var toRemove = [];
+  charGroup.children.forEach(function(c) {
+    if (c.userData && c.userData.isOutfit) toRemove.push(c);
+  });
+  toRemove.forEach(function(c) {
+    charGroup.remove(c);
+    c.traverse(function(ch) { if (ch.geometry) ch.geometry.dispose(); if (ch.material) ch.material.dispose(); });
+  });
+}

package/office/scene.js

@@ -0,0 +1,75 @@
+import * as THREE from 'three';
+import { CSS2DRenderer } from 'three/addons/renderers/CSS2DRenderer.js';
+import { SpectatorCamera } from './spectator-camera.js';
+import { S } from './state.js';
+
+export function initScene() {
+  S.container = document.getElementById('office-3d-container');
+  if (!S.container) return false;
+
+  S.scene = new THREE.Scene();
+  S.scene.background = new THREE.Color(0x0d1117);
+  S.scene.fog = new THREE.Fog(0x0d1117, 25, 55);
+
+  S.camera = new THREE.PerspectiveCamera(50, S.container.clientWidth / S.container.clientHeight, 0.1, 200);
+  S.camera.position.set(0, 12, 16);
+  S.camera.lookAt(0, 0, 0);
+
+  S.renderer = new THREE.WebGLRenderer({ antialias: true });
+  S.renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
+  S.renderer.setSize(S.container.clientWidth, S.container.clientHeight);
+  S.renderer.shadowMap.enabled = true;
+  S.renderer.shadowMap.type = THREE.PCFSoftShadowMap;
+  S.renderer.toneMapping = THREE.ACESFilmicToneMapping;
+  S.renderer.toneMappingExposure = 1.2;
+  S.container.appendChild(S.renderer.domElement);
+
+  S.cssRenderer = new CSS2DRenderer();
+  S.cssRenderer.setSize(S.container.clientWidth, S.container.clientHeight);
+  S.cssRenderer.domElement.style.position = 'absolute';
+  S.cssRenderer.domElement.style.top = '0';
+  S.cssRenderer.domElement.style.left = '0';
+  S.cssRenderer.domElement.style.pointerEvents = 'none';
+  S.container.appendChild(S.cssRenderer.domElement);
+
+  // Spectator camera — free movement, no limits
+  S.controls = new SpectatorCamera(S.camera, S.renderer.domElement);
+
+  // Lighting
+  var ambient = new THREE.AmbientLight(0xffffff, 0.5);
+  S.scene.add(ambient);
+
+  var dirLight = new THREE.DirectionalLight(0xffffff, 0.8);
+  dirLight.position.set(8, 12, 8);
+  dirLight.castShadow = true;
+  dirLight.shadow.mapSize.width = 2048;
+  dirLight.shadow.mapSize.height = 2048;
+  dirLight.shadow.camera.left = -15;
+  dirLight.shadow.camera.right = 15;
+  dirLight.shadow.camera.top = 15;
+  dirLight.shadow.camera.bottom = -15;
+  dirLight.shadow.camera.near = 0.5;
+  dirLight.shadow.camera.far = 30;
+  dirLight.shadow.bias = -0.001;
+  S.scene.add(dirLight);
+
+  var fillLight = new THREE.DirectionalLight(0x6c8aff, 0.15);
+  fillLight.position.set(-5, 8, -5);
+  S.scene.add(fillLight);
+
+  S.clock = new THREE.Clock();
+
+  S.resizeObserver = new ResizeObserver(function() {
+    if (!S.container || !S.running) return;
+    var w = S.container.clientWidth;
+    var h = S.container.clientHeight;
+    if (w <= 0 || h <= 0) return;
+    S.camera.aspect = w / h;
+    S.camera.updateProjectionMatrix();
+    S.renderer.setSize(w, h);
+    S.cssRenderer.setSize(w, h);
+  });
+  S.resizeObserver.observe(S.container);
+
+  return true;
+}

package/office/spectator-camera.js

@@ -0,0 +1,177 @@
+import * as THREE from 'three';
+
+// Spectator / fly camera — Unreal Engine style free movement
+// Left-drag: look around (rotate)
+// Right-drag: pan (strafe)
+// WASD: move forward/back/left/right
+// Q/E: down/up
+// Scroll: dolly forward/back
+// Shift: fast move
+// Middle-drag: also pan
+
+export function SpectatorCamera(camera, domElement) {
+  var self = this;
+  self.camera = camera;
+  self.domElement = domElement;
+  self.enabled = true;
+
+  // Movement
+  self.moveSpeed = 4;
+  self.fastMultiplier = 3;
+  self.scrollSpeed = 2;
+  self.lookSpeed = 0.003;
+  self.panSpeed = 0.01;
+  self.damping = 0.88;
+
+  // Internal state
+  var euler = new THREE.Euler(0, 0, 0, 'YXZ');
+  var velocity = new THREE.Vector3();
+  var moveDir = new THREE.Vector3();
+  var keys = {};
+  var isLeftDrag = false;
+  var isRightDrag = false;
+  var isMiddleDrag = false;
+  var lastMouse = { x: 0, y: 0 };
+
+  // Initialize euler from camera
+  euler.setFromQuaternion(camera.quaternion, 'YXZ');
+
+  // --- Event handlers ---
+  function onMouseDown(e) {
+    if (!self.enabled) return;
+    // Only capture if click is on the 3D canvas area
+    if (e.target !== domElement) return;
+    // Take focus away from any text input so WASD works
+    if (document.activeElement && document.activeElement !== document.body) {
+      document.activeElement.blur();
+    }
+    if (e.button === 0) isLeftDrag = true;
+    if (e.button === 2) isRightDrag = true;
+    if (e.button === 1) isMiddleDrag = true;
+    lastMouse.x = e.clientX;
+    lastMouse.y = e.clientY;
+    e.preventDefault();
+  }
+
+  function onMouseUp(e) {
+    if (e.button === 0) isLeftDrag = false;
+    if (e.button === 2) isRightDrag = false;
+    if (e.button === 1) isMiddleDrag = false;
+  }
+
+  function onMouseMove(e) {
+    if (!self.enabled) return;
+    var dx = e.clientX - lastMouse.x;
+    var dy = e.clientY - lastMouse.y;
+    lastMouse.x = e.clientX;
+    lastMouse.y = e.clientY;
+
+    if (isRightDrag) {
+      // Look around (rotate)
+      euler.y -= dx * self.lookSpeed;
+      euler.x -= dy * self.lookSpeed;
+      euler.x = Math.max(-Math.PI / 2 + 0.01, Math.min(Math.PI / 2 - 0.01, euler.x));
+      camera.quaternion.setFromEuler(euler);
+    }
+
+    if (isLeftDrag || isMiddleDrag) {
+      // Pan (strafe)
+      var right = new THREE.Vector3();
+      var up = new THREE.Vector3();
+      camera.getWorldDirection(new THREE.Vector3());
+      right.setFromMatrixColumn(camera.matrixWorld, 0);
+      up.setFromMatrixColumn(camera.matrixWorld, 1);
+      camera.position.addScaledVector(right, -dx * self.panSpeed);
+      camera.position.addScaledVector(up, dy * self.panSpeed);
+    }
+  }
+
+  function onWheel(e) {
+    if (!self.enabled) return;
+    // Check if scroll is over the 3D container
+    var rect = domElement.getBoundingClientRect();
+    if (e.clientX < rect.left || e.clientX > rect.right || e.clientY < rect.top || e.clientY > rect.bottom) return;
+    var forward = new THREE.Vector3();
+    camera.getWorldDirection(forward);
+    var amount = -e.deltaY * 0.01 * self.scrollSpeed;
+    camera.position.addScaledVector(forward, amount);
+    e.preventDefault();
+  }
+
+  function isTyping() {
+    var el = document.activeElement;
+    if (!el) return false;
+    var tag = el.tagName;
+    return tag === 'INPUT' || tag === 'TEXTAREA' || tag === 'SELECT' || el.isContentEditable;
+  }
+
+  function onKeyDown(e) {
+    if (!self.enabled || isTyping()) return;
+    keys[e.code] = true;
+  }
+
+  function onKeyUp(e) {
+    keys[e.code] = false;
+  }
+
+  function onContextMenu(e) {
+    if (e.target === domElement) e.preventDefault();
+  }
+
+  // --- Public methods ---
+  self.update = function(dt) {
+    if (!self.enabled) return;
+
+    var speed = self.moveSpeed * (keys['ShiftLeft'] || keys['ShiftRight'] ? self.fastMultiplier : 1);
+
+    // Build movement direction in camera space
+    moveDir.set(0, 0, 0);
+    if (keys['KeyW'] || keys['ArrowUp']) moveDir.z -= 1;
+    if (keys['KeyS'] || keys['ArrowDown']) moveDir.z += 1;
+    if (keys['KeyA'] || keys['ArrowLeft']) moveDir.x -= 1;
+    if (keys['KeyD'] || keys['ArrowRight']) moveDir.x += 1;
+    if (keys['KeyE'] || keys['Space']) moveDir.y += 1;
+    if (keys['KeyQ'] || keys['ControlLeft']) moveDir.y -= 1;
+
+    if (moveDir.lengthSq() > 0) {
+      moveDir.normalize();
+      // Transform to world space using camera orientation
+      var forward = new THREE.Vector3();
+      var right = new THREE.Vector3();
+      camera.getWorldDirection(forward);
+      right.crossVectors(forward, camera.up).normalize();
+      var worldUp = new THREE.Vector3(0, 1, 0);
+
+      // Forward/back along camera look direction (projected on XZ for ground feel, or full 3D)
+      velocity.addScaledVector(forward, -moveDir.z * speed * dt);
+      velocity.addScaledVector(right, moveDir.x * speed * dt);
+      velocity.addScaledVector(worldUp, moveDir.y * speed * dt);
+    }
+
+    // Apply velocity with damping
+    camera.position.add(velocity);
+    velocity.multiplyScalar(self.damping);
+
+    // Kill tiny velocities
+    if (velocity.lengthSq() < 0.0001) velocity.set(0, 0, 0);
+  };
+
+  self.dispose = function() {
+    domElement.removeEventListener('mousedown', onMouseDown);
+    document.removeEventListener('mouseup', onMouseUp);
+    document.removeEventListener('mousemove', onMouseMove);
+    domElement.removeEventListener('wheel', onWheel);
+    document.removeEventListener('keydown', onKeyDown);
+    document.removeEventListener('keyup', onKeyUp);
+    domElement.removeEventListener('contextmenu', onContextMenu);
+  };
+
+  // --- Bind events ---
+  domElement.addEventListener('mousedown', onMouseDown);
+  document.addEventListener('mouseup', onMouseUp);
+  document.addEventListener('mousemove', onMouseMove);
+  domElement.addEventListener('wheel', onWheel, { passive: false });
+  document.addEventListener('keydown', onKeyDown);
+  document.addEventListener('keyup', onKeyUp);
+  domElement.addEventListener('contextmenu', onContextMenu);
+}

package/office/state.js

@@ -0,0 +1,25 @@
+// Shared mutable state for the 3D office system.
+// All modules import S and read/write through it.
+export const S = {
+  scene: null,
+  camera: null,
+  renderer: null,
+  cssRenderer: null,
+  controls: null,
+  container: null,
+  running: false,
+  animationId: null,
+  clock: null,
+  agents3d: {},
+  lastProcessedMsg: 0,
+  currentEnv: 'modern',
+  furnitureGroup: null,
+  deskMeshes: [],
+  syncInterval: null,
+  resizeObserver: null,
+  cachedTasks: [],
+  conversationVelocity: 0,
+  monitorCanvases: {},
+  fpsCounter: 0,
+  fpsTime: 0,
+};

package/package.json

@@ -1,56 +1,58 @@
-{
-  "name": "let-them-talk",
-  "version": "3.5.1",
-  "description": "MCP message broker + web dashboard for inter-agent communication. Let AI CLI agents talk to each other.",
-  "main": "server.js",
-  "bin": {
-    "agent-bridge": "./cli.js",
-    "let-them-talk": "./cli.js"
-  },
-  "scripts": {
-    "start": "node server.js",
-    "dashboard": "node dashboard.js",
-    "test": "echo \"No tests yet\""
-  },
-  "engines": {
-    "node": ">=16.0.0"
-  },
-  "files": [
-    "server.js",
-    "dashboard.js",
-    "dashboard.html",
-    "cli.js",
-    "templates/",
-    "conversation-templates/",
-    "logo.png",
-    "LICENSE",
-    "SECURITY.md",
-    "CHANGELOG.md"
-  ],
-  "keywords": [
-    "mcp",
-    "claude",
-    "claude-code",
-    "gemini-cli",
-    "codex-cli",
-    "agent",
-    "multi-agent",
-    "communication",
-    "message-broker",
-    "ai-agents",
-    "let-them-talk"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Dekelelz/let-them-talk.git"
-  },
-  "homepage": "https://talk.unrealai.studio",
-  "bugs": {
-    "url": "https://github.com/Dekelelz/let-them-talk/issues"
-  },
-  "author": "Dekelelz <contact@talk.unrealai.studio>",
-  "license": "SEE LICENSE IN LICENSE",
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "1.27.1"
-  }
-}
+{
+  "name": "let-them-talk",
+  "version": "3.6.0",
+  "description": "MCP message broker + web dashboard for inter-agent communication. Let AI CLI agents talk to each other.",
+  "main": "server.js",
+  "bin": {
+    "agent-bridge": "./cli.js",
+    "let-them-talk": "./cli.js"
+  },
+  "scripts": {
+    "start": "node server.js",
+    "dashboard": "node dashboard.js",
+    "test": "echo \"No tests yet\""
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "files": [
+    "server.js",
+    "dashboard.js",
+    "dashboard.html",
+    "office/",
+    "mods/",
+    "cli.js",
+    "templates/",
+    "conversation-templates/",
+    "logo.png",
+    "LICENSE",
+    "SECURITY.md",
+    "CHANGELOG.md"
+  ],
+  "keywords": [
+    "mcp",
+    "claude",
+    "claude-code",
+    "gemini-cli",
+    "codex-cli",
+    "agent",
+    "multi-agent",
+    "communication",
+    "message-broker",
+    "ai-agents",
+    "let-them-talk"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Dekelelz/let-them-talk.git"
+  },
+  "homepage": "https://talk.unrealai.studio",
+  "bugs": {
+    "url": "https://github.com/Dekelelz/let-them-talk/issues"
+  },
+  "author": "Dekelelz <contact@talk.unrealai.studio>",
+  "license": "SEE LICENSE IN LICENSE",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "1.27.1"
+  }
+}