@saadnvd1/agent-os 0.3.672 → 0.3.678

package/lib/bus/read-scope.ts

@@ -0,0 +1,109 @@
+import { db } from "../db";
+import type { Session } from "../db";
+import { getProject } from "../projects";
+import { getWorkspace } from "../workspaces";
+import { previousNames } from "../session-names";
+import { resolveRef, type Candidate } from "./resolve";
+
+export type ReadableSession = Session & { project_name: string | null };
+
+export interface ReaderScope {
+  workspaceId: string | null;
+  projectId: string | null;
+  label: string;
+}
+
+// What the asking session may read: its workspace, or its project when it
+// has none. The boundary the orchestrator's tools use.
+export function readerScope(callerId: string): ReaderScope {
+  const caller = db
+    .prepare(`SELECT * FROM session_rows WHERE id = ?`)
+    .get(callerId) as Session | undefined;
+  if (!caller) throw new Error("aos read runs from inside an AgentOS session");
+  const project = caller.project_id ? getProject(caller.project_id) : null;
+  const workspaceId =
+    caller.workspace_id ?? (project && project.workspace_id) ?? null;
+  if (workspaceId)
+    return {
+      workspaceId,
+      projectId: null,
+      label: `workspace ${getWorkspace(workspaceId)?.name ?? workspaceId}`,
+    };
+  if (!project || project.is_uncategorized)
+    throw new Error(`${caller.name} isn't in a project`);
+  return {
+    workspaceId: null,
+    projectId: project.id,
+    label: `project ${project.name}`,
+  };
+}
+
+const SELECT = `SELECT s.*, p.name AS project_name FROM session_rows s
+  LEFT JOIN projects p ON p.id = s.project_id
+  WHERE s.peer_mirror = 0 AND s.held_by_device IS NULL`;
+
+const isLive = (s: Session) =>
+  !s.archived_at && (!s.task_status || s.task_status === "running");
+
+function candidates(rows: ReadableSession[]): Candidate[] {
+  const old = previousNames();
+  return rows.map((s) => ({
+    id: s.id,
+    name: s.name,
+    projectName: s.project_name,
+    tmuxName: s.tmux_name,
+    previousNames: old.get(s.id) ?? [],
+  }));
+}
+
+function inScope(s: ReadableSession, scope: ReaderScope): boolean {
+  if (s.role) return false;
+  if (scope.workspaceId) {
+    const p = s.project_id ? getProject(s.project_id) : null;
+    return !!p && p.workspace_id === scope.workspaceId;
+  }
+  return s.project_id === scope.projectId;
+}
+
+export type Readable =
+  | { ok: true; session: ReadableSession; note?: string }
+  | { ok: false; external: boolean; error: string };
+
+// A session in the caller's scope by name, old name, project/name, id or id
+// prefix. Done, dropped and archived ones count, but a live session wins a
+// name over a finished one.
+export function resolveReadable(callerId: string, ref: string): Readable {
+  const scope = readerScope(callerId);
+  const all = (db.prepare(SELECT).all() as ReadableSession[]).sort((a, b) =>
+    a.updated_at < b.updated_at ? 1 : -1
+  );
+  const mine = all.filter((s) => inScope(s, scope));
+  let none = "";
+  for (const group of [mine.filter(isLive), mine.filter((s) => !isLive(s))]) {
+    const r = resolveRef(ref, candidates(group));
+    if (r.ok) {
+      const session = group.find((s) => s.id === r.id)!;
+      if (session.id === callerId)
+        return { ok: false, external: false, error: "that's this session" };
+      return { ok: true, session, note: r.note };
+    }
+    if (r.reason === "ambiguous")
+      return { ok: false, external: false, error: r.error };
+    none = r.error;
+  }
+  const other = resolveRef(
+    ref,
+    candidates(all.filter((s) => !mine.includes(s)))
+  );
+  if (other.ok) {
+    const s = all.find((x) => x.id === other.id)!;
+    return {
+      ok: false,
+      external: false,
+      error: s.role
+        ? `${s.name} is an orchestrator: it isn't readable. Message it with aos send`
+        : `"${ref}" isn't in your ${scope.label}; aos read reaches only sessions there`,
+    };
+  }
+  return { ok: false, external: true, error: `${none}. Run: aos peers` };
+}

package/lib/bus/read.ts

