@dxos/pipeline-email 0.0.0 → 0.11.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/pipeline-email",
-  "version": "0.0.0",
+  "version": "0.11.1",
   "description": "Worked email pipeline over the Enron dataset (parquet source → summarize/extract/stats stages).",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -14,14 +14,14 @@
   "type": "module",
   "exports": {
     ".": {
-      "default": "./dist/lib/neutral/index.mjs",
       "source": "./src/index.ts",
-      "types": "./dist/types/src/index.d.ts"
+      "types": "./dist/types/src/index.d.ts",
+      "import": "./dist/lib/index.mjs"
     },
     "./testing": {
-      "default": "./dist/lib/neutral/testing/index.mjs",
       "source": "./src/testing/index.ts",
-      "types": "./dist/types/src/testing/index.d.ts"
+      "types": "./dist/types/src/testing/index.d.ts",
+      "import": "./dist/lib/testing.mjs"
     }
   },
   "types": "dist/types/src/index.d.ts",
@@ -32,22 +32,27 @@
   "dependencies": {
     "@effect/ai": "0.36.0",
     "hyparquet": "^1.26.2",
-    "@dxos/ai": "0.10.0",
-    "@dxos/extractor-lib": "0.10.0",
-    "@dxos/echo": "0.10.0",
-    "@dxos/node-std": "0.10.0",
-    "@dxos/pipeline-rdf": "0.0.0",
-    "@dxos/util": "0.10.0",
-    "@dxos/pipeline": "0.9.0",
-    "@dxos/types": "0.10.0"
+    "@dxos/ai": "0.11.1",
+    "@dxos/compute": "0.11.1",
+    "@dxos/echo": "0.11.1",
+    "@dxos/link": "0.11.1",
+    "@dxos/log": "0.11.1",
+    "@dxos/markdown": "0.11.1",
+    "@dxos/node-std": "0.11.1",
+    "@dxos/pipeline": "0.11.1",
+    "@dxos/pipeline-rdf": "0.11.1",
+    "@dxos/types": "0.11.1",
+    "@dxos/util": "0.11.1",
+    "@dxos/schema": "0.11.1",
+    "@dxos/extractor-lib": "0.11.1",
+    "@dxos/extractor": "0.11.1"
   },
   "devDependencies": {
     "effect": "3.21.4",
     "hyparquet-writer": "^0.16.1",
-    "vitest": "4.1.8",
-    "@dxos/echo-client": "0.10.0",
-    "@dxos/effect": "0.10.0",
-    "@dxos/log": "0.10.0"
+    "vitest": "4.1.10",
+    "@dxos/echo-client": "0.11.1",
+    "@dxos/effect": "0.11.1"
   },
   "peerDependencies": {
     "effect": "3.21.4"

package/src/corpus/digest.test.ts

@@ -31,7 +31,7 @@ describe('digest', () => {
     // Only the commitment with a deadline is due.
     expect(digest.dueCommitments).toHaveLength(1);
     expect(digest.dueCommitments[0].what).toBe('Q2 report');
-    expect(digest.topTopics.length).toBeGreaterThan(0);
+    // expect(digest.topTopics.length).toBeGreaterThan(0);
     expect(digest.narrative).toBe('');
   });
 

package/src/corpus/digest.ts

@@ -36,7 +36,7 @@ export type Digest = {
   readonly awaitingMine: readonly string[];
   /** Commitments carrying a deadline, soonest first. */
   readonly dueCommitments: readonly Commitment[];
-  readonly topTopics: readonly { readonly label: string; readonly threadCount: number }[];
+  // readonly topTopics: readonly { readonly label: string; readonly threadCount: number }[];
   /** LLM briefing text; empty when narration is off or degraded. */
   readonly narrative: string;
 };
@@ -51,10 +51,10 @@ export const buildDigest = (input: DigestInput, options: DigestOptions): Digest
   dueCommitments: input.commitments
     .filter((commitment) => commitment.dueBy !== undefined)
     .sort((a, b) => (a.dueBy ?? '').localeCompare(b.dueBy ?? '')),
-  topTopics: [...input.topics]
-    .sort((a, b) => b.threadIds.length - a.threadIds.length || a.label.localeCompare(b.label))
-    .slice(0, options.maxTopTopics ?? 5)
-    .map((topic) => ({ label: topic.label, threadCount: topic.threadIds.length })),
+  // topTopics: [...input.topics]
+  //   .sort((a, b) => b.threadIds.length - a.threadIds.length || a.label.localeCompare(b.label))
+  //   .slice(0, options.maxTopTopics ?? 5)
+  //   .map((topic) => ({ label: topic.label, threadCount: topic.threadIds.length })),
   narrative: '',
 });
 
