slashvibe-mcp 0.8.20 → 0.8.22

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/incoming.js

@@ -111,4 +111,43 @@ function inertField(text, maxLen = 80) {
   return flat.length > maxLen ? flat.slice(0, maxLen - 1) + '\u2026' : flat;
 }
 
-module.exports = { renderIncoming, neutralize, scrub, inertField, MSG_OPEN, MSG_CLOSE, MAX_BODY };
+/**
+ * inertField, plus the markup a rendered surface can act on.
+ *
+ * inertField defangs terminal/agent structure (control chars, bidi, backticks,
+ * brackets). It deliberately leaves HTML and Markdown alone, which is fine for
+ * a plain terminal line and NOT fine anywhere a client renders markup: `<br>`
+ * forges a new row, `<details>` hides text, `**x**` and a leading bullet fake
+ * structure (review P1 on the people list). This makes those inert while
+ * keeping every word visible — defanged, never censored.
+ */
+function inertMarkup(text, maxLen = 80) {
+  return inertField(text, maxLen)
+    .replaceAll('<', '\u2039')          // ‹ — no HTML element can form
+    .replaceAll('>', '\u203a')          // ›
+    .replaceAll('*', '\u2217')          // ∗ — no bold/italic/bullet
+    .replaceAll('|', '\u2502')          // │ — no table row
+    .replace(/^[\s\u2022•\-+#]+/, '')    // no forged list item or heading
+    // Emphasis pairs across the WHOLE rendered document, not within one field
+    // (review P1): a lone `_` here can close an emphasis the surface itself
+    // opened, or pair with another row. So every `_` and `~` in foreign PROSE
+    // is defanged unconditionally. Identity is handled separately — see
+    // inertIdentity, which preserves a handle exactly by other means.
+    .replace(/_/g, '\u2017')
+    .replace(/~/g, '\u223c');
+}
+
+/**
+ * A handle must render EXACTLY — mangling someone's identity to defang markup
+ * is its own dishonesty. So it is emitted inside an inline code span, where
+ * no emphasis, HTML or bullet can form, and where the fence itself cannot be
+ * broken (inertField has already neutralized backticks in foreign text).
+ */
+function inertIdentity(text, maxLen = 40) {
+  return '`' + inertField(text, maxLen)
+    .replaceAll('<', '\u2039')
+    .replaceAll('>', '\u203a')
+    .replace(/^[\s\u2022•\-+#]+/, '') + '`';
+}
+
+module.exports = { renderIncoming, neutralize, scrub, inertField, inertMarkup, inertIdentity, MSG_OPEN, MSG_CLOSE, MAX_BODY };

package/index.js

@@ -52,7 +52,16 @@ const SERVER_CAPABILITIES = {
 // ambient footer performs platform requests, so remember/reflect/call and
 // the manifest never carry it.
 const SKIP_FOOTER_TOOLS = ['vibe_init', 'vibe_doctor', 'vibe_test', 'vibe_update',
-  'vibe_capabilities', 'vibe_remember', 'vibe_reflect', 'vibe_call'];
+  'vibe_capabilities', 'vibe_remember', 'vibe_reflect', 'vibe_call',
+  // 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',
+  // 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
@@ -326,6 +335,14 @@ const kernelTools = {
   vibe_remember: require('./tools/remember'),
   vibe_reflect: require('./tools/reflect'),
   vibe_call: require('./tools/call'),
+
+  // ── People (opt-in discovery, platform#345 / vibe-mcp#28) ──────────────
+  // `vibe who` is who is present NOW; `vibe people` is who chose to be
+  // findable, online or not. Listing is always the person's own act — no
+  // path anywhere may set it for them.
+  vibe_people: require('./tools/people'),
+  vibe_list_me: require('./tools/list-me'),
+  vibe_unlist_me: require('./tools/unlist-me'),
 };
 
 // ─── Extras ──────────────────────────────────────────────────────────────

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slashvibe-mcp",
-  "version": "0.8.20",
+  "version": "0.8.22",
   "mcpName": "io.github.vibecodinginc/vibe",
   "description": "Presence + messaging for terminal coding agents (Claude Code, Codex, Cursor) \u2014 the /vibe kernel",
   "main": "index.js",
@@ -109,8 +109,10 @@
     "tools/inbox.js",
     "tools/init.js",
     "tools/intro.js",
+    "tools/list-me.js",
     "tools/mind.js",
     "tools/patterns.js",
+    "tools/people.js",
     "tools/play.js",
     "tools/poem.js",
     "tools/reflect.js",
@@ -122,6 +124,7 @@
     "tools/summarize.js",
     "tools/test.js",
     "tools/token.js",
+    "tools/unlist-me.js",
     "tools/update.js",
     "tools/weave.js",
     "tools/who.js",

package/scripts/verb-canary.mjs

@@ -12,7 +12,7 @@ import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
-const VERBS = ['vibe_capabilities', 'vibe_remember', 'vibe_reflect', 'vibe_call', 'vibe_dm', 'vibe_inbox', 'vibe_reply'];
+const VERBS = ['vibe_capabilities', 'vibe_remember', 'vibe_reflect', 'vibe_call', 'vibe_dm', 'vibe_inbox', 'vibe_reply', 'vibe_people', 'vibe_list_me', 'vibe_unlist_me'];
 const LEGAL = new Set(['granted', 'available', 'off', 'unavailable']);
 
 function rpc(child, msg) {

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;
   }
 }
 
@@ -1315,8 +1383,70 @@ async function setNotificationPace(pace) {
   }
 }
 
+/**
+ * The people list (opt-in discovery, platform#345). Two contained calls:
+ * flip your OWN listed flag, and read the people who chose to be findable.
+ * Nothing here ranks, recommends, or lists anyone automatically.
+ */
+/**
+ * The two decisions the people helpers make, as pure functions so the pins
+ * exercise the REAL logic rather than a stubbed result (review P2).
+ */
+function interpretListedResponse(result, want) {
+  if (!result || result.success === false) {
+    return { ok: false, error: result?.error || 'request_failed', message: result?.message };
+  }
+  const echoed = result?.user?.listed;
+  if (typeof echoed !== 'boolean') {
+    return { ok: false, error: 'unconfirmed', message: 'the server did not say whether the change took' };
+  }
+  if (echoed !== want) {
+    return { ok: false, error: 'unconfirmed', message: `the server reports listed=${echoed}` };
+  }
+  return { ok: true, listed: echoed };
+}
+
+function interpretDirectoryResponse(result) {
+  if (!result || result.success === false) {
+    return { ok: false, error: result?.error || 'request_failed', message: result?.message };
+  }
+  if (!Array.isArray(result.listings)) {
+    return { ok: false, error: 'malformed_response', message: 'the list came back without entries' };
+  }
+  return { ok: true, listings: result.listings, count: result.count, note: result.note };
+}
+
+async function setListed(listed, building) {
+  const want = listed === true;
+  const body = { listed: want };
+  // `building` rides along ONLY when the person supplied it with the action —
+  // the platform's contained self-profile write owns both fields.
+  if (typeof building === 'string' && building.trim()) body.building = building.trim();
+  try {
+    // The SERVER'S ECHO is the fact, not the absence of an error (review P1).
+    return interpretListedResponse(await request('POST', '/api/users', body, { auth: true }), want);
+  } catch (e) {
+    return { ok: false, error: 'transport_failed', message: e.message };
+  }
+}
+
+async function getPeople() {
+  try {
+    // A response without a listings ARRAY is malformed — reporting it as an
+    // empty list would turn a read failure into "nobody is here" (review P2).
+    return interpretDirectoryResponse(await request('GET', '/api/directory'));
+  } catch (e) {
+    return { ok: false, error: 'transport_failed', message: e.message };
+  }
+}
+
 module.exports = {
   setNotificationPace,
+  // People (opt-in discovery)
+  setListed,
+  getPeople,
+  interpretListedResponse,
+  interpretDirectoryResponse,
   // Session
   registerSession,
   setSessionId,
@@ -1325,6 +1455,7 @@ module.exports = {
   // Presence
   heartbeat,
   getActiveUsers,
+  getActiveUsersResult,
   setVisibility,
   sendTypingIndicator,
   getTypingUsers,
@@ -1332,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,