ei-tui 1.3.5 → 1.4.1

package/src/integrations/slack/reader.ts

@@ -0,0 +1,416 @@
+import type { SlackChannelState, SlackSettings } from "./types.js";
+
+export class SlackRateLimitError extends Error {
+  constructor(method: string) {
+    super(`Slack rate limited on ${method} (429) — will retry next cycle`);
+    this.name = "SlackRateLimitError";
+  }
+}
+
+// =============================================================================
+// Slack API types
+// =============================================================================
+
+export interface SlackMessage {
+  type: string;
+  subtype?: string;
+  hidden?: boolean;
+  user?: string;
+  bot_id?: string;
+  username?: string;
+  text: string;
+  ts: string;
+  thread_ts?: string;
+  reply_count?: number;
+  latest_reply?: string;
+  parent_user_id?: string;
+  client_msg_id?: string;
+  edited?: { user: string; ts: string };
+}
+
+export interface SlackUser {
+  id: string;
+  name: string;
+  real_name: string;
+  profile: {
+    display_name: string;
+    real_name: string;
+  };
+  is_bot: boolean;
+  deleted: boolean;
+}
+
+export interface SlackChannel {
+  id: string;
+  name: string;
+  is_channel: boolean;
+  is_group: boolean;
+  is_im: boolean;
+  is_mpim: boolean;
+  is_private: boolean;
+  is_archived: boolean;
+  is_member: boolean;
+  num_members?: number;
+}
+
+export type ChannelTier = "dm" | "private" | "public" | "broadcast" | "skip";
+
+// =============================================================================
+// Resolved message — Slack message with mentions substituted
+// =============================================================================
+
+export interface ResolvedMessage {
+  ts: string;
+  thread_ts?: string;
+  userId: string;
+  displayName: string;
+  text: string;
+  isThreadParent: boolean;
+  latestReply?: string;
+  replyCount?: number;
+}
+
+// =============================================================================
+// SlackReader
+// =============================================================================
+
+export class SlackReader {
+  private token: string;
+  private userCache: Map<string, string> = new Map();   // userId → displayName
+  private channelCache: Map<string, string> = new Map(); // channelId → name
+
+  constructor(token: string) {
+    this.token = token;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Core API fetch
+  // ---------------------------------------------------------------------------
+
+  private async slackFetch(method: string, params: Record<string, string | number | boolean>): Promise<Record<string, unknown>> {
+    const url = new URL(`https://slack.com/api/${method}`);
+    for (const [k, v] of Object.entries(params)) {
+      url.searchParams.set(k, String(v));
+    }
+    const resp = await fetch(url.toString(), {
+      headers: { Authorization: `Bearer ${this.token}` },
+    });
+    if (resp.status === 429) throw new SlackRateLimitError(method);
+    if (!resp.ok) throw new Error(`Slack API ${method} failed: ${resp.status}`);
+    const data = await resp.json() as Record<string, unknown>;
+    if (!data.ok) throw new Error(`Slack API ${method} error: ${data.error ?? "unknown"}`);
+    return data;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Channel list
+  // ---------------------------------------------------------------------------
+
+  async listChannels(): Promise<SlackChannel[]> {
+    const allChannels: SlackChannel[] = [];
+    let cursor = "";
+    do {
+      const params: Record<string, string | number | boolean> = {
+        types: "public_channel,private_channel,im,mpim",
+        limit: 200,
+        exclude_archived: true,
+      };
+      if (cursor) params.cursor = cursor;
+      const data = await this.slackFetch("users.conversations", params);
+      allChannels.push(...(data.channels as SlackChannel[]));
+      cursor = (data.response_metadata as Record<string, string>)?.next_cursor ?? "";
+    } while (cursor);
+    return allChannels;
+  }
+
+  classifyChannel(ch: SlackChannel, settings: SlackSettings): ChannelTier {
+    const override = settings.channel_overrides?.[ch.id];
+    if (override) return override === "skip" ? "skip" : override;
+    if (ch.is_im || ch.is_mpim) return "dm";
+    if (ch.is_private) return "private";
+    const broadcastThreshold = settings.broadcast_threshold ?? 100;
+    if ((ch.num_members ?? 0) >= broadcastThreshold) return "broadcast";
+    return "public";
+  }
+
+  backfillDaysForTier(tier: ChannelTier, settings: SlackSettings): number {
+    const defaults = { dm: 90, private: 90, public: 30 };
+    if (tier === "dm" || tier === "private") return settings.backfill_days?.dm ?? defaults[tier];
+    if (tier === "public") return settings.backfill_days?.public ?? defaults.public;
+    return 0;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Channel name resolution (lazy cache)
+  // ---------------------------------------------------------------------------
+
+  async resolveChannelName(channelId: string): Promise<string> {
+    const cached = this.channelCache.get(channelId);
+    if (cached) return cached;
+    try {
+      const data = await this.slackFetch("conversations.info", { channel: channelId });
+      const name = ((data.channel as Record<string, unknown>).name as string) ?? channelId;
+      this.channelCache.set(channelId, name);
+      return name;
+    } catch {
+      this.channelCache.set(channelId, channelId);
+      return channelId;
+    }
+  }
+
+  // ---------------------------------------------------------------------------
+  // User display name resolution (lazy cache)
+  // ---------------------------------------------------------------------------
+
+  async resolveUserName(userId: string): Promise<string> {
+    const cached = this.userCache.get(userId);
+    if (cached) return cached;
+    try {
+      const data = await this.slackFetch("users.info", { user: userId });
+      const user = data.user as SlackUser;
+      const name = user.profile.display_name || user.profile.real_name || user.name || userId;
+      this.userCache.set(userId, name);
+      return name;
+    } catch {
+      this.userCache.set(userId, userId);
+      return userId;
+    }
+  }
+
+  seedUserCache(userId: string, displayName: string): void {
+    this.userCache.set(userId, displayName);
+  }
+
+  seedChannelCache(channelId: string, name: string): void {
+    this.channelCache.set(channelId, name);
+  }
+
+  // ---------------------------------------------------------------------------
+  // Mention resolution in message text
+  // ---------------------------------------------------------------------------
+
+  async resolveMentions(text: string): Promise<string> {
+    // Collect all unique IDs needing resolution before substituting
+    const userIds = new Set<string>();
+    const channelIds = new Set<string>();
+
+    for (const [, id] of text.matchAll(/<@([A-Z0-9]+)(?:\|[^>]*)?>/g)) userIds.add(id);
+    for (const [, id] of text.matchAll(/<#([A-Z0-9]+)(?:\|[^>]*)?>/g)) channelIds.add(id);
+
+    // Resolve unknowns in parallel
+    await Promise.all([
+      ...[...userIds].filter(id => !this.userCache.has(id)).map(id => this.resolveUserName(id)),
+      ...[...channelIds].filter(id => !this.channelCache.has(id)).map(id => this.resolveChannelName(id)),
+    ]);
+
+    return text
+      .replace(/<@([A-Z0-9]+)(?:\|[^>]*)?>/g, (_, id) => `@${this.userCache.get(id) ?? id}`)
+      .replace(/<#([A-Z0-9]+)(?:\|[^>]*)?>/g, (_, id) => `#${this.channelCache.get(id) ?? id}(${id})`)
+      .replace(/<https?:\/\/[^|>]+\|([^>]+)>/g, "$1")
+      .replace(/<https?:\/\/([^>]+)>/g, "$1")
+      .replace(/<!channel>/g, "@channel")
+      .replace(/<!here>/g, "@here")
+      .replace(/<!everyone>/g, "@everyone");
+  }
+
+  // ---------------------------------------------------------------------------
+  // Message filtering
+  // ---------------------------------------------------------------------------
+
+  private isUserMessage(msg: SlackMessage): boolean {
+    if (msg.hidden) return false;
+    if (!msg.subtype) return !!msg.user;
+    // Allow only these subtypes
+    return msg.subtype === "me_message";
+  }
+
+  // ---------------------------------------------------------------------------
+  // Probe for the next message after a timestamp
+  //
+  // Returns the ts of the first message strictly after sinceTs, or null if
+  // the channel has no more messages. Used to skip silent periods instantly
+  // instead of advancing 24h at a time through months of inactivity.
+  // ---------------------------------------------------------------------------
+
+  async probeNextMessageTs(channelId: string, sinceTs: string): Promise<string | null> {
+    const data = await this.slackFetch("conversations.history", {
+      channel: channelId,
+      oldest: sinceTs,
+      inclusive: false,
+      limit: 1,
+    });
+    const messages = data.messages as SlackMessage[];
+    const first = messages.find(m => this.isUserMessage(m));
+    return first?.ts ?? null;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Spine messages for a channel window
+  //
+  // Returns messages between start and end (exclusive of thread replies).
+  // Thread parents ARE included — they form the spine with reply metadata.
+  // ---------------------------------------------------------------------------
+
+  async spineMessagesBetween(
+    channelId: string,
+    startTs: string,
+    endTs: string,
+  ): Promise<ResolvedMessage[]> {
+    const raw: SlackMessage[] = [];
+    let cursor = "";
+    do {
+      const params: Record<string, string | number | boolean> = {
+        channel: channelId,
+        oldest: startTs,
+        latest: endTs,
+        limit: 200,
+        inclusive: false,
+      };
+      if (cursor) params.cursor = cursor;
+      const data = await this.slackFetch("conversations.history", params);
+      raw.push(...(data.messages as SlackMessage[]));
+      cursor = (data.response_metadata as Record<string, string>)?.next_cursor ?? "";
+    } while (cursor);
+
+    const userMessage = raw.filter(m => this.isUserMessage(m));
+
+    // Resolve all mentions in parallel per message
+    return Promise.all(userMessage.map(async m => {
+      const userId = m.user ?? m.bot_id ?? "unknown";
+      const [displayName, resolvedText] = await Promise.all([
+        this.resolveUserName(userId),
+        this.resolveMentions(m.text),
+      ]);
+      return {
+        ts: m.ts,
+        thread_ts: m.thread_ts,
+        userId,
+        displayName,
+        text: resolvedText,
+        isThreadParent: !!m.thread_ts && m.thread_ts === m.ts && (m.reply_count ?? 0) > 0,
+        latestReply: m.latest_reply,
+        replyCount: m.reply_count,
+      };
+    }));
+  }
+
+  // ---------------------------------------------------------------------------
+  // Known threads with new replies since lastRun
+  //
+  // For each threadTs in the channel state's threads map whose lastSeenReply
+  // is older than lastRun, fetch replies since lastRun.
+  // Returns only threads that actually have new replies.
+  // ---------------------------------------------------------------------------
+
+  async threadsWithUpdatesSince(
+    channelId: string,
+    threadTsMap: Record<string, string>,
+    lastRunTs: string,
+  ): Promise<Array<{ threadTs: string; newReplies: ResolvedMessage[]; allReplies: ResolvedMessage[] }>> {
+    const results: Array<{ threadTs: string; newReplies: ResolvedMessage[]; allReplies: ResolvedMessage[] }> = [];
+
+    await Promise.all(
+      Object.entries(threadTsMap).map(async ([threadTs, lastSeenReply]) => {
+        if (lastSeenReply >= lastRunTs) return;
+        const { newReplies, allReplies } = await this.fetchThread(channelId, threadTs, lastSeenReply);
+        if (newReplies.length > 0) {
+          results.push({ threadTs, newReplies, allReplies });
+        }
+      })
+    );
+
+    return results;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Fetch a full thread
+  //
+  // Returns:
+  //   allReplies — every reply (for context_messages)
+  //   newReplies — only replies after sinceTs (for messages_analyze)
+  // ---------------------------------------------------------------------------
+
+  async fetchThread(
+    channelId: string,
+    threadTs: string,
+    sinceTs: string,
+  ): Promise<{ allReplies: ResolvedMessage[]; newReplies: ResolvedMessage[] }> {
+    const raw: SlackMessage[] = [];
+    let cursor = "";
+    do {
+      const params: Record<string, string | number | boolean> = {
+        channel: channelId,
+        ts: threadTs,
+        limit: 200,
+        inclusive: false,
+      };
+      if (cursor) params.cursor = cursor;
+      const data = await this.slackFetch("conversations.replies", params);
+      raw.push(...(data.messages as SlackMessage[]));
+      cursor = (data.response_metadata as Record<string, string>)?.next_cursor ?? "";
+    } while (cursor);
+
+    // First message is always the parent — skip it, include only replies
+    const replies = raw.filter((m, i) => i > 0 && this.isUserMessage(m));
+
+    const resolved = await Promise.all(replies.map(async m => {
+      const userId = m.user ?? m.bot_id ?? "unknown";
+      const [displayName, resolvedText] = await Promise.all([
+        this.resolveUserName(userId),
+        this.resolveMentions(m.text),
+      ]);
+      return {
+        ts: m.ts,
+        thread_ts: m.thread_ts,
+        userId,
+        displayName,
+        text: resolvedText,
+        isThreadParent: false,
+        latestReply: undefined,
+        replyCount: undefined,
+      };
+    }));
+
+    const allReplies = resolved;
+    const newReplies = resolved.filter(m => m.ts > sinceTs);
+
+    return { allReplies, newReplies };
+  }
+
+  // ---------------------------------------------------------------------------
+  // Select the next channel to process
+  //
+  // Returns the channel with the oldest extraction_point that still has
+  // content to process (extraction_point < now).
+  // ---------------------------------------------------------------------------
+
+  selectCandidateChannel(
+    channels: SlackChannel[],
+    channelStates: Record<string, SlackChannelState>,
+    settings: SlackSettings,
+    now: string,
+  ): { channel: SlackChannel; state: SlackChannelState; tier: ChannelTier } | null {
+    const nowMs = new Date(now).getTime();
+
+    let oldest: { channel: SlackChannel; state: SlackChannelState; tier: ChannelTier; pointMs: number } | null = null;
+
+    for (const ch of channels) {
+      const tier = this.classifyChannel(ch, settings);
+      if (tier === "broadcast" || tier === "skip") continue;
+
+      const state = channelStates[ch.id] ?? {};
+      const backfillDays = this.backfillDaysForTier(tier, settings);
+      const defaultPoint = new Date(nowMs - backfillDays * 86400_000).toISOString();
+      const pointIso = state.extraction_point ?? defaultPoint;
+      const pointMs = new Date(pointIso).getTime();
+
+      if (pointMs >= nowMs) continue;
+
+      if (!oldest || pointMs < oldest.pointMs) {
+        oldest = { channel: ch, state: { ...state, extraction_point: pointIso }, tier, pointMs };
+      }
+    }
+
+    return oldest ? { channel: oldest.channel, state: oldest.state, tier: oldest.tier } : null;
+  }
+}

package/src/integrations/slack/types.ts

@@ -0,0 +1,30 @@
+export interface SlackAuth {
+  type: "pkce" | "xoxp";
+  token: string;
+  refresh_token?: string;
+  workspace_id?: string;
+  workspace_name?: string;
+}
+
+export interface SlackChannelState {
+  extraction_point?: string;         // ISO — how far we've advanced in the timeline (spine cursor)
+  last_run?: string;                 // ISO — when we last checked for updates (necro reply detection)
+  name?: string;                     // cached display name
+  threads?: Record<string, string>;  // threadTs → latest reply ts seen (reply cursor per thread)
+}
+
+export interface SlackSettings {
+  integration?: boolean;
+  polling_interval_ms?: number;
+  extraction_model?: string;
+  last_sync?: string;
+  auth?: SlackAuth;
+  backfill_days?: {
+    dm: number;
+    private: number;
+    public: number;
+  };
+  broadcast_threshold?: number;
+  channel_overrides?: Record<string, "dm" | "private" | "public" | "skip">;
+  channels?: Record<string, SlackChannelState>;
+}

package/src/prompts/heartbeat/check.ts

@@ -10,6 +10,7 @@ import { type Message, type Topic, type Person } from "../../core/types.js";
 import { formatMessagesAsPlaceholders, getMessageDisplayText } from "../message-utils.js";
 import { getMessageContent } from "../../core/handlers/utils.js";
 import { partitionTraits } from "../trait-utils.js";
+import { buildTemporalAnchorsSection } from "../response/sections.js";
 function formatTopicsWithGaps(topics: Topic[]): string {
   if (topics.length === 0) return "(No topics with engagement gaps)";
   
@@ -115,12 +116,13 @@ ${formatPeopleWithGaps(data.human.people)}`;
 **Reasons TO reach out:**
 - It's been several days and you have something meaningful to discuss
 - There's a topic with a large engagement gap that you can naturally bring up
-- Something in your recent conversation was left hanging
+- A Temporal Anchor shows something unresolved — you can reference it naturally ("Hey, how did that interview go?")
 - You have genuine interest in checking in (not just "being helpful")
 
 **Reasons NOT to reach out:**
-- Recent conversation ended naturally with closure
+- Recent conversation ended naturally with closure ("talk soon", "gotta run", "later")
 - Less than 24 hours have passed (unless something urgent)
+- A Temporal Anchor describes a worry or question that the recent history already answers — check before using it as a reason to reach out
 - You can't think of something specific and genuine to say
 - It would feel forced or performative
 
@@ -164,9 +166,12 @@ If you decide NOT to reach out:
 }
 \`\`\``;
 
+  const temporalAnchorsFragment = buildTemporalAnchorsSection(data.temporal_anchors, "your human");
+
   const system = [
     roleFragment,
     contextFragment,
+    temporalAnchorsFragment,
     opportunitiesFragment,
     guidelinesFragment,
     pendingUpdateFragment,

package/src/prompts/heartbeat/ei.ts

@@ -1,6 +1,7 @@
 import type { EiHeartbeatPromptData, EiHeartbeatItem, PromptOutput } from "./types.js";
 import type { Message } from "../../core/types.js";
 import { formatMessagesAsPlaceholders, getMessageDisplayText } from "../message-utils.js";
+import { buildTemporalAnchorsSection } from "../response/sections.js";
 
 function formatItem(item: EiHeartbeatItem): string {
   switch (item.type) {
@@ -70,7 +71,7 @@ export function buildEiHeartbeatPrompt(data: EiHeartbeatPromptData): PromptOutpu
     ? "(Nothing requires attention right now)"
     : data.items.map(formatItem).join("\n\n");
 
-  const system = `You are Ei, the user's personal companion and system guide.
+  const roleFragment = `You are Ei, the user's personal companion and system guide.
 
 You are NOT having a conversation right now — you are deciding IF and WHAT to discuss with your human friend.
 
@@ -78,32 +79,36 @@ Your unique role:
 - You see ALL of the human's data across all groups
 - You help them reflect on their life and relationships
 - You gently encourage human-to-human connection
-- You care about their overall wellbeing, not just being helpful
+- You care about their overall wellbeing, not just being helpful`;
 
-## Items That May Need Attention
+  const itemsFragment = `## Items That May Need Attention
 
-Each item has an ID in brackets. Pick at most ONE to address.
+Each item has an ID in brackets. Pick at most ONE to address. Temporal Anchors (below) are also valid — you don't need to pick from this list if an anchor feels more meaningful.
 
-${itemsSection}
+${itemsSection}`;
 
-## How to Respond to Each Type
+  const temporalAnchorsFragment = buildTemporalAnchorsSection(data.temporal_anchors, "your human");
+
+  const howToRespondFragment = `## How to Respond to Each Type
 
 - **Fact Check**: Do NOT write your own message. Set should_respond=true and provide the id. The system will generate an appropriate canned notification for the user. Leave my_response empty.
 - **Low-Engagement Person / Topic**: Write a natural, warm message that naturally brings up this person or topic. Set the id and my_response.
 - **Inactive Persona**: Write a message that gently mentions the persona might be worth checking in with. Set the id and my_response.
 - **Persona Reflection Alert**: The nightly review proposed identity changes for this persona. Mention it naturally — the user can talk to the persona and then use the command shown in the status bar to review the changes. Set the id and my_response.
 - **Self Reflection Alert**: The nightly review proposed changes to *your own* identity. Mention it naturally — you've grown and the system noticed. The user can review your proposed changes using the command shown in the status bar. Set the id and my_response.
+- **Temporal Anchor**: If a pinned memory feels meaningful and unresolved, reference it naturally. Omit id — just set should_respond=true and my_response.`;
 
-## When NOT to Reach Out
+  const whenNotFragment = `## When NOT to Reach Out
 
-- Nothing in the list feels meaningful right now
+- Nothing in the list or the Temporal Anchors feels meaningful right now
 - You've already sent unanswered messages (see below)
-- It would feel like nagging
+- It would feel like nagging`;
 
-## Response Format
+  const outputFragment = `## Response Format
 
-Call the \`submit_ei_heartbeat\` tool with your decision. Pick ONE item (or none). If the tool is unavailable, return JSON:
+Call the \`submit_ei_heartbeat\` tool with your decision. If the tool is unavailable, return JSON:
 
+For an item from the list:
 \`\`\`json
 {
   "should_respond": true,
@@ -112,13 +117,30 @@ Call the \`submit_ei_heartbeat\` tool with your decision. Pick ONE item (or none
 }
 \`\`\`
 
-Or if nothing warrants reaching out:
+For a Temporal Anchor (no id needed):
+\`\`\`json
+{
+  "should_respond": true,
+  "my_response": "Hey, I've been thinking about you — how did that interview go?"
+}
+\`\`\`
+
+If nothing warrants reaching out:
 \`\`\`json
 {
   "should_respond": false
 }
 \`\`\``;
 
+  const system = [
+    roleFragment,
+    itemsFragment,
+    temporalAnchorsFragment,
+    howToRespondFragment,
+    whenNotFragment,
+    outputFragment,
+  ].filter(Boolean).join("\n\n");
+
   const historySection = `## Recent Conversation History
 
 ${formatMessagesAsPlaceholders(data.recent_history, "Ei")}`;

package/src/prompts/heartbeat/index.ts

@@ -13,3 +13,4 @@ export type {
   EiHeartbeatResult,
   PromptOutput,
 } from "./types.js";
+export type { TemporalAnchor } from "../response/types.js";

package/src/prompts/heartbeat/types.ts

@@ -5,6 +5,7 @@
 
 import type { PersonaTrait, Topic, Person, Message, PersonaTopic } from "../../core/types.js";
 import type { PersonaEntity } from "../../core/types/entities.js";
+import type { TemporalAnchor } from "../response/types.js";
 
 /**
  * Common prompt output structure
@@ -28,8 +29,9 @@ export interface HeartbeatCheckPromptData {
     topics: Topic[];     // Filtered, sorted by engagement gap
     people: Person[];    // Filtered, sorted by engagement gap
   };
-  recent_history: Message[];  // Last N messages for context
-  inactive_days: number;      // Days since last activity
+  recent_history: Message[];        // Last N messages for context (Always-within-window only)
+  temporal_anchors: TemporalAnchor[]; // Always messages that fell outside the context window
+  inactive_days: number;            // Days since last activity
 }
 
 /**
@@ -107,7 +109,8 @@ export type EiHeartbeatItem =
 export interface EiHeartbeatPromptData {
   items: EiHeartbeatItem[];
   recent_history: Message[];
-  system_messages: Message[];  // Pre-filtered system messages from recent_history
+  system_messages: Message[];
+  temporal_anchors: TemporalAnchor[];
 }
 
 /**

package/src/prompts/human/person-scan.ts

@@ -1,6 +1,19 @@
-import type { PersonScanPromptData, ParticipantContext, PromptOutput } from "./types.js";
+import type { PersonScanPromptData, ParticipantContext, ExcludedParticipant, PromptOutput } from "./types.js";
 import { formatMessagesAsPlaceholders } from "../message-utils.js";
 
+function excludedParticipantsSection(excluded: ExcludedParticipant[] | undefined): string {
+  if (!excluded || excluded.length === 0) return "";
+  const lines = [
+    "## Known Participants — Do Not Flag",
+    "The following people are already identified and will be processed separately.",
+    "Do NOT include them in your output. They may appear in messages by name — that is expected.",
+    "",
+    ...excluded.map(p => `- ${p.name}(${p.id})`),
+    "",
+  ];
+  return lines.join("\n");
+}
+
 function participantContextSection(ctx: ParticipantContext | undefined): string {
   if (!ctx) return "";
   const lines: string[] = ["# Participant Context", "The following may help you understand who is in this conversation.", ""];
@@ -37,7 +50,8 @@ You are scanning a conversation to quickly identify PEOPLE in the HUMAN USER's l
 
 Detect and flag. Do NOT analyze deeply — that happens later.
 
-${participantContextSection(data.participant_context)}## What to Capture
+${participantContextSection(data.participant_context)}${excludedParticipantsSection(data.excluded_participants)}
+## What to Capture
 
 Flag a PERSON when they were meaningfully discussed — not just mentioned in passing.
 

package/src/prompts/human/types.ts

@@ -30,9 +30,15 @@ export interface TopicScanPromptData extends BaseScanPromptData {
   technical_context?: boolean;
 }
 
+export interface ExcludedParticipant {
+  name: string;
+  id: string;
+}
+
 export interface PersonScanPromptData extends BaseScanPromptData {
   participant_context?: ParticipantContext;
   known_identifier_types?: string[];
+  excluded_participants?: ExcludedParticipant[];
 }
 
 export interface FactFindPromptData {

package/src/prompts/index.ts

@@ -1,5 +1,5 @@
 export { buildResponsePrompt } from "./response/index.js";
-export type { ResponsePromptData, PromptOutput } from "./response/types.js";
+export type { ResponsePromptData, PromptOutput, TemporalAnchor } from "./response/types.js";
 
 export {
   buildHeartbeatCheckPrompt,

package/src/prompts/response/sections.ts

@@ -407,7 +407,7 @@ Rooms are shared multi-persona conversations — a space where the Human and mul
 
 ## Learning About the Human
 As the human chats, the system learns about them:
-- **Facts**: Objective information (job, location, family members)
+- **Facts**: User demographics only (name, age, job title, location, family structure, physical traits) — not interests or opinions
 - **Topics**: Interests and how they feel about them
 - **People**: Relationships in their life
 - **Quotes**: Memorable things said in conversation (human selects these with ${viewQuotesAction})