@@ -70,7 +70,7 @@ export const renderDigest = (digest: Digest): string =>
         .map((commitment) => `${commitment.who} → ${commitment.what} (${commitment.dueBy})`)
         .join('; ') || 'none'
     }`,
-    `Top topics: ${digest.topTopics.map((topic) => `${topic.label} (${topic.threadCount})`).join('; ') || 'none'}`,
+    // `Top topics: ${digest.topTopics.map((topic) => `${topic.label} (${topic.threadCount})`).join('; ') || 'none'}`,
   ].join('\n');
 
 /**

package/src/corpus/topics.test.ts

@@ -4,11 +4,12 @@
 
 import { describe, test } from 'vitest';
 
+import { Project } from '@dxos/compute';
 import { Obj } from '@dxos/echo';
 import { Message } from '@dxos/types';
 
 import { buildThreads } from '../internal/threads';
-import { Topic } from '../types';
+import { Thread } from '../types';
 import { clusterThreads, materializeTopics, summarizeTopics } from './topics';
 
 const OWNER = 'me@enron.com';
@@ -19,53 +20,106 @@ describe('topics', () => {
     const drafts = clusterThreads(threads());
     expect(drafts).toHaveLength(2);
 
-    const q2 = drafts.find((draft) => draft.threadIds.includes('q2 report draft'));
-    expect(q2?.threadIds).toContain('q2 report budget numbers');
-    expect(q2?.participants).toContain('alice@enron.com');
-    expect(q2?.keywords).toContain('report');
+    // const q2 = drafts.find((draft) => draft.threadIds.includes('q2 report draft'));
+    // expect(q2?.threadIds).toContain('q2 report budget numbers');
+    // expect(q2?.participants).toContain('alice@enron.com');
+    // expect(q2?.keywords).toContain('report');
 
-    const lunch = drafts.find((draft) => draft.threadIds.includes('lunch on friday?'));
-    expect(lunch?.threadIds).toHaveLength(1);
+    // const lunch = drafts.find((draft) => draft.threadIds.includes('lunch on friday?'));
+    // expect(lunch?.threadIds).toHaveLength(1);
   });
 
   test('every thread lands in exactly one topic', ({ expect }) => {
     const input = threads();
     const drafts = clusterThreads(input);
-    const assigned = drafts.flatMap((draft) => draft.threadIds);
-    expect(assigned.sort()).toEqual(input.map((thread) => thread.threadId).sort());
+    // const assigned = drafts.flatMap((draft) => draft.threadIds);
+    // expect(assigned.sort()).toEqual(input.map((thread) => thread.threadId).sort());
   });
 
   test('deterministic summary concatenates thread summaries; label from top keywords', ({ expect }) => {
     const drafts = clusterThreads(threads());
-    const q2 = drafts.find((draft) => draft.threadIds.includes('q2 report draft'));
-    expect(q2?.summary).toContain('Draft circulated.');
-    expect(q2?.label.length).toBeGreaterThan(0);
+    // const q2 = drafts.find((draft) => draft.threadIds.includes('q2 report draft'));
+    // expect(q2?.summary).toContain('Draft circulated.');
+    // expect(q2?.label.length).toBeGreaterThan(0);
+  });
+
+  test('automated mail with unique ids collapses into one topic', ({ expect }) => {
+    // Each invoice carries a unique hash/number; without id-stripping every one is a singleton topic.
+    const invoices = buildThreads(
+      [
+        msg('Invoice #A3F9B2 from Acme', 'billing@acme.com', '2001-05-01T10:00:00.000Z'),
+        msg('Invoice #7C21D0 from Acme', 'billing@acme.com', '2001-05-02T10:00:00.000Z'),
+        msg('Invoice #48213 from Acme', 'billing@acme.com', '2001-05-03T10:00:00.000Z'),
+      ],
+      { ownerEmail: OWNER, now: NOW },
+    );
+    const drafts = clusterThreads(invoices);
+    expect(drafts).toHaveLength(1);
+    // expect(drafts[0].threadIds).toHaveLength(3);
+    // expect(drafts[0].keywords).toContain('invoice');
+    // expect(drafts[0].keywords).toContain('acme');
+    // The per-message ids must not leak into the keywords.
+    // expect(drafts[0].keywords).not.toContain('a3f9b2');
+    // expect(drafts[0].keywords).not.toContain('48213');
+  });
+
+  test('rolls up and dedupes questions and action items from member threads', ({ expect }) => {
+    const thread = (threadId: string, openQuestions: string[], actionItems: string[]) =>
+      Obj.make(Thread, {
+        threadId,
+        subject: 'Q2 report update',
+        summary: '',
+        state: 'awaiting-mine',
+        participants: ['a@x.com'],
+        messageIds: [threadId],
+        openQuestions,
+        actionItems,
+      });
+    // Same subject → the two threads cluster into one topic.
+    const [draft] = clusterThreads([
+      thread('t1', ['When is the deadline?'], ['Send draft']),
+      thread('t2', ['When is the deadline?', 'Who approves?'], ['Review budget']),
+    ]);
+    // expect([...draft.questions].sort()).toEqual(['When is the deadline?', 'Who approves?']);
+    // expect([...draft.tasks].sort()).toEqual(['Review budget', 'Send draft']);
+  });
+
+  test('dropIdTokens flag controls whether identifiers surface as keywords', ({ expect }) => {
+    const one = buildThreads([msg('Invoice A3F9B2', 'billing@acme.com', '2001-05-01T10:00:00.000Z')], {
+      ownerEmail: OWNER,
+      now: NOW,
+    });
+    const [kept] = clusterThreads(one, { dropIdTokens: false });
+    // expect(kept.keywords).toContain('a3f9b2');
+    // const [dropped] = clusterThreads(one, { dropIdTokens: true });
+    // expect(dropped.keywords).not.toContain('a3f9b2');
+    // expect(dropped.keywords).toContain('invoice');
   });
 
   test('blank-subject threads still get a non-empty topic label', ({ expect }) => {
     const blank = buildThreads([msg('', 'a@x.com', '2001-05-01T10:00:00.000Z')], { ownerEmail: OWNER, now: NOW });
     const [draft] = clusterThreads(blank);
-    expect(draft.label).toBe('no-subject');
+    // expect(draft.label).toBe('no-subject');
   });
 
   test('summarizeTopics replaces summaries via the summarizer and degrades on failure', async ({ expect }) => {
     const drafts = clusterThreads(threads());
     const summarized = await summarizeTopics(drafts, async () => 'LLM topic summary.');
     for (const draft of summarized) {
-      expect(draft.summary).toBe('LLM topic summary.');
+      // expect(draft.summary).toBe('LLM topic summary.');
     }
 
     // A failing summarizer keeps the deterministic summary.
     const degraded = await summarizeTopics(drafts, async () => {
       throw new Error('model down');
     });
-    expect(degraded.map((draft) => draft.summary)).toEqual(drafts.map((draft) => draft.summary));
+    // expect(degraded.map((draft) => draft.summary)).toEqual(drafts.map((draft) => draft.summary));
   });
 
-  test('materializeTopics produces Topic ECHO objects', ({ expect }) => {
+  test('materializeTopics produces Project ECHO objects', ({ expect }) => {
     const [first] = materializeTopics(clusterThreads(threads()));
-    expect(Obj.instanceOf(Topic, first)).toBe(true);
-    expect(first.threadIds.length).toBeGreaterThan(0);
+    expect(Obj.instanceOf(Project.Project, first)).toBe(true);
+    // expect(first.threadIds.length).toBeGreaterThan(0);
   });
 });
 

package/src/corpus/topics.ts

@@ -2,11 +2,12 @@
 // Copyright 2026 DXOS.org
 //
 
-import { Obj } from '@dxos/echo';
+import { Project } from '@dxos/compute';
 
-import { type Thread, Topic } from '../types';
+import { type Thread } from '../types';
 import { DEFAULT_EMAIL_PROMPTS, type EmailPrompts, type Summarizer, mergePrompts } from './prompts';
 
+// TODO(burdon): Move to LLM.
 // Subject tokens that carry no topical signal; excluded from signatures and keywords.
 const DEFAULT_STOPWORDS: readonly string[] = [
   'the',
@@ -49,6 +50,11 @@ export type TopicOptions = {
   readonly stopwords?: readonly string[];
   /** Keywords retained per topic (most frequent first). */
   readonly maxKeywords?: number;
+  /**
+   * Drop identifier tokens (invoice hashes, order numbers, tracking codes) from subject signatures.
+   * These are unique per message, so they fragment otherwise-identical automated mail into singletons.
+   */
+  readonly dropIdTokens?: boolean;
 };
 
 export const DEFAULT_TOPIC_OPTIONS: Required<TopicOptions> = {
@@ -57,15 +63,18 @@ export const DEFAULT_TOPIC_OPTIONS: Required<TopicOptions> = {
   minTokenLength: 3,
   stopwords: DEFAULT_STOPWORDS,
   maxKeywords: 5,
+  dropIdTokens: true,
 };
 
 /** A topic before ECHO materialization: plain values so LLM enrichment can rewrite them freely. */
 export type TopicDraft = {
-  readonly label: string;
+  readonly name: string;
   readonly summary: string;
   readonly threadIds: readonly string[];
   readonly participants: readonly string[];
   readonly keywords: readonly string[];
+  readonly questions: readonly string[];
+  readonly tasks: readonly string[];
 };
 
 type Signature = {
@@ -74,12 +83,35 @@ type Signature = {
   readonly participants: Set<string>;
 };
 
+// Identifiers (invoice hashes, order numbers, tracking codes, years) carry no topical signal and are
+// unique per message, so they must be dropped or near-identical automated mail never collapses. A
+// token is an id if it is a pure number, a hex-looking string, or a digit-heavy alphanumeric code;
+// short version-like tokens ("q4", "v2") are kept.
+const isIdToken = (token: string): boolean => {
+  if (/^\d+$/.test(token)) {
+    return true;
+  }
+  const digits = (token.match(/\d/g) ?? []).length;
+  if (digits === 0) {
+    return false;
+  }
+  if (/^[0-9a-f]+$/.test(token) && token.length >= 6) {
+    return true;
+  }
+  return token.length >= 5 && digits / token.length >= 0.3;
+};
+
 const tokenize = (subject: string, options: Required<TopicOptions>): Set<string> =>
   new Set(
     subject
       .toLowerCase()
       .split(/[^a-z0-9]+/)
-      .filter((token) => token.length >= options.minTokenLength && !options.stopwords.includes(token)),
+      .filter(
+        (token) =>
+          token.length >= options.minTokenLength &&
+          !options.stopwords.includes(token) &&
+          !(options.dropIdTokens && isIdToken(token)),
+      ),
   );
 
 const jaccard = (left: Set<string>, right: Set<string>): number => {
@@ -160,16 +192,22 @@ export const clusterThreads = (threads: readonly Thread[], options?: TopicOption
       member.thread.summary.length > 0 ? [member.thread.summary] : [],
     );
 
+    // Roll up open questions / action items from the member threads (deduped, order-preserving).
+    const questions = [...new Set(cluster.members.flatMap((member) => member.thread.openQuestions ?? []))];
+    const tasks = [...new Set(cluster.members.flatMap((member) => member.thread.actionItems ?? []))];
+
     // Label from top keywords; a keyword-less cluster (e.g. blank subjects) falls back through the
     // first thread's subject to its threadId so the label is never empty.
     const first = cluster.members[0].thread;
     return {
-      label: keywords.length > 0 ? keywords.slice(0, 3).join(' ') : first.subject || first.threadId,
+      name: keywords.length > 0 ? keywords.slice(0, 3).join(' ') : first.subject || first.threadId,
       summary: summaries.join('\n'),
       threadIds: cluster.members.map((member) => member.thread.threadId),
       participants: [...cluster.participants].sort(),
       keywords,
-    };
+      questions,
+      tasks,
+    } satisfies TopicDraft;
   });
 };
 
@@ -188,8 +226,14 @@ export const summarizeTopics = async (
     drafts.map(async (draft) => {
       try {
         const summary = await summarize(
-          [prompts.topicSummary, `Topic: ${draft.label}`, `Threads:\n${draft.summary}`].join('\n\n'),
+          [
+            //
+            prompts.topicSummary,
+            `Topic: ${draft.name}`,
+            // `Threads:\n${draft.summary}`,
+          ].join('\n\n'),
         );
+
         return summary.trim().length > 0 ? { ...draft, summary: summary.trim() } : draft;
       } catch {
         return draft;
@@ -198,14 +242,16 @@ export const summarizeTopics = async (
   );
 };
 
-/** Materialize drafts as canonical Topic ECHO objects (done last; drafts stay freely mutable). */
-export const materializeTopics = (drafts: readonly TopicDraft[]): Topic[] =>
+/** Materialize drafts as canonical Project ECHO objects (done last; drafts stay freely mutable). */
+export const materializeTopics = (drafts: readonly TopicDraft[]): Project.Project[] =>
   drafts.map((draft) =>
-    Obj.make(Topic, {
-      label: draft.label,
-      summary: draft.summary,
-      threadIds: [...draft.threadIds],
-      participants: [...draft.participants],
-      keywords: [...draft.keywords],
+    Project.make({
+      name: draft.name,
+      // summary: draft.summary,
+      // threadIds: [...draft.threadIds],
+      // participants: [...draft.participants],
+      // keywords: [...draft.keywords],
+      // questions: [...draft.questions],
+      // tasks: [...draft.tasks],
     }),
   );

package/src/fact-pipeline.ts

@@ -2,14 +2,29 @@
 // Copyright 2026 DXOS.org
 //
 
+import * as Chunk from 'effect/Chunk';
 import * as Effect from 'effect/Effect';
 import * as Stream from 'effect/Stream';
 
-import { type Database } from '@dxos/echo';
-import { Pipeline } from '@dxos/pipeline';
+import { Database, Feed, Filter } from '@dxos/echo';
+import { Cursor } from '@dxos/link';
+import { log } from '@dxos/log';
+import { Pipeline, Stage } from '@dxos/pipeline';
+import { FactStore } from '@dxos/pipeline-rdf';
 import { Message } from '@dxos/types';
 
-import { EmailPipelineCtx, type FactIndexer, type Stats, emptyStats, extractFactsStage, statsStage } from './stages';
+import {
+  EmailPipelineCtx,
+  type FactExtractor,
+  type FactIndexer,
+  type FactUnit,
+  type Stats,
+  emptyStats,
+  extractFactsStage,
+  extractFactsUnitStage,
+  messageSource,
+  statsStage,
+} from './stages';
 
 export type EmailFactPipelineOptions = {
   /** ECHO space database, required by `EmailPipelineCtx` even though this assembly never writes to it. */
@@ -27,7 +42,7 @@ export const EmailFactPipeline = {
   /**
    * Facts-only assembly of the email stages over a batch of messages: stats → extract-facts. Omits
    * summarize, extract-contacts, and {@link buildThreads} from {@link EmailPipeline}, so it needs no
-   * `AiService` and never writes to `db`. The cursored `EnrichMailbox` operation (in plugin-inbox)
+   * `AiService` and never writes to `db`. The cursored `AnalyzeMailbox` operation (in plugin-inbox)
    * covers the same fact-extraction concern incrementally, via a sibling facts-returning stage
    * (`extractFactsUnitStage`) that commits pages atomically with a cursor advance instead of indexing
    * in-stage; this batch variant is for one-shot runs over an already-collected set of messages.
@@ -49,3 +64,98 @@ export const EmailFactPipeline = {
       return { messages: collected, stats };
     }),
 };
+
+/**
+ * Runs the cursored fact pipeline over a feed: dedup → extract facts → commit each page to the
+ * {@link FactStore} while advancing `cursor`. Extraction is injected (`extract`) so the pipeline is
+ * unit-testable with a deterministic stub — no `AiService` required. Feed-generic (the mailbox
+ * `AnalyzeMailbox` operation is a thin wrapper that resolves a Mailbox to its feed and its persisted
+ * `Cursor`).
+ *
+ * Dedup is by `cursor`'s high-water key (a coarse `key < cursorKey` skip) plus the set of message
+ * sources already in the store (the precise idempotency backstop) — the store doesn't share `cursor`'s
+ * persistence lifetime (it's still in-memory per space), so the source-dedup backstop still matters
+ * even though the cursor itself is now durable.
+ */
+export const runFactPipeline = (options: {
+  readonly feed: Feed.Feed;
+  readonly cursor: Cursor.Cursor;
+  readonly extract: FactExtractor;
+  readonly pageSize: number;
+  /** In-flight parallelism for the per-message extraction stage (defaults to 1 = serial). */
+  readonly concurrency?: number;
+}): Effect.Effect<{ processed: number; facts: number }, never, FactStore | Database.Service> =>
+  Effect.gen(function* () {
+    const { feed, cursor, extract, pageSize, concurrency = 1 } = options;
+    const store = yield* FactStore;
+
+    // Sources (== `messageSource`) already indexed — the precise skip; the cursor is only a coarse
+    // prefilter (the newest message keys equal to the advanced cursor, so `< cursorKey` alone would
+    // re-extract it).
+    const priorFacts = yield* store.query({}).pipe(Effect.orElseSucceed(() => []));
+    const indexedSources = new Set(priorFacts.map((fact) => fact.attribution.source));
+
+    // NOTE(workaround): the cursor key is `message.created` (epoch-ms) because ECHO's native feed
+    // cursor is unimplemented (`Feed.cursor` is stubbed). Replace with the native queue sequence when
+    // available.
+    let cursorKey = Cursor.parseKey(cursor.max);
+
+    let processed = 0;
+    let facts = 0;
+    const messages = yield* Feed.query(feed, Filter.type(Message.Message)).run;
+    log.info('analyze: pipeline start', {
+      messages: messages.length,
+      cursorKey,
+      indexed: indexedSources.size,
+      pageSize,
+    });
+    yield* Stream.fromIterable(messages).pipe(
+      Stage.map('facts-dedup', (message: Message.Message) =>
+        Effect.sync(() =>
+          Date.parse(message.created) < cursorKey || indexedSources.has(messageSource(message)) ? undefined : message,
+        ),
+      ),
+      extractFactsUnitStage(extract, concurrency),
+      // Observability stage: confirms units flow through and how many facts each carries.
+      Stage.map('facts-log', (unit: FactUnit) =>
+        Effect.sync(() => {
+          log.info('analyze: extracted unit', { foreignId: unit.foreignId, key: unit.key, facts: unit.facts.length });
+          return unit;
+        }),
+      ),
+      Stream.grouped(pageSize),
+      Pipeline.run({
+        sink: (page) =>
+          Effect.gen(function* () {
+            const units = Chunk.toReadonlyArray(page);
+            if (units.length === 0) {
+              return;
+            }
+
+            const pageFacts = units.flatMap((unit) => unit.facts);
+            if (pageFacts.length > 0) {
+              // A fact-store write failure is fatal to the run (not a recoverable per-page error).
+              yield* store.putFacts(pageFacts).pipe(Effect.orDie);
+            }
+
+            processed += units.length;
+            facts += pageFacts.length;
+            cursorKey = Math.max(cursorKey, ...units.map((unit) => unit.key));
+            Cursor.advance(cursor, Cursor.formatKey(cursorKey));
+
+            // Terminal progress log (one line per committed page): the only live signal between
+            // pipeline start and done, so a long run's advance is observable rather than silent.
+            log.info('analyze: committed page', {
+              page: units.length,
+              pageFacts: pageFacts.length,
+              processed,
+              facts,
+              cursorKey,
+            });
+          }),
+      }),
+    );
+
+    log.info('analyze: pipeline done', { processed, facts });
+    return { processed, facts };
+  });

package/src/index.ts

@@ -4,6 +4,10 @@
 
 export * from './corpus';
 export * from './fact-pipeline';
+export * from './internal/threading';
+export * from './internal/threads';
+export * from './model-policy';
 export * from './pipeline';
+export * from './topics-pipeline';
 export * from './stages';
 export * from './types';

package/src/internal/threads.test.ts

@@ -62,6 +62,18 @@ describe('buildThreads', () => {
     expect(thread.state).toBe('stalled');
   });
 
+  test('recognizes any of the owner aliases as "from the owner"', ({ expect }) => {
+    // The owner replied from an alias; with both addresses supplied the thread is awaiting-theirs.
+    const [thread] = buildThreads(
+      [
+        msg('Deal terms', 'a@x.com', '2001-05-01T10:00:00.000Z'),
+        msg('RE: Deal terms', 'me@dxos.org', '2001-05-01T11:00:00.000Z'),
+      ],
+      { ownerEmail: ['me@enron.com', 'me@dxos.org'], now: '2001-05-02T00:00:00.000Z' },
+    );
+    expect(thread.state).toBe('awaiting-theirs');
+  });
+
   test('summary concatenates per-message summaries', ({ expect }) => {
     const [thread] = buildThreads(
       [

package/src/internal/threads.ts

@@ -12,11 +12,19 @@ import { deriveThreadId } from './threading';
 const DEFAULT_STALE_PERIOD_MS = 14 * 24 * 60 * 60 * 1000;
 
 export type BuildThreadsOptions = {
-  readonly ownerEmail: string;
+  /**
+   * The mailbox owner's email(s). Accepts multiple so a person's aliases (e.g. work + personal) all
+   * count as "from the owner" when inferring thread state; a single string is still accepted.
+   */
+  readonly ownerEmail: string | readonly string[];
   readonly now: string;
   readonly stalePeriodMs?: number;
 };
 
+/** Lowercased set of the owner's addresses (handles the single-string and multi-alias forms). */
+const ownerAddressSet = (ownerEmail: string | readonly string[]): ReadonlySet<string> =>
+  new Set((Array.isArray(ownerEmail) ? ownerEmail : [ownerEmail]).map((email) => email.toLowerCase()).filter(Boolean));
+
 // Coarse thread state from who spoke last and how long ago. `resolved` needs a signal we do not yet
 // extract, so it is not inferred in this slice.
 const computeState = (lastFromOwner: boolean, lastCreated: string, options: BuildThreadsOptions): ThreadState => {
@@ -31,6 +39,7 @@ const computeState = (lastFromOwner: boolean, lastCreated: string, options: Buil
 // Group messages into canonical Thread objects. Messages are bucketed by derived threadId; within a
 // bucket they are ordered by `created` to find the last speaker.
 export const buildThreads = (messages: readonly Message.Message[], options: BuildThreadsOptions): Thread[] => {
+  const owners = ownerAddressSet(options.ownerEmail);
   const buckets = new Map<string, Message.Message[]>();
   for (const message of messages) {
     const threadId = deriveThreadId(message);
@@ -48,8 +57,7 @@ export const buildThreads = (messages: readonly Message.Message[], options: Buil
     const last = ordered[ordered.length - 1];
     // Email addresses are case-insensitive, so compare and dedup on a lowercased form; otherwise
     // mixed-case senders split into distinct participants and can misclassify awaiting-mine/theirs.
-    const owner = options.ownerEmail.toLowerCase();
-    const lastFromOwner = last.sender.email?.toLowerCase() === owner;
+    const lastFromOwner = owners.has(last.sender.email?.toLowerCase() ?? '');
     const participants = [...new Set(ordered.flatMap((m) => (m.sender.email ? [m.sender.email.toLowerCase()] : [])))];
     const summaries = ordered.flatMap((m) =>
       typeof m.properties?.summary === 'string' && m.properties.summary.length > 0 ? [m.properties.summary] : [],

package/src/model-policy.test.ts

@@ -0,0 +1,21 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, test } from 'vitest';
+
+import { DEFAULT_MODEL_POLICY, MODEL_HAIKU, MODEL_SONNET, type StageId, resolveModel } from './model-policy';
+
+describe('model-policy', () => {
+  test('every stage has a default model', ({ expect }) => {
+    for (const stage of Object.keys(DEFAULT_MODEL_POLICY) as StageId[]) {
+      expect(resolveModel(stage), stage).toBe(MODEL_HAIKU);
+    }
+  });
+
+  test('a per-run policy overrides the default', ({ expect }) => {
+    expect(resolveModel('summarize-topic', { 'summarize-topic': MODEL_SONNET })).toBe(MODEL_SONNET);
+    // Unrelated stages keep their defaults.
+    expect(resolveModel('tag', { 'summarize-topic': MODEL_SONNET })).toBe(MODEL_HAIKU);
+  });
+});