slashvibe-mcp 0.8.21 → 0.8.23

package/config.js

@@ -82,22 +82,40 @@ function load() {
 
 function save(config) {
   ensureDir();
-  // Load existing to preserve fields we're not updating
+  // Load existing to preserve fields we're not updating.
+  //
+  // Every field below falls back to `existing`, so a file that failed to parse
+  // does not merge into this write — it VANISHES from it, and the auth token
+  // with it. Signing someone out is not a repair for a file we could not read.
   let existing = {};
-  try {
-    if (fs.existsSync(PRIMARY_CONFIG)) {
+  if (fs.existsSync(PRIMARY_CONFIG)) {
+    try {
       existing = JSON.parse(fs.readFileSync(PRIMARY_CONFIG, 'utf8'));
+    } catch (e) {
+      console.error('Refusing to write config: the file on disk could not be read.', e.message);
+      return false;
     }
-  } catch (e) {}
+  }
+
+  // "Did the caller mention this field?" — distinct from "is its value truthy".
+  // The fallbacks below are truthy-or-existing, which cannot express a removal:
+  // removeKeypair() deleted the keys and save() restored them from disk, so
+  // vibe_token's "old local keys removed" was never true. For the fields where
+  // an explicit empty value is a real instruction, presence decides.
+  const has = (k) => !!config && Object.prototype.hasOwnProperty.call(config, k);
 
   // Save to primary config (~/.vibe/config.json)
   const data = {
     username: config.handle || config.username || existing.username,
-    workingOn: config.one_liner || config.workingOn || existing.workingOn,
+    // An empty one_liner is a person clearing what they're working on, not an
+    // absent update; the truthy chain kept showing the previous line forever.
+    workingOn: has('one_liner') ? config.one_liner
+      : has('workingOn') ? config.workingOn
+      : existing.workingOn,
     createdAt: config.createdAt || existing.createdAt || new Date().toISOString().split('T')[0],
     // AIRC keypair (persisted across sessions)
-    publicKey: config.publicKey || existing.publicKey || null,
-    privateKey: config.privateKey || existing.privateKey || null,
+    publicKey: has('publicKey') ? (config.publicKey ?? null) : (existing.publicKey || null),
+    privateKey: has('privateKey') ? (config.privateKey ?? null) : (existing.privateKey || null),
     // Guided mode (AskUserQuestion menus)
     guided_mode: config.guided_mode !== undefined ? config.guided_mode : existing.guided_mode,
     // GitHub Activity settings
@@ -107,8 +125,43 @@ function save(config) {
     authToken: config.authToken || config.privyToken || existing.authToken || existing.privyToken || null,
     authMethod: config.authMethod || existing.authMethod || null
   };
+  // Fields this function does not enumerate — x_credentials, firstDmSent,
+  // pendingAuth, visible — used to vanish on every save, because the object
+  // above is built field by field.
+  //
+  // Two layers are needed, not one. Spreading `existing` keeps what was already
+  // on disk (each key in `data` already falls back to its existing value, so the
+  // overlay never replaces a real value with a null it invented). But callers
+  // also SET these fields — `cfg.pendingAuth = true`, `cfg.visible = true`,
+  // `save({firstDmSent: true})` — and those writes were dropped just as
+  // silently. Keeping only `existing` would preserve the old value and still
+  // ignore the update, which reads as working and isn't. So the caller's own
+  // non-translated keys go on top of `existing` and under `data`.
+  //
+  // TRANSLATED names are excluded because they are aliases the block above
+  // already resolved; passing them through would write both spellings.
+  const TRANSLATED = new Set([
+    'handle', 'one_liner', 'username', 'workingOn', 'createdAt',
+    'publicKey', 'privateKey', 'guided_mode', 'authToken', 'privyToken',
+    'authMethod', 'github_activity_enabled', 'github_activity_privacy',
+  ]);
+  const fromCaller = {};
+  for (const [k, v] of Object.entries(config || {})) {
+    if (!TRANSLATED.has(k)) fromCaller[k] = v;
+  }
+  const merged = { ...existing, ...fromCaller, ...data };
+
   // 0600: this file carries the auth token — it is a credential, not a preference.
-  fs.writeFileSync(PRIMARY_CONFIG, JSON.stringify(data, null, 2), { mode: 0o600 });
+  const tmp = `${PRIMARY_CONFIG}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    fs.writeFileSync(tmp, JSON.stringify(merged, null, 2), { mode: 0o600 });
+    fs.renameSync(tmp, PRIMARY_CONFIG);
+  } catch (e) {
+    try { fs.unlinkSync(tmp); } catch {}
+    console.error('Failed to save config:', e.message);
+    return false;
+  }
+  return true;
 }
 
 function getHandle() {
@@ -198,6 +251,19 @@ function generateSessionId() {
   return 'sess_' + Date.now().toString(36) + Math.random().toString(36).substring(2, 10);
 }
 
+// Distinguishes "no session yet" (absent) from "unreadable" (present, corrupt),
+// which getSessionData() cannot: both come back as null.
+function sessionFileIsReadable() {
+  if (!fs.existsSync(SESSION_FILE)) return true;
+  try {
+    const content = fs.readFileSync(SESSION_FILE, 'utf8').trim();
+    if (content.startsWith('{')) JSON.parse(content);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
 function getSessionData() {
   try {
     if (fs.existsSync(SESSION_FILE)) {
@@ -215,7 +281,20 @@ function getSessionData() {
 
 function saveSessionData(data) {
   ensureDir();
-  fs.writeFileSync(SESSION_FILE, JSON.stringify(data, null, 2));
+  if (!sessionFileIsReadable()) {
+    console.error('Refusing to write session data: the file on disk could not be read.');
+    return false;
+  }
+  const tmp = `${SESSION_FILE}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    fs.writeFileSync(tmp, JSON.stringify(data, null, 2));
+    fs.renameSync(tmp, SESSION_FILE);
+  } catch (e) {
+    try { fs.unlinkSync(tmp); } catch {}
+    console.error('Failed to save session data:', e.message);
+    return false;
+  }
+  return true;
 }
 
 function getSessionId() {
@@ -375,9 +454,11 @@ const hasPrivyAuth = hasOAuth;
  */
 function removeKeypair() {
   const cfg = load();
-  delete cfg.publicKey;
-  delete cfg.privateKey;
-  save(cfg);
+  // Explicitly null, not deleted: an absent key means "no instruction" to
+  // save(), and the old value came straight back off disk.
+  cfg.publicKey = null;
+  cfg.privateKey = null;
+  const saved = save(cfg);
 
   // Also clear from session
   const data = getSessionData();
@@ -386,6 +467,7 @@ function removeKeypair() {
     delete data.privateKey;
     saveSessionData(data);
   }
+  return saved;
 }
 
 /**

package/index.js

@@ -56,7 +56,12 @@ const SKIP_FOOTER_TOOLS = ['vibe_init', 'vibe_doctor', 'vibe_test', 'vibe_update
   // The people actions each end in ONE obvious next action; the ambient
   // footer would stack a second one AND name a specific recipient to reply
   // to — the choosing is the human's, so the footer stays off here.
-  'vibe_people', 'vibe_list_me', 'vibe_unlist_me'];
+  'vibe_people', 'vibe_list_me', 'vibe_unlist_me',
+  // The first screen states the unread count itself and shows ids rather than
+  // bodies. The footer would state that count a SECOND time from a different
+  // (cached) source — the two disagreed in a real session — and re-render the
+  // message bodies the screen deliberately withholds.
+  'vibe_start'];
 
 // Progressive disclosure: only these tools are visible before authentication
 // After auth, the full toolset is revealed via tools/list_changed notification
@@ -590,7 +595,11 @@ class VibeMCPServer {
             // vibe_init reads only {handle, one_liner, auth_method} and ignores any
             // extra keys, so this is safe for every command yet lets relevant
             // context (e.g. a handle the caller already supplied) carry into auth.
-            const initResult = await initTool.handler(params.arguments || {});
+            // The gated tool's arguments describe ITS job, not the person signing in:
+            // vibe_dm's `handle` is the recipient. Forwarding it made a first message
+            // to @brightseth request a sign-in AS @brightseth (login?handle=brightseth,
+            // config.handle saved as the recipient). GitHub says who you are; pass nothing.
+            const initResult = await initTool.handler({});
             const initDisplay = initResult.display || JSON.stringify(initResult, null, 2);
 
             // After auth, emit tools/list_changed so Claude sees full toolset

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "slashvibe-mcp",
-  "version": "0.8.21",
+  "version": "0.8.23",
   "mcpName": "io.github.vibecodinginc/vibe",
-  "description": "Presence + messaging for terminal coding agents (Claude Code, Codex, Cursor) \u2014 the /vibe kernel",
+  "description": "Presence + messaging for terminal coding agents (Claude Code, Codex, Cursor) — the /vibe kernel",
   "main": "index.js",
   "bin": {
     "slashvibe-mcp": "cli.js",

package/setup.js

@@ -315,6 +315,14 @@ async function getOnlineCount() {
   try {
     const response = await fetch(`${API_BASE}/api/presence`);
     const data = await response.json();
+    // Before sign-in the roster is private: the server answers with counts only
+    // (`{ anonymous: true, counts: { humansActive, active, ... }, active: [] }`).
+    // Counting names here printed "0 builders online" to every newcomer while
+    // eleven people were on. Read the count the server actually gives.
+    if (data.counts && typeof data.counts === 'object') {
+      const n = data.counts.humansActive ?? data.counts.active;
+      if (Number.isFinite(n)) return n;
+    }
     return (data.active?.length || 0) + (data.away?.length || 0);
   } catch (e) {
     return 0;
@@ -324,28 +332,30 @@ async function getOnlineCount() {
 /**
  * Get online users with details for display
  */
-async function getOnlineUsers() {
+async function getOnlineUsers(token) {
   try {
-    const response = await fetch(`${API_BASE}/api/presence`);
+    // Handles are only served to a signed-in caller; pass the fresh token so the
+    // "here now" list after sign-in is real, not an empty anonymous answer.
+    const headers = token ? { Authorization: `Bearer ${token}` } : {};
+    const response = await fetch(`${API_BASE}/api/presence`, { headers });
     const data = await response.json();
-    const active = data.active || [];
-    const away = data.away || [];
+    const people = (u) => !u.isAgent;
+    // "Here now" means active humans only. Away rows were once appended below,
+    // which let the headline count disagree with the rows under it (codex P2).
+    const active = (data.active || []).filter(people);
+    const workText = (u) => u.workingOn || u.working_on || u.one_liner || '';
 
     // Format: { users: [{handle, status, one_liner}], total: number }
-    const users = [
-      ...active.slice(0, 5).map(u => ({
-        handle: u.username || u.handle,
-        status: 'active',
-        one_liner: u.one_liner || u.status || ''
-      })),
-      ...away.slice(0, 2).map(u => ({
-        handle: u.username || u.handle,
-        status: 'away',
-        one_liner: u.one_liner || u.status || ''
-      }))
-    ].slice(0, 5);
-
-    return { users, total: active.length + away.length };
+    const users = active.slice(0, 5).map(u => ({
+      handle: u.username || u.handle,
+      status: 'active',
+      one_liner: workText(u)
+    }));
+
+    const total = Number.isFinite(data.counts?.humansActive)
+      ? data.counts.humansActive
+      : active.length;
+    return { users, total };
   } catch (e) {
     return { users: [], total: 0 };
   }
@@ -477,7 +487,9 @@ async function setup() {
   }
 
   const onlineCount = await getOnlineCount();
-  console.log(`${colors.dim}     → Connected! ${onlineCount} builders online${colors.reset}`);
+  console.log(onlineCount > 0
+      ? `${colors.dim}     → Connected — ${onlineCount} ${onlineCount === 1 ? 'person' : 'people'} here now${colors.reset}`
+      : `${colors.dim}     → Connected${colors.reset}`);
   printStep(3, 'Testing connection...', 'done');
 
   // Step 4: Authenticate
@@ -504,7 +516,7 @@ async function setup() {
     console.log(`${colors.dim}     → Authenticated as @${authResult.handle}${colors.reset}`);
 
     // Success! Show who's online immediately
-    const presence = await getOnlineUsers();
+    const presence = await getOnlineUsers(authResult.token);
 
     console.log('');
     console.log(`${colors.green}  ✓ Setup complete!${colors.reset}`);
@@ -512,7 +524,7 @@ async function setup() {
 
     // Show who's vibing right now
     if (presence.users.length > 0) {
-      console.log(`${colors.bold}  🟢 ${presence.total} builders vibing now:${colors.reset}`);
+      console.log(`${colors.bold}  🟢 ${presence.total} people here now:${colors.reset}`);
       for (const user of presence.users) {
         const statusIcon = user.status === 'active' ? colors.green + '●' : colors.yellow + '○';
         const liner = user.one_liner ? ` — ${user.one_liner.slice(0, 40)}` : '';
@@ -526,7 +538,7 @@ async function setup() {
 
     console.log(`${colors.bold}  Quick start:${colors.reset}`);
     console.log(`${colors.dim}  1. Restart your coding agent${detected.length > 1 ? `s (${detected.join(', ')})` : ''}${colors.reset}`);
-    console.log(`${colors.dim}  2. Send a real message to someone you already know — "dm @their-handle ..."${colors.reset}`);
+    console.log(`${colors.dim}  2. Say: "message @their-handle — ..." to someone you already know${colors.reset}`);
     console.log(`${colors.dim}  3. Claude Code: run "npx slashvibe-mcp hook install" — waiting messages appear at the top of your next session${colors.reset}`);
     console.log('');
     console.log(`${colors.cyan}  Welcome to /vibe, @${authResult.handle}.${colors.reset}`);

package/store/api.js

@@ -354,11 +354,21 @@ async function getTypingUsers(forHandle) {
   }
 }
 
-async function getActiveUsers() {
+async function getActiveUsersInner() {
   try {
     const endpoint = USE_V2_PRESENCE ? '/api/v2/presence' : '/api/presence';
     const result = await request('GET', endpoint);
 
+    // request() RESOLVES on transport failure ({success:false, network:true}),
+    // so without this the lists below are simply absent and a dead network maps
+    // to a successful empty room. 401 is deliberately excluded: that is the
+    // "signed out, here are public counts" path handled below, not a failure.
+    if (result?.success === false && result.statusCode !== 401) {
+      const err = new Error(result.error || 'presence request failed');
+      err.code = result.network ? 'transport_failed' : `http_${result.statusCode || 'error'}`;
+      throw err;
+    }
+
     // Combine active + away, plus any AGENTS currently live in a room (e.g.
     // @coltrane hosting the cantina). Agents live in their own array; without
     // this a live agent host never reached the footer's live-room line.
@@ -446,10 +456,38 @@ async function getActiveUsers() {
     return mappedUsers;
   } catch (e) {
     console.error('Who failed:', e.message);
-    return [];
+    const err = new Error(e?.message || 'presence read failed');
+    err.code = e?.code || 'transport_failed';
+    throw err;
+  }
+}
+
+// The same outcome-preserving shape the inbox uses: flattening a failed
+// presence read to [] made "0 others here" a claim nobody verified.
+async function getActiveUsersResult() {
+  try {
+    const users = await getActiveUsersInner();
+    if (!Array.isArray(users)) return { ok: false, users: [], error: 'malformed_response' };
+    // Signed out is not an empty room either — the server told us it would not
+    // say who is here. A caller rendering a count must not treat that as zero.
+    //
+    // The ARRAY ITSELF is returned, not a fresh []: it carries `anonymous` and
+    // `counts` as non-enumerable properties, and who.js reads them to say "4
+    // people are here, sign in to see who". Substituting a bare [] there turned
+    // that back into "Quiet right now — you're the only one here", the exact
+    // sentence those properties exist to prevent.
+    if (users.anonymous) return { ok: false, users, error: 'unauthenticated' };
+    return { ok: true, users };
+  } catch (e) {
+    return { ok: false, users: [], error: e?.code || 'transport_failed', message: e?.message };
   }
 }
 
+// Named callers keep the old shape: an empty list on failure, as before.
+async function getActiveUsers() {
+  return (await getActiveUsersResult()).users;
+}
+
 async function setVisibility(handle, visible) {
   try {
     const endpoint = USE_V2_PRESENCE ? '/api/v2/presence' : '/api/presence';
@@ -600,7 +638,30 @@ async function sendMessage(from, to, body, type = 'dm', payload = null, options
   }
 }
 
+/**
+ * The inbox, and whether it was actually read.
+ *
+ * getInbox() swallows transport failures into [] for its many callers, which
+ * makes "no threads" and "could not ask" the same value — and a caller that
+ * renders a claim from that (vibe_start did) states a fact nobody has
+ * (review P1). This is the same call with the outcome kept:
+ *   { ok: true,  threads }  the server answered
+ *   { ok: false, threads: [], error }  nobody answered, or the API refused
+ */
+async function getInboxResult(handle) {
+  try {
+    const threads = await getInboxInner(handle);
+    return Array.isArray(threads) ? { ok: true, threads } : { ok: false, threads: [], error: 'malformed_response' };
+  } catch (e) {
+    return { ok: false, threads: [], error: e?.code || 'transport_failed', message: e?.message };
+  }
+}
+
 async function getInbox(handle) {
+  return (await getInboxResult(handle)).threads;
+}
+
+async function getInboxInner(handle) {
   try {
     // V2: Use threads endpoint (Postgres-backed, cross-client sync)
     if (USE_V2_MESSAGES) {
@@ -629,8 +690,10 @@ async function getInbox(handle) {
     // V1 fallback
     return getInboxV1(handle);
   } catch (e) {
+    // Rethrow: getInboxResult owns the outcome now, and getInbox() still
+    // presents [] to every caller that only wants the list.
     console.error('Inbox failed:', e.message);
-    return [];
+    throw e;
   }
 }
 
@@ -640,10 +703,15 @@ async function getInboxV1(handle) {
     // /api/messages now returns V2 format: { threads, total_unread }
     const result = await request('GET', `/api/messages?user=${handle}`);
 
-    // Check for API errors (auth failures, etc.)
+    // An API-level refusal (auth failure, server error) is a FAILED read, not
+    // an empty inbox. Returning [] here made "the server said no" and "you
+    // have no threads" the same value — the same swallow the transport path
+    // had, one layer down (review P1).
     if (result.success === false) {
       console.error('[getInbox] API error:', result.error, result.message);
-      return [];
+      const err = new Error(result.message || result.error || 'inbox_refused');
+      err.code = result.error || 'inbox_refused';
+      throw err;
     }
 
     // V2 format: map threads to expected format
@@ -678,7 +746,7 @@ async function getInboxV1(handle) {
     }));
   } catch (e) {
     console.error('Inbox v1 failed:', e.message);
-    return [];
+    throw e;
   }
 }
 
@@ -1387,6 +1455,7 @@ module.exports = {
   // Presence
   heartbeat,
   getActiveUsers,
+  getActiveUsersResult,
   setVisibility,
   sendTypingIndicator,
   getTypingUsers,
@@ -1394,6 +1463,7 @@ module.exports = {
   // Messages
   sendMessage,
   getInbox,
+  getInboxResult,
   getRawInbox,
   getUnreadCount,
   getThread,

package/store/local.js

@@ -38,8 +38,33 @@ function loadPresence() {
   return {};
 }
 
+function presenceIsReadable() {
+  if (!fs.existsSync(PRESENCE_FILE)) return true;   // absent = a real first write
+  try {
+    JSON.parse(fs.readFileSync(PRESENCE_FILE, 'utf8'));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
 function savePresence(presence) {
-  fs.writeFileSync(PRESENCE_FILE, JSON.stringify(presence, null, 2));
+  // loadPresence() turns an unreadable file into {}, so an unguarded save would
+  // drop every other person's presence record.
+  if (!presenceIsReadable()) {
+    console.error('Refusing to write presence: the file on disk could not be read.');
+    return false;
+  }
+  const tmp = `${PRESENCE_FILE}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    fs.writeFileSync(tmp, JSON.stringify(presence, null, 2));
+    fs.renameSync(tmp, PRESENCE_FILE);
+  } catch (e) {
+    try { fs.unlinkSync(tmp); } catch {}
+    console.error('Failed to save presence:', e.message);
+    return false;
+  }
+  return true;
 }
 
 async function heartbeat(handle, one_liner) {
@@ -53,6 +78,11 @@ async function heartbeat(handle, one_liner) {
   savePresence(presence);
 }
 
+async function getActiveUsersResult() {
+  if (!presenceIsReadable()) return { ok: false, users: [], error: 'local_corrupt' };
+  return { ok: true, users: await getActiveUsers() };
+}
+
 async function getActiveUsers() {
   const presence = loadPresence();
   const now = Date.now();
@@ -87,16 +117,38 @@ async function setVisibility(handle, visible) {
 
 // ============ MESSAGES ============
 
+/**
+ * The messages file, with failures preserved.
+ *
+ * A file that does not exist yet IS an empty inbox — that is a real answer.
+ * A file that cannot be read, or whose lines do not parse, is NOT: it is a
+ * failed read, and flattening it to [] makes "nothing has happened" and
+ * "something is wrong" the same value (review P1 — the same swallow the API
+ * store had, two layers down).
+ */
+function loadMessagesStrict() {
+  if (!fs.existsSync(MESSAGES_FILE)) return [];
+  const content = fs.readFileSync(MESSAGES_FILE, 'utf8');
+  return content.trim().split('\n')
+    .filter(line => line.length > 0)
+    .map((line, i) => {
+      try {
+        return JSON.parse(line);
+      } catch (e) {
+        const err = new Error(`messages.jsonl line ${i + 1} is not valid JSON`);
+        err.code = 'local_corrupt';
+        throw err;
+      }
+    });
+}
+
+// Unchanged contract for every caller that only wants the list.
 function loadMessages() {
   try {
-    if (fs.existsSync(MESSAGES_FILE)) {
-      const content = fs.readFileSync(MESSAGES_FILE, 'utf8');
-      return content.trim().split('\n')
-        .filter(line => line.length > 0)
-        .map(line => JSON.parse(line));
-    }
-  } catch (e) {}
-  return [];
+    return loadMessagesStrict();
+  } catch (e) {
+    return [];
+  }
 }
 
 function appendMessage(msg) {
@@ -127,6 +179,31 @@ async function getInbox(handle) {
     .sort((a, b) => b.timestamp - a.timestamp);
 }
 
+/**
+ * The inbox, and whether it was actually read — the same contract the API
+ * store provides (store/api.js). Both implementations must answer it, or a
+ * caller that distinguishes "empty" from "could not ask" silently gets the
+ * wrong answer in the other mode (review P1: with VIBE_LOCAL=true, a missing
+ * method made every start claim the read had failed).
+ *
+ * A local file read either produces the list or throws; there is no partial
+ * or refused outcome to represent.
+ */
+async function getInboxResult(handle) {
+  try {
+    // The STRICT loader: getInbox() flattens a corrupt or unreadable file to
+    // [], which is exactly the fact this wrapper exists to preserve.
+    const messages = loadMessagesStrict();
+    const h = handle.toLowerCase().replace('@', '');
+    const threads = messages
+      .filter((m) => m.to === h)
+      .sort((a, b) => b.timestamp - a.timestamp);
+    return { ok: true, threads };
+  } catch (e) {
+    return { ok: false, threads: [], error: e?.code || 'local_read_failed', message: e?.message };
+  }
+}
+
 async function getUnreadCount(handle) {
   const inbox = await getInbox(handle);
   return inbox.filter(m => !m.read_at).length;
@@ -152,7 +229,19 @@ async function getThread(myHandle, theirHandle) {
 }
 
 async function markThreadRead(myHandle, theirHandle) {
-  const messages = loadMessages();
+  // A READ-MODIFY-WRITE over the whole file must never run on a swallowed
+  // read (review P1 — DATA LOSS): loadMessages() returns [] for a corrupt or
+  // unreadable file, and the rewrite below would then replace every message,
+  // including the valid ones, with an empty file. A read that did not succeed
+  // is not permission to write; the mark is abandoned and the file is left
+  // exactly as it is.
+  let messages;
+  try {
+    messages = loadMessagesStrict();
+  } catch (e) {
+    console.error('[local] not marking read — the messages file could not be read:', e.message);
+    return { success: false, error: e.code || 'local_read_failed' };
+  }
   const me = myHandle.toLowerCase().replace('@', '');
   const them = theirHandle.toLowerCase().replace('@', '');
   const now = Date.now();
@@ -165,8 +254,21 @@ async function markThreadRead(myHandle, theirHandle) {
     return m;
   });
 
-  // Rewrite the file
-  fs.writeFileSync(MESSAGES_FILE, updated.map(m => JSON.stringify(m)).join('\n') + '\n');
+  // Rewrite the file. Reached only from a read that actually succeeded, and
+  // written via a temp file + rename so an interrupted write cannot leave a
+  // half-file behind either.
+  // A per-write temp name: a fixed one collides between concurrent marks, and
+  // a failed rename would leave it behind (review P2).
+  const tmp = `${MESSAGES_FILE}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    fs.writeFileSync(tmp, updated.map(m => JSON.stringify(m)).join('\n') + '\n');
+    fs.renameSync(tmp, MESSAGES_FILE);
+  } catch (e) {
+    try { fs.unlinkSync(tmp); } catch {}
+    console.error('[local] mark-read write failed; the file is unchanged:', e.message);
+    return { success: false, error: e.code || 'local_write_failed' };
+  }
+  return { success: true };
 }
 
 // ============ SKILL EXCHANGES ============
@@ -239,10 +341,12 @@ module.exports = {
   // Presence
   heartbeat,
   getActiveUsers,
+  getActiveUsersResult,
   setVisibility,
 
   // Messages
   sendMessage,
+  getInboxResult,
   getInbox,
   getRawInbox,
   getUnreadCount,

package/store/profiles.js

@@ -28,10 +28,38 @@ function loadProfiles() {
   return {};
 }
 
+// True only when the store on disk is absent (a legitimate first write) or
+// parses. A present-but-unreadable file loaded as {}, so writing over it would
+// delete every profile it holds.
+function storeIsReadable() {
+  if (!fs.existsSync(PROFILES_FILE)) return true;
+  try {
+    JSON.parse(fs.readFileSync(PROFILES_FILE, 'utf8'));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
 // Save all profiles to disk
 function saveProfiles(profiles) {
+  // Every mutator above is a read-modify-write over the whole store, and
+  // loadProfiles() cannot tell "no profiles" from "unreadable". A read that did
+  // not succeed is not permission to write.
+  if (!storeIsReadable()) {
+    console.error('Refusing to write profiles: the store on disk could not be read.');
+    return false;
+  }
   try {
-    fs.writeFileSync(PROFILES_FILE, JSON.stringify(profiles, null, 2));
+    const tmp = `${PROFILES_FILE}.${process.pid}.${Date.now()}.tmp`;
+    try {
+      fs.writeFileSync(tmp, JSON.stringify(profiles, null, 2));
+      fs.renameSync(tmp, PROFILES_FILE);
+    } catch (e) {
+      try { fs.unlinkSync(tmp); } catch {}
+      throw e;
+    }
+    return true;
   } catch (e) {
     console.error('Failed to save profiles:', e.message);
   }

package/tools/inbox.js

@@ -222,12 +222,21 @@ async function handler(args) {
   // all list/ambient concerns and must not hold this path open.
   if (requestedHandle) {
     const thread = await store.getThread(myHandle, requestedHandle);
-    await store.markThreadRead(
+    // markThreadRead can now REFUSE (a read that failed is not permission to
+    // write). A refusal means the thread on disk could not be read, so an
+    // empty render would be a claim about a conversation nobody looked at.
+    const marked = await store.markThreadRead(
       myHandle,
       requestedHandle,
       thread._lastMessageId,
       thread._threadId
     );
+    if (marked && marked.success === false) {
+      return {
+        display: `Couldn't read your thread with @${requestedHandle} — nothing is shown rather than an empty conversation.`,
+        footer: 'minimal',
+      };
+    }
 
     if (thread.some(m => m.from === requestedHandle)) {
       patterns.logMessageReceived(requestedHandle);
@@ -399,7 +408,10 @@ async function handler(args) {
 
     // Fetch full thread and mark as read
     const thread = await store.getThread(myHandle, them);
-    await store.markThreadRead(myHandle, them, thread._lastMessageId, thread._threadId);
+    const marked = await store.markThreadRead(myHandle, them, thread._lastMessageId, thread._threadId);
+    if (marked && marked.success === false) {
+      return { display: `Couldn't read your thread with @${them} — nothing is shown rather than an empty conversation.` };
+    }
 
     // Auto-track readWelcomeAt if viewing welcome from @brightseth
     const isWelcomeThread = them.toLowerCase() === 'brightseth';

package/tools/init.js

@@ -334,7 +334,10 @@ async function completeSignIn({ token, handle: finalHandle, actor }, one_liner)
   authStore.setOneLiner(one_liner || '');
   const authConfig = config.load();
   authConfig.handle = finalHandle;
-  authConfig.one_liner = one_liner || '';
+  // Only when we were actually given one. save() can now express a clear, and
+  // `one_liner || ''` would make signing in erase the line you set last week —
+  // an instruction nobody gave.
+  if (one_liner) authConfig.one_liner = one_liner;
   authConfig.authMethod = 'browser';
   authConfig.pendingAuth = false;
   config.save(authConfig);
@@ -535,7 +538,7 @@ Heading out? \`vibe bye\` ends presence for this session — you stay @${existin
     // Save one_liner for the completion handler
     const cfg = config.load();
     if (h) cfg.handle = h;
-    cfg.one_liner = one_liner || '';
+    if (one_liner) cfg.one_liner = one_liner;
     cfg.pendingAuth = true;
     config.save(cfg);
 
@@ -578,7 +581,7 @@ Heading out? \`vibe bye\` ends presence for this session — you stay @${existin
 
   const cfg = config.load();
   cfg.handle = h;
-  cfg.one_liner = one_liner || '';
+  if (one_liner) cfg.one_liner = one_liner;   // same: absent is not "clear it"
   cfg.visible = true;
   cfg.authMethod = 'legacy';
   config.save(cfg);

package/tools/reply.js

@@ -173,7 +173,11 @@ async function handler(args) {
 
   // Mark the thread as read since we're replying
   try {
-    await store.markThreadRead(myHandle, targetHandle);
+    // A refusal is not an exception, so `catch` alone could not see it.
+    const marked = await store.markThreadRead(myHandle, targetHandle);
+    if (marked && marked.success === false) {
+      console.warn('[reply] thread not marked read:', marked.error);
+    }
   } catch (e) {
     // Non-fatal - continue
     console.warn('[reply] Failed to mark thread as read:', e.message);

package/tools/start.js

@@ -17,9 +17,7 @@ const { inertField } = require('../incoming');
 const store = require('../store');
 const memory = require('../memory');
 const patterns = require('../intelligence/patterns');
-const { actions, formatActions } = require('./_actions');
-const { firstDmNudge, isHereNow } = require('./_shared');
-const { weaveMoment } = require('./weave');
+const { isHereNow, normalizeHandle } = require('./_shared');
 const init = require('./init');
 const { gatherWithTimeout } = require('./_work-context');
 
@@ -151,25 +149,6 @@ function compareVersions(v1, v2) {
   return 0;
 }
 
-/**
- * Generate ASCII welcome card - matches init.js format
- * Format: logo | handle + unread | tagline + online
- */
-function generateWelcomeCard({ handle, onlineCount, unreadCount, versionInfo }) {
-  // Match init.js generateAuthBanner format for consistency
-  const handleCol = `@${handle}`.padEnd(16);
-  const unreadCol = unreadCount > 0 ? `📬 ${unreadCount} unread`.padEnd(14) : `📬 0 messages`.padEnd(14);
-
-  // Add version badge if available
-  let versionSuffix = '';
-  if (versionInfo?.hasUpdate) {
-    versionSuffix = ' ⬆️';
-  }
-
-  return `  █░█ █ █▄▄ █▀▀   ${handleCol}  ask here · answer there
-  ▀▄▀ █ █▄█ ██▄   ${unreadCol}  🟢 ${onlineCount} online${versionSuffix}
-  ──────────────────────────────────────────────────`;
-}
 
 const definition = {
   name: 'vibe_start',
@@ -205,7 +184,6 @@ async function handler(args) {
 
   // Step 2: User is authenticated - show dashboard
   const myHandle = config.getHandle();
-  let threads = [];
   let updateNotice = '';
 
   // If we just updated, show a notice
@@ -213,9 +191,6 @@ async function handler(args) {
     updateNotice = `\n\n⬆️ **Updated v${updateResult.from} → v${updateResult.to}** — restart your coding agent to apply`;
   }
 
-  // Fetch version info early (non-blocking, cached)
-  const versionInfo = await getVersionInfo().catch(() => null);
-
   // ═══════════════════════════════════════════════════════════════════════
   // AMBIENT CONTEXT: Gather work context and auto-set presence
   // ═══════════════════════════════════════════════════════════════════════
@@ -245,48 +220,42 @@ async function handler(args) {
   // Log session start for patterns
   patterns.logSessionStart(myHandle);
 
-  // Get threads for memory context
-  try {
-    threads = memory.listThreads();
-  } catch (e) {}
-
   // Step 2: Get who's around
-  const users = await store.getActiveUsers();
-  const others = users.filter(u => u.handle !== myHandle);
+  // A presence request that FAILED is not an empty room (round-7 review):
+  // getActiveUsers flattens transport failure to [], so without this outcome
+  // "0 others here" is a claim nobody verified.
+  const presence = await store.getActiveUsersResult();
+  const presenceRead = presence.ok;
+  const users = presence.users;
+  // Compared normalized: an exact !== lets a differently-cased or @-prefixed
+  // copy of your own handle through, and then "N others here" counts you.
+  const me = normalizeHandle(myHandle || '');
+  const others = users.filter(u => normalizeHandle(u.handle || '') !== me);
   // GREEN MEANS A RECENT CONFIRMED HEARTBEAT — the same isHereNow gate who and
   // dm use. getActiveUsers returns active+away merged; rendering that union
   // under 🟢 told users someone was live who last breathed 25 minutes ago.
   const hereNow = others.filter(isHereNow);
-  const away = others.filter(u => !isHereNow(u));
 
-  // Step 3: Check inbox
+  // Step 3: Check inbox. A FAILED read is not an empty inbox (review P1):
+  // getInbox swallows transport errors into [], so without this flag a
+  // network failure renders as "0 unread" and as "no messages yet" — two
+  // claims nothing supports.
   let unreadCount = 0;
   let inboxThreads = [];
+  let inboxRead = false;
   try {
-    // Fetch full inbox (not just count) so we can include summaries
-    inboxThreads = await store.getInbox(myHandle);
+    // getInboxResult keeps the outcome that getInbox() flattens away.
+    const read = await store.getInboxResult(myHandle);
+    inboxRead = read.ok === true;
+    inboxThreads = read.threads || [];
     unreadCount = inboxThreads.reduce((sum, t) => sum + (t.unread || 0), 0);
-  } catch (e) {}
+  } catch (e) {
+    inboxThreads = [];
+  }
 
-  // Step 3b: Check for guest session messages + pair status (multiplayer)
-  let guestMessages = [];
-  let pairStatus = null;
-  try {
-    const apiUrl = config.getApiUrl();
-    const headers = apiHeaders();
-    const [guestResp, pairResp] = await Promise.all([
-      fetch(`${apiUrl}/api/session/guest?handle=${encodeURIComponent(myHandle)}`, { headers }),
-      fetch(`${apiUrl}/api/pair?handle=${encodeURIComponent(myHandle)}`, { headers }),
-    ]);
-    const guestData = await guestResp.json();
-    if (guestData.success && guestData.messages && guestData.messages.length > 0) {
-      guestMessages = guestData.messages;
-    }
-    const pairData = await pairResp.json();
-    if (pairData.success && pairData.paired) {
-      pairStatus = pairData;
-    }
-  } catch (e) {}
+  // Step 3b removed with the first-screen rewrite: the guest/pair fetches
+  // cost two HTTP round trips on every start and fed blocks this screen no
+  // longer renders. vibe_guest still owns that surface.
 
   // Step 4 used to fetch /api/suggestions and render "Suggested connections" — three
   // strangers proposed on every session start, in the DEFAULT surface rather than behind
@@ -298,211 +267,77 @@ async function handler(args) {
   // nobody to say anything about. NOTE: `workContext.suggestions` elsewhere in this file
   // is unrelated — that is local work context, not people.
 
-  // Generate the ASCII welcome card (matches init.js format)
-  const welcomeCard = generateWelcomeCard({
-    handle: myHandle,
-    onlineCount: hereNow.length,
-    unreadCount,
-    versionInfo
-  });
-
-  // Build display with card + any additional info
-  let display = welcomeCard;
-
-  // Add who's online section (top 5 with what they're building).
-  // Only isHereNow rows may sit under 🟢; everyone else is ○ away, in words.
-  if (hereNow.length > 0) {
-    const top5 = hereNow.slice(0, 5);
-    display += `\n\n**🟢 Online now:**`;
-    top5.forEach(u => {
-      // status/one_liner/note are written by other users — inert before they
-      // land in this session's context (codex F8 coverage).
-      const status = u.status ? ` (${inertField(u.status, 30)})` : '';
-      const truncated = inertField(u.one_liner || u.note || '', 40);
-      display += `\n• @${u.handle}${status}${truncated ? ' — ' + truncated : ''}`;
-    });
-    if (hereNow.length > 5) {
-      display += `\n• _+${hereNow.length - 5} more..._`;
-    }
-  }
-  if (away.length > 0) {
-    display += `\n${hereNow.length > 0 ? '' : '\n'}○ ${away.length} away`;
-  }
-
-  // First-DM activation nudge (dormant users only): if this user has never sent
-  // a DM, point them at a real human who's around right now with a ready opener.
-  // Gated inside firstDmNudge so we never nag people who already message.
-  display += firstDmNudge(hereNow, threads);
-
-  // Add unread messages section (if any)
-  if (unreadCount > 0) {
-    const unreadSenders = inboxThreads.filter(t => t.unread > 0);
-    display += `\n\n**📬 Unread (${unreadCount}):**`;
-    unreadSenders.slice(0, 3).forEach(t => {
-      const truncated = inertField(t.lastMessage || '', 50);
-      display += `\n• @${t.handle} (${t.unread}) — "${truncated}"`;
+  // ── THE FIRST SCREEN ────────────────────────────────────────────────
+  // One authoritative count, no message bodies, no chosen person, and the
+  // three things a person can actually do. Everything that used to live here
+  // — the presence list, message previews, the ambient footer's copy of the
+  // same messages, rotating tips, weave/guest/pair/memory blocks — either
+  // duplicated a fact stated elsewhere or made a claim this screen cannot
+  // verify. What a person needs on arrival is: who am I, what is waiting,
+  // and what can I say next.
+  const hereCount = hereNow.length;
+  const unreadSenders = inboxThreads.filter((t) => t.unread > 0);
+  // Server-supplied strings on a single line: a long handle or id would wrap
+  // and blow the line budget, and a control character would add literal lines
+  // (review P2).
+  const cell = (v, max) => inertField(String(v || ''), max);
+
+  let display = `/vibe @${cell(myHandle, 39)}`;
+  // ONE authoritative live-presence count: store.getActiveUsers(), filtered by
+  // the same isHereNow gate who and dm use, EXCLUDING the signed-in person.
+  // "N here" could be read as the room including you; "N others here" states
+  // exactly what was counted.
+  const counts = [
+    inboxRead ? `${unreadCount} unread` : "couldn't read your inbox",
+    presenceRead
+      ? `${hereCount} other${hereCount === 1 ? '' : 's'} here`
+      : "couldn't see who's here",
+  ];
+  display += `\n${counts.join(' · ')}`;
+
+  if (unreadSenders.length > 0) {
+    // Handle, count, and the STABLE id of the newest message — enough to
+    // reply to exactly that message. The words themselves stay in the thread
+    // until the person opens it.
+    display += '\n';
+    unreadSenders.slice(0, 5).forEach((t) => {
+      const id = t.lastMessageId ? ` · #${cell(t.lastMessageId, 40)}` : '';
+      display += `\n@${cell(t.handle, 39)} (${t.unread})${id}`;
     });
-    if (unreadSenders.length > 3) {
-      display += `\n• _+${unreadSenders.length - 3} more threads..._`;
+    if (unreadSenders.length > 5) {
+      display += `\n_+${unreadSenders.length - 5} more_`;
     }
+  } else if (inboxRead && inboxThreads.length === 0) {
+    // Only a PROVEN-empty inbox may be called a fresh arrival. Land them on
+    // whoever brought them here; no randomly chosen stranger, ever.
+    display += '\n\n_no messages yet — whoever invited you is the place to start_';
   }
 
-  // The Weave — "Fable holds your half": if someone replied to a thread and you
-  // haven't answered, surface the moment so the in-session model can draft your
-  // reply in your voice and send it with one word. Best-effort, never blocks start.
-  try {
-    display += await weaveMoment(myHandle);
-  } catch (e) {
-    // weave is additive magic — a failure here must never break vibe_start
-  }
-
-  // Add guest session messages (multiplayer — someone typed into your session)
-  if (guestMessages.length > 0) {
-    display += `\n\n**🎤 ${guestMessages.length} guest message${guestMessages.length > 1 ? 's' : ''} in your session:**`;
-    guestMessages.forEach(m => {
-      const time = new Date(m.timestamp).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
-      display += `\n• [${time}] @${inertField(m.from, 40)}: ${inertField(m.message, 80)}`;
-    });
-    display += `\n_Use vibe_guest with action "ack" to clear after reading._`;
-  }
-
-  // Show pair status if paired with someone
-  if (pairStatus) {
-    const mode = pairStatus.mode || 'coding';
-    display += `\n\n**🔗 Paired with @${pairStatus.partner}** (${mode})`;
-    display += `\n_Session sharing active. Use vibe_guest to exchange messages._`;
-  }
-
-  // Add memory context for returning users
-  if (threads.length > 0) {
-    const recentThreads = threads.slice(0, 3);
-    const names = recentThreads.map(t => `@${t.handle}`).join(', ');
-    display += `\n\n💭 **${threads.length}** people in memory · ${names}`;
-  }
+  if (updateNotice) display += updateNotice;
 
-  // Add update notice if we just auto-updated
-  if (updateNotice) {
-    display += updateNotice;
-  }
+  display += `\n\nvibe inbox · vibe people · vibe dm @handle "…"`;
 
-  // Step 6: Show rotating tips about features.
-  // A tip may only name a tool REGISTERED in a default session (#9.2) — the
-  // old set advertised "vibe stuck" / "vibe available" / "vibe context" /
-  // "start presence monitor", none of which exist, so every rotating tip
-  // told users to run a command that fails. If a tip's tool ever moves
-  // behind VIBE_EXTRAS, the tip moves with it.
-  const tips = [
-    '💡 **Tip:** Say "who\'s around?" — vibe_who shows who has a live heartbeat right now.',
-    '💡 **Tip:** Say "message @handle ..." to DM someone — replies land in your inbox across sessions.',
-    '💡 **Tip:** Say "check my vibe inbox" any time — messages wait for you between sessions.',
-    '💡 **Tip:** Run "npx slashvibe-mcp hook install" so waiting messages appear when your next Claude session starts.'
-  ];
-  const tipIndex = Math.floor(Date.now() / 60000) % tips.length; // Rotate every minute
-  display += `\n\n---\n${tips[tipIndex]}`;
-
-  // Build response with hints for structured dashboard flow
+  // ── THE RESPONSE ────────────────────────────────────────────────────
+  // The payload obeys the SAME contracts as the screen (review P1): a host
+  // and a model read this, so a body withheld from the display but shipped
+  // here is not withheld at all, and a handle chosen here is still a chosen
+  // handle. What ships is what the screen states — counts, and the threads
+  // waiting with the id needed to answer one exactly. Whoever is online is
+  // vibe_who's answer; whoever to talk to is the person's decision.
   const response = { display };
 
-  // === ENRICHED DATA ===
-  // Include full online users list so Claude doesn't need to call vibe_who
-  response.onlineUsers = others.map(u => ({
-    handle: u.handle,
-    hereNow: isHereNow(u),
-    building: (u.one_liner || u.note) ? inertField(u.one_liner || u.note) : null,
-    status: u.status ? inertField(u.status, 30) : null,
-    lastActive: u.lastSeen ? new Date(u.lastSeen).toISOString() : null
-  }));
-
-  // Include unread thread summaries so Claude doesn't need to call vibe_inbox
-  const unreadSenders = inboxThreads.filter(t => t.unread > 0);
-  response.unreadThreads = unreadSenders.map(t => ({
+  response.unread = inboxRead ? unreadCount : null;   // null = not read, never 0
+  response.here = presenceRead ? hereCount : null;   // null = not read, never 0
+  response.waiting = unreadSenders.slice(0, 5).map((t) => ({
     handle: t.handle,
     unread: t.unread,
-    preview: t.lastMessage ? t.lastMessage.slice(0, 80) : null,
-    isAgent: t.isAgent || false
+    lastMessageId: t.lastMessageId || null,
   }));
 
-  // Include guest session messages (multiplayer)
-  if (guestMessages.length > 0) {
-    response.guestMessages = guestMessages.map(m => ({
-      from: m.from,
-      message: m.message,
-      timestamp: m.timestamp,
-      id: m.id
-    }));
-  }
-
-  // Include pair status if paired
-  if (pairStatus) {
-    response.pairStatus = {
-      paired: true,
-      partner: pairStatus.partner,
-      mode: pairStatus.mode,
-      startedAt: pairStatus.startedAt
-    };
-  }
-
-
-  // Determine session state and suggest appropriate flow
-  let suggestion = null;
-
-  if (unreadCount >= 5) {
-    // Many unread - suggest triage
-    response.hint = 'structured_triage_recommended';
-    response.unread_count = unreadCount;
-  } else if (others.length === 0 && unreadCount === 0) {
-    // Empty room - suggest discovery or invite
-    response.hint = 'suggest_discovery';
-    response.reason = 'empty_room';
-  } else if (others.length > 0) {
-    // People around - check for interesting ones
-    const interesting = hereNow.find(u => {
-      const age = Date.now() - u.lastSeen;
-      return age < 5 * 60 * 1000; // Active in last 5 min
-    });
-    if (interesting) {
-      suggestion = {
-        handle: interesting.handle,
-        reason: 'active_now',
-        context: interesting.note || interesting.one_liner || 'Building something'
-      };
-      response.hint = 'surprise_suggestion';
-      response.suggestion = suggestion;
-    }
-  }
-
-  // Add guided mode actions for AskUserQuestion rendering
-  const onlineHandles = others.map(u => u.handle);
-  let actionList;
-
-  if (others.length === 0 && unreadCount === 0) {
-    // Empty room
-    actionList = actions.emptyRoom({ workContext });
-  } else {
-    // Normal dashboard
-    actionList = actions.dashboard({
-      unreadCount,
-      onlineUsers: onlineHandles,
-      suggestion,
-      workContext
-    });
-  }
-
-  response.actions = formatActions(actionList);
-
-  // ═══════════════════════════════════════════════════════════════════════
-  // WORK CONTEXT: Include in response for Claude to use
-  // ═══════════════════════════════════════════════════════════════════════
-  if (workContext?.suggestions?.brief) {
-    response.workContext = {
-      summary: workContext.suggestions.brief,
-      detailed: workContext.suggestions.detailed,
-      project: workContext.project?.name,
-      branch: workContext.git?.branch,
-      recentCommit: workContext.git?.recentCommits?.[0]?.message || null,
-      hasUncommitted: workContext.git?.hasUncommitted || false
-    };
-  }
+  // Work context is deliberately NOT returned here (review P1): the response
+  // is exactly what the screen states. The local context still does its real
+  // job above — it sets this session's presence note so other people see what
+  // you are working on — which is a side effect, not a payload.
 
   return response;
 }

package/tools/token.js

@@ -82,9 +82,12 @@ hands you a new token, paste it here.`
   // Remove old keypair (security improvement). Remember whether one existed:
   // the success copy below claims "old local keys removed" and must only say
   // that when it actually happened.
-  const removedKeypair = config.hasKeypair();
-  if (removedKeypair) {
+  // Checked AFTER, not before: "they existed and we called remove" is not the
+  // same fact as "they are gone", and until this round they were not gone.
+  let removedKeypair = false;
+  if (config.hasKeypair()) {
     config.removeKeypair();
+    removedKeypair = !config.hasKeypair();
   }
 
   // Send initial heartbeat

package/version.json

@@ -1,13 +1,12 @@
 {
-  "version": "0.8.21",
-  "updated": "2026-08-31",
-  "changelog": "People. You can now put yourself on a list of people who chose to be findable \u2014 say vibe list me \"what you're building\" \u2014 and browse it with vibe people. It is opt-in, it is not the same as vibe who (who's present this moment), and you can take yourself off any time with vibe unlist me. Nothing lists you automatically, nothing ranks or recommends anyone, and nothing picks who you message: you choose someone because their work makes you curious.",
+  "version": "0.8.23",
+  "updated": "2026-09-01",
+  "changelog": "The install tells the truth about the room. Setup used to say “0 builders online” to every newcomer, because the roster is private before you sign in and it was counting names it was never given; now it reads the count the server actually serves, and after sign-in it lists real people and what they are working on. And a first message to someone before you have signed in no longer asks GitHub to sign you in as them.",
   "features": [
-    "vibe people \u2014 everyone who chose to be findable, online or not; flat list, no ranking, no suggestions",
-    "vibe list me \"building \u2026\" \u2014 put yourself on the list with what you're working on; says plainly that anyone signed in can then find and DM you",
-    "vibe unlist me \u2014 take yourself off; conversations untouched",
-    "Listing reads the list back before claiming it worked, and says which actually happened",
-    "Other people's words render inert: no HTML, no markdown styling, no forged rows \u2014 and no censoring either"
+    "Setup says how many people are here now — never a zero it did not measure",
+    "After sign-in, setup lists the people actually here and what they are working on",
+    "Messaging @someone before sign-in starts your own sign-in, not one for them",
+    "Setup's quick start is a sentence you can say, not a command to learn"
   ],
   "deprecated": [],
   "breaking": false,