@creativeintelligence/abbie 0.1.3 → 0.1.5

package/src/lib/annotations.ts

@@ -1,836 +0,0 @@
-/**
- * Annotation domain model for preview deployments.
- *
- * Provides a portable grammar for structured UI feedback loops that agents
- * can consume reliably. Tool-agnostic: works whether annotations come from
- * Vercel comments, Agentation, browser automation, or manual CLI input.
- *
- * Design principles:
- * - Provider-agnostic: no vendor-specific assumptions
- * - Replayable: all state transitions are sequenced
- * - Actionable: blocking annotations can be routed to work sessions
- * - Thread-based: annotations support conversation threads
- */
-
-import { randomUUID } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-
-// ============================================================================
-// Types
-// ============================================================================
-
-export type AnnotationStatus = "pending" | "acknowledged" | "resolved" | "dismissed";
-export type AnnotationSeverity = "info" | "warning" | "error" | "critical";
-export type AnnotationIntent = "feedback" | "bug" | "suggestion" | "question" | "blocker";
-
-export interface Annotation {
-  /** The annotation body (markdown) */
-  body: string;
-  /** ISO timestamp of creation */
-  createdAt: string;
-  id: string;
-  /** What kind of annotation this is */
-  intent: AnnotationIntent;
-  /** Session ID if routed to agent work */
-  linkedSessionId?: string;
-  /** Optional structured metadata (AFS context, producer-specific fields) */
-  metadata?: Record<string, unknown>;
-  /** Preview deployment this annotation is attached to */
-  previewId: string;
-  /** Optional screenshot path */
-  screenshot?: string;
-  /** Optional CSS selector or element reference */
-  selector?: string;
-  /** Monotonic sequence number for ordering */
-  seq: number;
-  /** Severity level */
-  severity: AnnotationSeverity;
-  /** Source tool that created this annotation */
-  source: string;
-  /** Status lifecycle */
-  status: AnnotationStatus;
-  /** Optional URL/path in the preview being annotated */
-  target?: string;
-  /** Thread of messages (for conversations) */
-  thread: ThreadMessage[];
-  /** ISO timestamp of last update */
-  updatedAt: string;
-}
-
-export interface ThreadMessage {
-  /** Who sent this message */
-  author: string;
-  /** Message body (markdown) */
-  body: string;
-  id: string;
-  /** ISO timestamp */
-  timestamp: string;
-}
-
-export interface AnnotationEvent {
-  annotationId: string;
-  data: Record<string, unknown>;
-  seq: number;
-  timestamp: string;
-  type:
-    | "annotation.created"
-    | "annotation.updated"
-    | "annotation.deleted"
-    | "thread.message"
-    | "status.changed";
-}
-
-/**
- * Event envelope: wraps an AnnotationEvent with preview/session context
- * for cross-system replay and interoperability.
- */
-export interface EventEnvelope {
-  event: AnnotationEvent;
-  previewId: string;
-  sessionId?: string;
-  version: "1.0";
-}
-
-// ============================================================================
-// Agentation AFS interoperability types
-// ============================================================================
-
-export type AfsIntent = "fix" | "change" | "question" | "approve";
-export type AfsSeverity = "blocking" | "important" | "suggestion";
-export type AfsStatus = AnnotationStatus;
-
-export interface AfsThreadMessage {
-  content: string;
-  id: string;
-  role: "human" | "agent";
-  timestamp: number;
-}
-
-export interface AfsAnnotation {
-  accessibility?: string;
-  boundingBox?: {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-  };
-  comment: string;
-  computedStyles?: string;
-  cssClasses?: string;
-  element: string;
-  elementPath: string;
-  id: string;
-  intent?: AfsIntent;
-  nearbyText?: string;
-  reactComponents?: string;
-  resolvedAt?: string;
-  resolvedBy?: "human" | "agent";
-  selectedText?: string;
-  severity?: AfsSeverity;
-  status?: AfsStatus;
-  thread?: AfsThreadMessage[];
-  timestamp: number;
-  url?: string;
-  x: number;
-  y: number;
-}
-
-function afsSeverityToAnnotation(severity?: AfsSeverity): AnnotationSeverity {
-  switch (severity) {
-    case "blocking":
-      return "critical";
-    case "important":
-      return "warning";
-    case "suggestion":
-      return "info";
-    default:
-      return "info";
-  }
-}
-
-function annotationSeverityToAfs(severity: AnnotationSeverity): AfsSeverity {
-  switch (severity) {
-    case "critical":
-      return "blocking";
-    case "error":
-    case "warning":
-      return "important";
-    default:
-      return "suggestion";
-  }
-}
-
-function afsIntentToAnnotation(intent?: AfsIntent): AnnotationIntent {
-  switch (intent) {
-    case "fix":
-      return "bug";
-    case "change":
-      return "suggestion";
-    case "question":
-      return "question";
-    case "approve":
-      return "feedback";
-    default:
-      return "feedback";
-  }
-}
-
-function annotationIntentToAfs(intent: AnnotationIntent): AfsIntent {
-  switch (intent) {
-    case "bug":
-    case "blocker":
-      return "fix";
-    case "question":
-      return "question";
-    case "suggestion":
-      return "change";
-    default:
-      return "approve";
-  }
-}
-
-/**
- * AFS event types for external event stream ingestion.
- * These represent the events an AFS-compatible tool emits during
- * an annotation lifecycle (create, update, resolve, thread message).
- */
-export type AfsEventType =
-  | "annotation.created"
-  | "annotation.updated"
-  | "annotation.resolved"
-  | "annotation.deleted"
-  | "thread.message";
-
-export interface AfsEvent {
-  annotationId: string;
-  data: {
-    annotation?: AfsAnnotation;
-    message?: AfsThreadMessage;
-    resolvedBy?: "human" | "agent";
-    status?: AfsStatus;
-  };
-  timestamp: number;
-  type: AfsEventType;
-}
-
-function afsThreadToInternal(thread: AfsThreadMessage[]): ThreadMessage[] {
-  return thread.map((message) => ({
-    id: message.id,
-    author: message.role,
-    body: message.content,
-    timestamp: new Date(message.timestamp).toISOString(),
-  }));
-}
-
-function internalThreadToAfs(thread: ThreadMessage[]): AfsThreadMessage[] {
-  return thread.map((message) => ({
-    id: message.id,
-    role: message.author === "human" || message.author === "user" ? "human" : "agent",
-    content: message.body,
-    timestamp: Date.parse(message.timestamp),
-  }));
-}
-
-// ============================================================================
-// Store (file-based, per-preview)
-// ============================================================================
-
-/**
- * File-based annotation store.
- *
- * Stores annotations as JSON files in .abbie/annotations/{previewId}/.
- * Events are appended to an NDJSON log for replay.
- */
-export class AnnotationStore {
-  private readonly basePath: string;
-
-  constructor(basePath?: string) {
-    this.basePath = basePath || join(process.cwd(), ".abbie", "annotations");
-  }
-
-  private previewDir(previewId: string): string {
-    const dir = join(this.basePath, previewId);
-    if (!existsSync(dir)) {
-      mkdirSync(dir, { recursive: true });
-    }
-    return dir;
-  }
-
-  private annotationsFile(previewId: string): string {
-    return join(this.previewDir(previewId), "annotations.json");
-  }
-
-  private eventsFile(previewId: string): string {
-    return join(this.previewDir(previewId), "events.ndjson");
-  }
-
-  private readAnnotations(previewId: string): Annotation[] {
-    const file = this.annotationsFile(previewId);
-    if (!existsSync(file)) {
-      return [];
-    }
-    try {
-      return JSON.parse(readFileSync(file, "utf-8"));
-    } catch {
-      return [];
-    }
-  }
-
-  private writeAnnotations(previewId: string, annotations: Annotation[]): void {
-    writeFileSync(this.annotationsFile(previewId), JSON.stringify(annotations, null, 2));
-  }
-
-  private appendEvent(previewId: string, event: AnnotationEvent): void {
-    const file = this.eventsFile(previewId);
-    const line = `${JSON.stringify(event)}\n`;
-    writeFileSync(file, line, { flag: "a" });
-  }
-
-  private readEvents(previewId: string): AnnotationEvent[] {
-    const file = this.eventsFile(previewId);
-    if (!existsSync(file)) {
-      return [];
-    }
-
-    try {
-      const lines = readFileSync(file, "utf-8").trim().split("\n");
-      return lines.filter((l) => l.length > 0).map((l) => JSON.parse(l) as AnnotationEvent);
-    } catch {
-      return [];
-    }
-  }
-
-  private nextAnnotationSeq(previewId: string): number {
-    const annotations = this.readAnnotations(previewId);
-    if (annotations.length === 0) {
-      return 1;
-    }
-    return Math.max(...annotations.map((a) => a.seq)) + 1;
-  }
-
-  private nextEventSeq(previewId: string): number {
-    const events = this.readEvents(previewId);
-    if (events.length === 0) {
-      return 1;
-    }
-    return Math.max(...events.map((e) => e.seq)) + 1;
-  }
-
-  // ========================================================================
-  // CRUD
-  // ========================================================================
-
-  create(opts: {
-    previewId: string;
-    body: string;
-    severity?: AnnotationSeverity;
-    intent?: AnnotationIntent;
-    source?: string;
-    target?: string;
-    selector?: string;
-    screenshot?: string;
-  }): Annotation {
-    const now = new Date().toISOString();
-    const seq = this.nextAnnotationSeq(opts.previewId);
-
-    const annotation: Annotation = {
-      id: randomUUID(),
-      previewId: opts.previewId,
-      status: "pending",
-      severity: opts.severity || "info",
-      intent: opts.intent || "feedback",
-      body: opts.body,
-      target: opts.target,
-      selector: opts.selector,
-      screenshot: opts.screenshot,
-      source: opts.source || "cli",
-      thread: [],
-      seq,
-      createdAt: now,
-      updatedAt: now,
-    };
-
-    const annotations = this.readAnnotations(opts.previewId);
-    annotations.push(annotation);
-    this.writeAnnotations(opts.previewId, annotations);
-
-    this.appendEvent(opts.previewId, {
-      type: "annotation.created",
-      annotationId: annotation.id,
-      data: { body: opts.body, severity: annotation.severity, intent: annotation.intent },
-      seq: this.nextEventSeq(opts.previewId),
-      timestamp: now,
-    });
-
-    return annotation;
-  }
-
-  /**
-   * Import (create/update) an annotation from Agentation AFS shape.
-   * Preserves source annotation IDs for cross-tool interoperability.
-   */
-  createFromAfs(opts: {
-    previewId: string;
-    annotation: AfsAnnotation;
-    source?: string;
-  }): Annotation {
-    const now = new Date().toISOString();
-    const createdAt = Number.isFinite(opts.annotation.timestamp)
-      ? new Date(opts.annotation.timestamp).toISOString()
-      : now;
-
-    const annotations = this.readAnnotations(opts.previewId);
-    const idx = annotations.findIndex((a) => a.id === opts.annotation.id);
-    const existing = idx >= 0 ? annotations[idx] : null;
-
-    const base: Annotation = {
-      id: opts.annotation.id,
-      previewId: opts.previewId,
-      status: opts.annotation.status || "pending",
-      severity: afsSeverityToAnnotation(opts.annotation.severity),
-      intent: afsIntentToAnnotation(opts.annotation.intent),
-      body: opts.annotation.comment,
-      target: opts.annotation.url,
-      selector: opts.annotation.elementPath,
-      source: opts.source || "agentation-afs",
-      thread: afsThreadToInternal(opts.annotation.thread || []),
-      linkedSessionId: existing?.linkedSessionId,
-      metadata: {
-        afs: {
-          x: opts.annotation.x,
-          y: opts.annotation.y,
-          element: opts.annotation.element,
-          boundingBox: opts.annotation.boundingBox,
-          reactComponents: opts.annotation.reactComponents,
-          cssClasses: opts.annotation.cssClasses,
-          computedStyles: opts.annotation.computedStyles,
-          accessibility: opts.annotation.accessibility,
-          nearbyText: opts.annotation.nearbyText,
-          selectedText: opts.annotation.selectedText,
-          resolvedAt: opts.annotation.resolvedAt,
-          resolvedBy: opts.annotation.resolvedBy,
-        },
-      },
-      seq: existing?.seq || this.nextAnnotationSeq(opts.previewId),
-      createdAt: existing?.createdAt || createdAt,
-      updatedAt: now,
-    };
-
-    if (idx >= 0) {
-      annotations[idx] = {
-        ...existing,
-        ...base,
-        seq: existing!.seq,
-        createdAt: existing!.createdAt,
-      };
-      this.writeAnnotations(opts.previewId, annotations);
-      this.appendEvent(opts.previewId, {
-        type: "annotation.updated",
-        annotationId: base.id,
-        data: { source: "afs", status: base.status, severity: base.severity, intent: base.intent },
-        seq: this.nextEventSeq(opts.previewId),
-        timestamp: now,
-      });
-      return annotations[idx];
-    }
-
-    annotations.push(base);
-    this.writeAnnotations(opts.previewId, annotations);
-    this.appendEvent(opts.previewId, {
-      type: "annotation.created",
-      annotationId: base.id,
-      data: { source: "afs", status: base.status, severity: base.severity, intent: base.intent },
-      seq: this.nextEventSeq(opts.previewId),
-      timestamp: now,
-    });
-    return base;
-  }
-
-  list(previewId: string, filter?: { status?: AnnotationStatus }): Annotation[] {
-    const annotations = this.readAnnotations(previewId);
-    if (!filter?.status) {
-      return annotations;
-    }
-    return annotations.filter((a) => a.status === filter.status);
-  }
-
-  get(previewId: string, annotationId: string): Annotation | null {
-    const annotations = this.readAnnotations(previewId);
-    return annotations.find((a) => a.id === annotationId) || null;
-  }
-
-  acknowledge(previewId: string, annotationId: string): Annotation | null {
-    return this.updateStatus(previewId, annotationId, "acknowledged");
-  }
-
-  resolve(previewId: string, annotationId: string): Annotation | null {
-    return this.updateStatus(previewId, annotationId, "resolved");
-  }
-
-  dismiss(previewId: string, annotationId: string): Annotation | null {
-    return this.updateStatus(previewId, annotationId, "dismissed");
-  }
-
-  reply(previewId: string, annotationId: string, author: string, body: string): Annotation | null {
-    const annotations = this.readAnnotations(previewId);
-    const idx = annotations.findIndex((a) => a.id === annotationId);
-    if (idx === -1) {
-      return null;
-    }
-
-    const now = new Date().toISOString();
-    const message: ThreadMessage = {
-      id: randomUUID(),
-      author,
-      body,
-      timestamp: now,
-    };
-
-    annotations[idx].thread.push(message);
-    annotations[idx].updatedAt = now;
-    this.writeAnnotations(previewId, annotations);
-
-    this.appendEvent(previewId, {
-      type: "thread.message",
-      annotationId,
-      data: { author, body },
-      seq: this.nextEventSeq(previewId),
-      timestamp: now,
-    });
-
-    return annotations[idx];
-  }
-
-  /**
-   * Link an annotation to an agent session for resolution.
-   */
-  linkSession(previewId: string, annotationId: string, sessionId: string): Annotation | null {
-    const annotations = this.readAnnotations(previewId);
-    const idx = annotations.findIndex((a) => a.id === annotationId);
-    if (idx === -1) {
-      return null;
-    }
-
-    annotations[idx].linkedSessionId = sessionId;
-    annotations[idx].updatedAt = new Date().toISOString();
-    this.writeAnnotations(previewId, annotations);
-
-    return annotations[idx];
-  }
-
-  /**
-   * Get all events for replay.
-   */
-  events(previewId: string): AnnotationEvent[] {
-    return this.readEvents(previewId);
-  }
-
-  /**
-   * Convert an internal annotation into Agentation AFS shape.
-   */
-  toAfsAnnotation(annotation: Annotation): AfsAnnotation {
-    const afs = (annotation.metadata?.afs as Record<string, unknown> | undefined) || {};
-    const x = typeof afs.x === "number" ? afs.x : 50;
-    const y = typeof afs.y === "number" ? afs.y : 0;
-    const element = typeof afs.element === "string" ? afs.element : "div";
-
-    return {
-      id: annotation.id,
-      comment: annotation.body,
-      elementPath: annotation.selector || "body",
-      timestamp: Date.parse(annotation.createdAt),
-      x,
-      y,
-      element,
-      ...(annotation.target ? { url: annotation.target } : {}),
-      ...(afs.boundingBox && typeof afs.boundingBox === "object"
-        ? { boundingBox: afs.boundingBox as AfsAnnotation["boundingBox"] }
-        : {}),
-      ...(typeof afs.reactComponents === "string" ? { reactComponents: afs.reactComponents } : {}),
-      ...(typeof afs.cssClasses === "string" ? { cssClasses: afs.cssClasses } : {}),
-      ...(typeof afs.computedStyles === "string" ? { computedStyles: afs.computedStyles } : {}),
-      ...(typeof afs.accessibility === "string" ? { accessibility: afs.accessibility } : {}),
-      ...(typeof afs.nearbyText === "string" ? { nearbyText: afs.nearbyText } : {}),
-      ...(typeof afs.selectedText === "string" ? { selectedText: afs.selectedText } : {}),
-      intent: annotationIntentToAfs(annotation.intent),
-      severity: annotationSeverityToAfs(annotation.severity),
-      status: annotation.status,
-      ...(typeof afs.resolvedAt === "string" ? { resolvedAt: afs.resolvedAt } : {}),
-      ...(afs.resolvedBy === "human" || afs.resolvedBy === "agent"
-        ? { resolvedBy: afs.resolvedBy }
-        : {}),
-      ...(annotation.thread.length > 0 ? { thread: internalThreadToAfs(annotation.thread) } : {}),
-    };
-  }
-
-  exportAfs(previewId: string, annotationId: string): AfsAnnotation | null {
-    const annotation = this.get(previewId, annotationId);
-    if (!annotation) {
-      return null;
-    }
-    return this.toAfsAnnotation(annotation);
-  }
-
-  listAfs(previewId: string, filter?: { status?: AnnotationStatus }): AfsAnnotation[] {
-    return this.list(previewId, filter).map((annotation) => this.toAfsAnnotation(annotation));
-  }
-
-  /**
-   * Batch import AFS annotations into a preview.
-   */
-  importAfsBatch(opts: {
-    previewId: string;
-    annotations: AfsAnnotation[];
-    source?: string;
-  }): Annotation[] {
-    return opts.annotations.map((afs) =>
-      this.createFromAfs({ previewId: opts.previewId, annotation: afs, source: opts.source })
-    );
-  }
-
-  /**
-   * Batch export annotations as AFS payloads.
-   */
-  exportAfsBatch(previewId: string, filter?: { status?: AnnotationStatus }): AfsAnnotation[] {
-    return this.listAfs(previewId, filter);
-  }
-
-  /**
-   * Delete an annotation and emit annotation.deleted event.
-   */
-  delete(previewId: string, annotationId: string): Annotation | null {
-    const annotations = this.readAnnotations(previewId);
-    const idx = annotations.findIndex((a) => a.id === annotationId);
-    if (idx === -1) {
-      return null;
-    }
-
-    const deleted = annotations.splice(idx, 1)[0];
-    this.writeAnnotations(previewId, annotations);
-
-    this.appendEvent(previewId, {
-      type: "annotation.deleted",
-      annotationId,
-      data: { body: deleted.body, status: deleted.status },
-      seq: this.nextEventSeq(previewId),
-      timestamp: new Date().toISOString(),
-    });
-
-    return deleted;
-  }
-
-  /**
-   * Export events as event envelopes with preview/session context.
-   */
-  exportEvents(previewId: string, opts?: { sessionId?: string }): EventEnvelope[] {
-    const events = this.readEvents(previewId);
-    const annotations = this.readAnnotations(previewId);
-
-    return events.map((event) => {
-      const annotation = annotations.find((a) => a.id === event.annotationId);
-      return {
-        version: "1.0" as const,
-        previewId,
-        sessionId: opts?.sessionId ?? annotation?.linkedSessionId,
-        event,
-      };
-    });
-  }
-
-  // ========================================================================
-  // AFS event ingestion pipeline
-  // ========================================================================
-
-  /**
-   * Ingest an ordered stream of AFS events into the annotation store.
-   *
-   * Maps external AFS lifecycle events (created, updated, resolved, deleted,
-   * thread.message) into the internal domain model. Preserves ordering via
-   * monotonic seq numbers. Returns the annotations that were touched.
-   */
-  ingestAfsEvents(opts: { previewId: string; events: AfsEvent[]; source?: string }): {
-    ingested: number;
-    annotations: Annotation[];
-  } {
-    const touched = new Map<string, Annotation>();
-    let ingested = 0;
-
-    for (const afsEvent of opts.events) {
-      ingested += this.ingestAfsEvent(opts.previewId, afsEvent, touched, opts.source);
-    }
-
-    return { ingested, annotations: Array.from(touched.values()) };
-  }
-
-  // ========================================================================
-  // Session routing
-  // ========================================================================
-
-  /**
-   * Get actionable annotations: unresolved with blocking severity or blocker intent.
-   */
-  getActionable(previewId: string): Annotation[] {
-    const annotations = this.readAnnotations(previewId);
-    return annotations.filter(
-      (a) =>
-        a.status !== "resolved" &&
-        a.status !== "dismissed" &&
-        (a.severity === "critical" || a.severity === "error" || a.intent === "blocker")
-    );
-  }
-
-  /**
-   * Bulk-link all unlinked blocking/critical annotations to a work session.
-   * Returns the annotations that were linked.
-   */
-  routeBlockingToSession(previewId: string, sessionId: string): Annotation[] {
-    const actionable = this.getActionable(previewId);
-    const unlinked = actionable.filter((a) => !a.linkedSessionId);
-    const linked: Annotation[] = [];
-
-    for (const annotation of unlinked) {
-      const result = this.linkSession(previewId, annotation.id, sessionId);
-      if (result) {
-        linked.push(result);
-      }
-    }
-
-    return linked;
-  }
-
-  // ========================================================================
-  // Private helpers
-  // ========================================================================
-
-  private updateStatus(
-    previewId: string,
-    annotationId: string,
-    status: AnnotationStatus
-  ): Annotation | null {
-    const annotations = this.readAnnotations(previewId);
-    const idx = annotations.findIndex((a) => a.id === annotationId);
-    if (idx === -1) {
-      return null;
-    }
-
-    const now = new Date().toISOString();
-    const prev = annotations[idx].status;
-    annotations[idx].status = status;
-    annotations[idx].updatedAt = now;
-    this.writeAnnotations(previewId, annotations);
-
-    this.appendEvent(previewId, {
-      type: "status.changed",
-      annotationId,
-      data: { from: prev, to: status },
-      seq: this.nextEventSeq(previewId),
-      timestamp: now,
-    });
-
-    return annotations[idx];
-  }
-
-  private ingestAfsEvent(
-    previewId: string,
-    event: AfsEvent,
-    touched: Map<string, Annotation>,
-    source?: string
-  ): number {
-    switch (event.type) {
-      case "annotation.created":
-      case "annotation.updated":
-        return this.ingestAfsUpsert(previewId, event, touched, source);
-      case "annotation.resolved":
-        return this.ingestAfsResolved(previewId, event, touched);
-      case "annotation.deleted":
-        return this.ingestAfsDeleted(previewId, event);
-      case "thread.message":
-        return this.ingestAfsThreadMessage(previewId, event, touched);
-      default:
-        return 0;
-    }
-  }
-
-  private ingestAfsUpsert(
-    previewId: string,
-    event: AfsEvent,
-    touched: Map<string, Annotation>,
-    source?: string
-  ): number {
-    if (!event.data.annotation) {
-      return 0;
-    }
-
-    const upserted = this.createFromAfs({
-      previewId,
-      annotation: event.data.annotation,
-      source,
-    });
-    touched.set(upserted.id, upserted);
-    return 1;
-  }
-
-  private ingestAfsResolved(
-    previewId: string,
-    event: AfsEvent,
-    touched: Map<string, Annotation>
-  ): number {
-    const resolved = this.resolve(previewId, event.annotationId);
-    if (!resolved) {
-      return 0;
-    }
-
-    this.applyResolvedMetadata(previewId, event);
-    const refreshed = this.get(previewId, resolved.id);
-    if (refreshed) {
-      touched.set(refreshed.id, refreshed);
-    }
-    return 1;
-  }
-
-  private applyResolvedMetadata(previewId: string, event: AfsEvent): void {
-    if (!event.data.resolvedBy) {
-      return;
-    }
-
-    const annotations = this.readAnnotations(previewId);
-    const idx = annotations.findIndex((annotation) => annotation.id === event.annotationId);
-    if (idx < 0) {
-      return;
-    }
-
-    annotations[idx].metadata = {
-      ...annotations[idx].metadata,
-      afs: {
-        ...((annotations[idx].metadata?.afs as Record<string, unknown>) || {}),
-        resolvedBy: event.data.resolvedBy,
-        resolvedAt: new Date(event.timestamp).toISOString(),
-      },
-    };
-    this.writeAnnotations(previewId, annotations);
-  }
-
-  private ingestAfsDeleted(previewId: string, event: AfsEvent): number {
-    return this.delete(previewId, event.annotationId) ? 1 : 0;
-  }
-
-  private ingestAfsThreadMessage(
-    previewId: string,
-    event: AfsEvent,
-    touched: Map<string, Annotation>
-  ): number {
-    if (!event.data.message) {
-      return 0;
-    }
-
-    const message = event.data.message;
-    const replied = this.reply(previewId, event.annotationId, message.role, message.content);
-    if (!replied) {
-      return 0;
-    }
-
-    touched.set(replied.id, replied);
-    return 1;
-  }
-}