@@ -0,0 +1,181 @@
+import fs from "fs";
+import path from "path";
+import { db } from "../db";
+import type { Session } from "../db";
+import { lastItems, listItems } from "../chat/store";
+import { untrusted } from "../orchestrator/untrusted";
+import { readExternal, readResolved } from "../orchestrator/read";
+import { findExternalSession } from "../orchestrator/external-sessions";
+import { pieceOfSession, planPathOf } from "../plans/features";
+import { hostLink } from "../hosts/remote-api";
+import {
+  readerScope,
+  resolveReadable,
+  type ReadableSession,
+} from "./read-scope";
+import {
+  READ_DEFAULT_TURNS,
+  TERMINAL_LINES,
+  TERMINAL_LINES_ALL,
+  condenseItems,
+  grepTurns,
+  renderTurns,
+  type Rendered,
+} from "./condense";
+
+export interface ReadOpts {
+  turns?: number;
+  lines?: number;
+  all?: boolean;
+  grep?: string;
+}
+
+export interface ReadResult {
+  // Ours, not another session's text: who, what state, how much.
+  header: string;
+  // Another session's text, fenced and redacted.
+  text: string;
+  session: { id: string | null; name: string; project: string | null };
+  task: { prompt: string | null; plan: string | null } | null;
+  turns: { from: number; to: number; total: number } | null;
+  truncated: boolean;
+}
+
+const PLAN_FILE = ".agentos/plan.md";
+const PROMPT_CAP = 1500;
+// Items fetched per turn asked for, when the whole chat isn't needed.
+const ITEMS_PER_TURN = 400;
+
+export class ReadError extends Error {
+  constructor(
+    message: string,
+    readonly status: number
+  ) {
+    super(message);
+  }
+}
+
+function stateOf(s: Session): string {
+  if (s.archived_at) return "archived";
+  return s.task_status ?? "running";
+}
+
+function planOf(s: Session): string | null {
+  if (s.worktree_path) {
+    const own = path.join(s.worktree_path, PLAN_FILE);
+    if (fs.existsSync(own)) return own;
+  }
+  const piece = pieceOfSession(s.id);
+  const fromFeature = piece ? planPathOf(piece.feature_id) : null;
+  return fromFeature && fs.existsSync(fromFeature) ? fromFeature : null;
+}
+
+function taskHeader(s: Session, all: boolean) {
+  if (!s.task_prompt) return null;
+  const p = s.task_prompt.trim();
+  return {
+    prompt: !all && p.length > PROMPT_CAP ? `${p.slice(0, PROMPT_CAP)}…` : p,
+    plan: planOf(s),
+  };
+}
+
+function userCount(sessionId: string): number {
+  return (
+    db
+      .prepare(
+        `SELECT COUNT(*) AS n FROM chat_items WHERE session_id = ? AND kind = 'user'`
+      )
+      .get(sessionId) as { n: number }
+  ).n;
+}
+
+function chatTurns(s: Session, o: ReadOpts) {
+  const total = userCount(s.id);
+  if (o.all || o.grep) return { turns: condenseItems(listItems(s.id)), total };
+  const asked = o.lines
+    ? Math.ceil(o.lines / 4) + 1
+    : (o.turns ?? READ_DEFAULT_TURNS);
+  const items = lastItems(s.id, Math.min(asked * ITEMS_PER_TURN, 4000));
+  const inWindow = items.filter((i) => i.kind === "user").length;
+  return { turns: condenseItems(items, Math.max(total - inWindow, 0)), total };
+}
+
+// What a session in the caller's workspace said and did, condensed.
+export async function readPeer(
+  callerId: string,
+  ref: string,
+  o: ReadOpts = {}
+): Promise<ReadResult> {
+  let found;
+  try {
+    found = resolveReadable(callerId, ref);
+  } catch (error) {
+    throw new ReadError(
+      error instanceof Error ? error.message : String(error),
+      403
+    );
+  }
+  if (!found.ok) {
+    const scope = readerScope(callerId);
+    const external =
+      found.external && scope.workspaceId
+        ? await findExternalSession(scope.workspaceId, ref).catch(() => null)
+        : null;
+    if (external) {
+      const n = o.lines ?? (o.all ? TERMINAL_LINES_ALL : TERMINAL_LINES);
+      return {
+        header: `${external.ref} (external terminal)`,
+        text: await readExternal(external, n),
+        session: { id: null, name: external.ref, project: null },
+        task: null,
+        turns: null,
+        truncated: false,
+      };
+    }
+    throw new ReadError(found.error, found.external ? 404 : 403);
+  }
+  const s: ReadableSession = found.session;
+  const who = { id: s.id, name: s.name, project: s.project_name };
+  const label = `${s.project_name ? `${s.project_name}/` : ""}${s.name}`;
+  const task = taskHeader(s, !!o.all);
+  const note = found.note ? ` (${found.note})` : "";
+
+  if (s.view !== "chat" || hostLink(s.host_id)) {
+    const n =
+      o.lines ?? (o.all || o.grep ? TERMINAL_LINES_ALL : TERMINAL_LINES);
+    return {
+      header: `${label}${note}: ${s.view}, ${stateOf(s)}`,
+      text: await readResolved(s, n, o.grep),
+      session: who,
+      task,
+      turns: null,
+      truncated: false,
+    };
+  }
+
+  const { turns, total } = chatTurns(s, o);
+  const r: Rendered = o.grep
+    ? grepTurns(turns, o.grep, { all: o.all })
+    : renderTurns(turns, o);
+  const taskText = task
+    ? `Task brief:\n${task.prompt}${task.plan ? `\nPlan: ${task.plan}` : ""}\n\n`
+    : "";
+  const body = r.text
+    ? r.text
+    : o.grep
+      ? `no turns match "${o.grep}"`
+      : "(no messages yet)";
+  const range = r.to
+    ? `turns ${r.from === r.to ? r.to : `${r.from}-${r.to}`} of ${total}`
+    : `${total} turns`;
+  const more =
+    r.truncated && !o.all ? "; more with --turns N, --grep or --all" : "";
+  return {
+    header: `${label}${note} (chat, ${stateOf(s)}), ${o.grep ? `matches for "${o.grep}", ` : ""}${range}${more}`,
+    text: untrusted(s.name, `${taskText}${body}`),
+    session: who,
+    task,
+    turns: { from: r.from, to: r.to, total },
+    truncated: r.truncated,
+  };
+}

package/lib/chat/client-send.ts

@@ -1,25 +1,29 @@
-import type { ChatImage } from "./events";
+import { resolveFiles } from "../attachments/store";
+import type { ChatFile, ChatImage } from "./events";
 import type { CompactFirst } from "./stale";
 
-// What a browser's send may carry: its text and images, and whether the
+// What a browser's send may carry: its text, images and files, and whether the
 // reader chose to compact a stale chat first. Who a message is from (`from`,
 // `peer`, `origin`) is set by the server alone, never by a client. Its own
 // id for the message is kept only in a shape no server id takes.
 export function clientSend(msg: unknown): {
   text: string;
   images?: ChatImage[];
+  files?: ChatFile[];
   compact?: CompactFirst;
   id?: string;
 } {
   const m = (msg ?? {}) as {
     text?: unknown;
     images?: unknown;
+    files?: unknown;
     compact?: unknown;
     clientId?: unknown;
   };
   return {
     text: typeof m.text === "string" ? m.text : "",
     images: Array.isArray(m.images) ? (m.images as ChatImage[]) : undefined,
+    files: resolveFiles(m.files),
     ...(m.compact === true && { compact: "yes" as const }),
     ...(isClientId(m.clientId) && { id: m.clientId }),
   };

package/lib/chat/driver.ts

@@ -6,6 +6,7 @@ import type {
   ApprovalDecision,
   ChatAccess,
   ChatCommand,
+  ChatFile,
   ChatImage,
   ChatItem,
   ChatModel,
@@ -88,7 +89,9 @@ export interface ChatConversation {
   send(
     text: string,
     images?: ChatImage[],
-    options?: { now?: boolean }
+    // `files`: saved attachments; their paths are already in `text`, and a
+    // driver may also hand some to the model directly.
+    options?: { now?: boolean; files?: ChatFile[] }
   ): string | undefined;
   // A command the driver answers itself, without starting a turn (/mcp):
   // the items to show, or null to send the text as a message.

package/lib/chat/drivers/claude.ts

@@ -1,3 +1,4 @@
+import { documentBlocks } from "../../attachments/message";
 import { sessionBaseEnv } from "../../agents/server-env";
 import { randomUUID } from "crypto";
 import {
@@ -320,6 +321,7 @@ export const claudeDriver: ChatDriver = {
               data: img.data,
             },
           })),
+          ...documentBlocks(sendOptions?.files),
           { type: "text" as const, text },
         ];
         const checkpoint = randomUUID();

package/lib/chat/events.ts

@@ -1,5 +1,8 @@
 import type { CallUsage } from "../usage/types";
 import type { SearchResult } from "./find";
+import type { ChatFile } from "../attachments/types";
+
+export type { ChatFile };
 
 /**
  * The provider-neutral shape of a chat conversation. Every driver (Claude
@@ -152,6 +155,8 @@ export type ChatItem =
       kind: "user";
       text: string;
       images?: ChatImage[];
+      // Saved in the session's attachments folder, by reference.
+      files?: ChatFile[];
       // Who sent it through the agent bus, when not typed here.
       from?: string;
       // Sent by another agent session: shown as its body, while the agent
@@ -282,6 +287,7 @@ export interface QueuedMessage {
   id: string;
   text: string;
   imageCount?: number;
+  fileCount?: number;
   createdAt: number;
 }
 
@@ -413,7 +419,13 @@ export type ChatServerMessage =
 // What a browser sends.
 export type ChatClientMessage =
   // `clientId` (`user-c-…`) becomes the message's id: a resend is a no-op.
-  | { type: "send"; text: string; images?: ChatImage[]; clientId?: string }
+  | {
+      type: "send";
+      text: string;
+      images?: ChatImage[];
+      files?: ChatFile[];
+      clientId?: string;
+    }
   | { type: "queue_edit"; id: string; text: string }
   | { type: "queue_move"; id: string; by: -1 | 1 }
   | { type: "queue_delete"; id: string }

package/lib/chat/pending.ts

@@ -1,4 +1,4 @@
-import type { ChatImage, ChatState } from "./events";
+import type { ChatFile, ChatImage, ChatState } from "./events";
 
 // A message the composer sent that isn't in the chat or its queue yet. It
 // shows as a bubble at once, and stays (as failed, with Retry) if it never
@@ -7,6 +7,7 @@ export interface PendingSend {
   id: string;
   text: string;
   images?: ChatImage[];
+  files?: ChatFile[];
   compact?: boolean;
   // "sending": not taken in yet. "accepted": the server has it and is
   // starting the agent.

package/lib/chat/queued.ts

@@ -1,6 +1,6 @@
 import { db } from "../db";
 import { HELD_SQL } from "./hold";
-import type { ChatImage, QueuedMessage, SentBy } from "./events";
+import type { ChatFile, ChatImage, QueuedMessage, SentBy } from "./events";
 
 // Messages written while a turn runs, kept in SQLite so a reload or a
 // restart never loses them. The worker sends them in order when the turn
@@ -15,6 +15,7 @@ interface Row {
   id: string;
   text: string;
   images: string | null;
+  files: string | null;
   sent_by: string | null;
   created_at: number;
 }
@@ -25,19 +26,21 @@ export function listQueue(sessionId: string): QueuedMessage[] {
   return (
     db
       .prepare(
-        `SELECT id, text, image_count, created_at
+        `SELECT id, text, image_count, files, created_at
          FROM chat_queue WHERE session_id = ? ORDER BY position, created_at`
       )
       .all(sessionId) as {
       id: string;
       text: string;
       image_count: number;
+      files: string | null;
       created_at: number;
     }[]
   ).map((r) => ({
     id: r.id,
     text: r.text,
     imageCount: r.image_count || undefined,
+    fileCount: r.files ? (JSON.parse(r.files) as unknown[]).length : undefined,
     createdAt: r.created_at,
   }));
 }
@@ -45,7 +48,12 @@ export function listQueue(sessionId: string): QueuedMessage[] {
 // At the back. A retried send with the same id is only queued once.
 export function enqueue(
   sessionId: string,
-  m: { id: string; text: string; images?: ChatImage[] } & SentBy
+  m: {
+    id: string;
+    text: string;
+    images?: ChatImage[];
+    files?: ChatFile[];
+  } & SentBy
 ): void {
   const images = m.images?.length ? JSON.stringify(m.images) : null;
   const sentBy: SentBy = { from: m.from, peer: m.peer, origin: m.origin };
@@ -59,8 +67,8 @@ export function enqueue(
   if (n >= MAX_QUEUED)
     throw new Error(`The queue is full (${MAX_QUEUED} messages)`);
   db.prepare(
-    `INSERT OR IGNORE INTO chat_queue (id, session_id, position, text, images, image_count, sent_by, created_at)
-     VALUES (?, ?, (SELECT COALESCE(MAX(position), 0) + 1 FROM chat_queue WHERE session_id = ?), ?, ?, ?, ?, ?)`
+    `INSERT OR IGNORE INTO chat_queue (id, session_id, position, text, images, image_count, files, sent_by, created_at)
+     VALUES (?, ?, (SELECT COALESCE(MAX(position), 0) + 1 FROM chat_queue WHERE session_id = ?), ?, ?, ?, ?, ?, ?)`
   ).run(
     m.id,
     sessionId,
@@ -68,6 +76,7 @@ export function enqueue(
     m.text,
     images,
     m.images?.length ?? 0,
+    m.files?.length ? JSON.stringify(m.files) : null,
     m.from || m.peer || m.origin ? JSON.stringify(sentBy) : null,
     Date.now()
   );
@@ -80,13 +89,20 @@ export function claimNext(
   sessionId: string,
   // That message only, if it's still there.
   id?: string
-): ({ id: string; text: string; images?: ChatImage[] } & SentBy) | null {
+):
+  | ({
+      id: string;
+      text: string;
+      images?: ChatImage[];
+      files?: ChatFile[];
+    } & SentBy)
+  | null {
   const row = db
     .prepare(
       `DELETE FROM chat_queue WHERE session_id = @sid AND NOT ${HELD_SQL} AND id = (
          SELECT id FROM chat_queue WHERE session_id = @sid AND (@id IS NULL OR id = @id)
          ORDER BY position, created_at LIMIT 1
-       ) RETURNING id, text, images, sent_by, created_at`
+       ) RETURNING id, text, images, files, sent_by, created_at`
     )
     .get({ sid: sessionId, id: id ?? null }) as Row | undefined;
   if (!row) return null;
@@ -94,6 +110,7 @@ export function claimNext(
     id: row.id,
     text: row.text,
     images: row.images ? (JSON.parse(row.images) as ChatImage[]) : undefined,
+    files: row.files ? (JSON.parse(row.files) as ChatFile[]) : undefined,
     ...(row.sent_by ? (JSON.parse(row.sent_by) as SentBy) : {}),
   };
 }

package/lib/chat/runner.ts

@@ -19,6 +19,7 @@ import type { CompactFirst } from "./stale";
 import type {
   ApprovalDecision,
   ChatContext,
+  ChatFile,
   ChatImage,
   ChatServerMessage,
   ChatState,
@@ -405,7 +406,12 @@ function refuseAway(sessionId: string): void {
 // started): the message waits in the queue instead of starting a turn.
 function queuedIfHeld(
   sessionId: string,
-  m: { id: string; text: string; images?: ChatImage[] } & SentBy
+  m: {
+    id: string;
+    text: string;
+    images?: ChatImage[];
+    files?: ChatFile[];
+  } & SentBy
 ): boolean {
   refuseAway(sessionId);
   if (!chatHold(sessionId)) return false;
@@ -429,6 +435,7 @@ export async function sendChat(
   input: {
     text: string;
     images?: ChatImage[];
+    files?: ChatFile[];
     // Typed in the composer: waits in the queue while a turn runs.
     queue?: boolean;
     // Compact a stale chat first (lib/chat/stale).
@@ -438,7 +445,7 @@ export async function sendChat(
   } & SentBy
 ): Promise<void> {
   const text = input.text.trim();
-  if (!text && !input.images?.length) return;
+  if (!text && !input.images?.length && !input.files?.length) return;
   if (input.id && taken(sessionId, input.id)) return;
   refuseAway(sessionId);
   const id = input.id ?? `user-${Date.now()}-${randomUUID().slice(0, 5)}`;
@@ -449,6 +456,7 @@ export async function sendChat(
       id,
       text,
       images: input.images,
+      files: input.files,
       ...sentBy(input),
     });
     emitQueue(sessionId);
@@ -463,6 +471,7 @@ export async function sendChat(
     id,
     text,
     images: input.images,
+    files: input.files,
     ...sentBy(input),
     queue: input.queue,
     compact: input.compact,

package/lib/chat/worker/host.ts

@@ -10,10 +10,12 @@ import { agentEnv } from "../../agents/launch";
 import { sessionRunningBrief } from "../../project-config/session";
 import { BUS_BRIEF } from "../../agents/brief";
 import { resolveModelForAgent } from "../../model-catalog";
+import { agentText } from "../../attachments/message";
 import { chatDriverFor } from "../drivers";
 import type { ChatConversation } from "../driver";
 import type {
   ChatContext,
+  ChatFile,
   ChatImage,
   ChatItem,
   ChatState,
@@ -560,6 +562,7 @@ export class ChatHost {
       id: string;
       text: string;
       images?: ChatImage[];
+      files?: ChatFile[];
     } & SentBy,
     now = false
   ): void {
@@ -577,7 +580,7 @@ export class ChatHost {
     if (now) this.nowPending++;
     this.stopping = null;
     const note = this.refreshedNote ?? (this.restartedNote && RESTARTED_NOTE);
-    const text = note ? `${note}\n\n${m.text}` : m.text;
+    const text = agentText(note ? `${note}\n\n${m.text}` : m.text, m.files);
     if (this.refreshedNote) {
       this.refreshedNote = null;
       db.prepare(`UPDATE sessions SET chat_refreshed = 0 WHERE id = ?`).run(
@@ -592,13 +595,16 @@ export class ChatHost {
     }
     if (/^\/compact\b/.test(m.text.trimStart())) this.setCompacting(true);
     const checkpoint = now
-      ? this.conversation.send(text, m.images, { now })
-      : this.conversation.send(text, m.images);
+      ? this.conversation.send(text, m.images, { now, files: m.files })
+      : m.files?.length
+        ? this.conversation.send(text, m.images, { files: m.files })
+        : this.conversation.send(text, m.images);
     const user: ChatItem = {
       id: m.id,
       kind: "user",
       text: m.text,
       images: m.images,
+      files: m.files,
       from: m.from,
       peer: m.peer,
       origin: m.origin,

package/lib/chat/worker/protocol.ts

@@ -9,6 +9,7 @@ import path from "path";
 import type {
   ApprovalDecision,
   ChatAccess,
+  ChatFile,
   ChatImage,
   ChatItem,
   ChatState,
@@ -32,6 +33,7 @@ export type WorkerCommand =
       id: string;
       text: string;
       images?: ChatImage[];
+      files?: ChatFile[];
       from?: string;
       peer?: PeerMessage;
       origin?: ChatOrigin;

package/lib/config/client-config-types.ts

@@ -28,10 +28,23 @@ export interface ClientConfig {
   runTriggers: Record<string, string>;
   features: ClientFeatures;
   intake: IntakeLimits;
-  attachments: { max: number };
+  attachments: AttachmentConfig;
   voice: VoiceLimits;
 }
 
+// What a chat accepts, served from lib/attachments/policy.ts. Sizes in bytes.
+export interface AttachmentConfig {
+  max: number;
+  maxBytes: number;
+  maxImageBytes: number;
+  pdfInlineBytes: number;
+  types: {
+    ext: string;
+    mediaType: string;
+    kind: "image" | "pdf" | "sheet" | "doc" | "text";
+  }[];
+}
+
 // Server kill switches for the phone's new sends.
 export interface ClientFeatures {
   shakeToReport: boolean;
@@ -66,8 +79,6 @@ export const INTAKE_LIMITS: IntakeLimits = {
   logMaxLines: 200,
 };
 
-export const ATTACHMENT_LIMITS = { max: 8 };
-
 export const VOICE_LIMITS: VoiceLimits = {
   maxPhrases: 100,
   holdMinMs: 250,

package/lib/config/client-config.ts

@@ -1,3 +1,4 @@
+import { ATTACHMENT_LIMITS } from "../attachments/policy";
 import { ACCESS_LEVELS, DEFAULT_NEW_CHAT_ACCESS } from "../chat/access-levels";
 import { CHAT_ACCESS } from "../chat/events";
 import {
@@ -7,7 +8,6 @@ import {
 import { TASK_STATE_LABELS } from "../tasks/state-labels";
 import { cachedCheck } from "../updates/check";
 import {
-  ATTACHMENT_LIMITS,
   CLIENT_CONFIG_VERSION,
   INTAKE_LIMITS,
   VOICE_LIMITS,