@@ -106,6 +106,16 @@ jobs:
             echo "tag=$TAG"
           } >> "$GITHUB_OUTPUT"
 
+      # `./embed` and the `#sim-cli/*` imports point at TypeScript source, which
+      # only the monorepo's own Next.js app consumes (it transpiles the package).
+      # The tarball ships `dist` alone, so published they would be dead entry
+      # points; the smoke test below fails on any export that does not exist.
+      - name: Drop source-only entry points
+        working-directory: packages/sim-cli
+        run: |
+          jq 'del(.imports, .exports["./embed"])' package.json > "$RUNNER_TEMP/package.json"
+          mv "$RUNNER_TEMP/package.json" package.json
+
       # Bun packs because it rewrites `workspace:` ranges to real versions,
       # which `npm pack` would publish verbatim. The smoke test below and the
       # publish job both use this one tarball, so what was tested is what ships.
@@ -126,6 +136,20 @@ jobs:
           SMOKE_DIR="$(mktemp -d "$RUNNER_TEMP/sim-cli-smoke.XXXXXX")"
           tar -xzf "$RUNNER_TEMP/package.tgz" -C "$SMOKE_DIR"
           test "$("$SMOKE_DIR/package/dist/index.js" --version)" = "$VERSION"
+          node -e '
+            const fs = require("node:fs")
+            const path = require("node:path")
+            const root = path.join(process.argv[1], "package")
+            const pkg = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8"))
+            const targets = Object.values(pkg.exports ?? {}).flatMap((entry) =>
+              typeof entry === "string" ? [entry] : Object.values(entry)
+            )
+            const missing = targets.filter((target) => !fs.existsSync(path.join(root, target)))
+            if (missing.length > 0) {
+              console.error("Exports point at files the tarball does not contain: " + missing.join(", "))
+              process.exit(1)
+            }
+          ' "$SMOKE_DIR"
 
       - name: Verify version is unpublished
         env:
 
@@ -93,11 +93,27 @@ describe('Search MCP protocol', () => {
       expect(JSON.parse(searchContent.text)).toMatchObject({
         results: [{ documentId, queryIndexes: [0] }],
       })
-      const read = await client.callTool({ name: 'read_document', arguments: { documentId } })
+      const read = await client.callTool({
+        name: 'read_document',
+        arguments: { documentId, limit: 8 },
+      })
       expect(read.isError).not.toBe(true)
+      expect(mocks.liveRead.mock.lastCall?.[0].input).toMatchObject({
+        limit: 8,
+        scaledWindow: { documentsInCall: 1 },
+      })
       expect(read.content).toEqual([
         { type: 'text', text: expect.stringContaining('Read evidence') },
       ])
+      const batchRead = await client.callTool({
+        name: 'read_document',
+        arguments: { documentIds: [documentId, `${documentId}b`], limit: 8 },
+      })
+      expect(batchRead.isError).not.toBe(true)
+      expect(mocks.liveRead.mock.lastCall?.[0].input).toMatchObject({
+        limit: 8,
+        scaledWindow: { documentsInCall: 2 },
+      })
       const offsetless = await client.callTool({
         name: 'search',
         arguments: {
 
@@ -298,6 +298,7 @@ export function createKnowledgeMcpServer(context: KnowledgeMcpContext): McpServe
                 ...options,
                 documentId: id,
                 organizationId,
+                scaledWindow: { documentsInCall: documentId ? 1 : batch.length },
                 resultSecretRegistry: registry,
                 signal,
               },
 
@@ -1193,6 +1193,89 @@ describe('authorized live retrieval', () => {
       })
     ).rejects.toBe('user_stop:test')
   })
+  describe('read window', () => {
+    const content = 'x'.repeat(30_000)
+    async function readWindow(extra: Record<string, unknown>, text = content) {
+      const [result] = (await searchLiveKnowledge.execute({ principal, input })).results
+      if (!result) throw new Error('Expected the search fixture to return a result')
+      mocks.read.mockResolvedValue({ ...document, content: text })
+      const read = await readLiveDocument.execute({
+        principal,
+        input: {
+          workspaceId: 'workspace',
+          documentId: result.documentId,
+          limit: 3,
+          resultSecretRegistry: new ResolvedSecretTraceRegistry([]),
+          ...extra,
+        },
+      })
+      const [chunk] = read.chunks
+      if (!chunk) throw new Error('Expected the read to return a window')
+      return {
+        length: chunk.content.length,
+        encoded: JSON.stringify(chunk.content).length - 2,
+        next: read.next,
+      }
+    }
+
+    const scaled = (documentsInCall: number) => ({ scaledWindow: { documentsInCall } })
+
+    it('returns a proportionally longer window when a scaling caller asks for more chunks', async () => {
+      const { length, next } = await readWindow({ limit: 8, ...scaled(1) })
+      expect(length).toBe(21_333)
+      expect(next).toEqual({ startChunkIndex: 0, startOffset: 21_333 })
+    })
+
+    it('continues a longer window from where the previous one ended', async () => {
+      const { length, next } = await readWindow({ limit: 8, ...scaled(1), startOffset: 21_333 })
+      expect(length).toBe(30_000 - 21_333)
+      expect(next).toBeNull()
+    })
+
+    it.each([
+      [5, 1, 13_333],
+      [8, 2, 20_000],
+      [8, 3, 13_333],
+      [8, 4, 10_000],
+    ])(
+      'shares one call budget: limit %i across %i documents reads %i characters each',
+      async (limit, documentsInCall, expected) => {
+        expect((await readWindow({ limit, ...scaled(documentsInCall) })).length).toBe(expected)
+      }
+    )
+
+    it.each([
+      [1, 21_333],
+      [2, 20_000],
+    ])(
+      'keeps a quote-heavy window within its share once JSON-encoded, across %i documents',
+      async (documentsInCall, share) => {
+        const quotes = '"'.repeat(30_000)
+        const { length, encoded, next } = await readWindow(
+          { limit: 8, ...scaled(documentsInCall) },
+          quotes
+        )
+        expect(encoded).toBeLessThanOrEqual(share)
+        expect(length).toBeGreaterThanOrEqual(8_000)
+        expect(next).toEqual({ startChunkIndex: 0, startOffset: length })
+      }
+    )
+
+    it('keeps the standard window for quote-heavy text at the default limit', async () => {
+      const { length } = await readWindow({ limit: 3, ...scaled(1) }, '"'.repeat(30_000))
+      expect(length).toBe(8_000)
+    })
+
+    it.each([
+      ['at the default limit', { limit: 3, ...scaled(1) }],
+      ['below the default limit', { limit: 1, ...scaled(1) }],
+      ['when the call budget is spread over five documents', { limit: 8, ...scaled(5) }],
+      ['when the call budget is spread over ten documents', { limit: 8, ...scaled(10) }],
+      ['for a caller that does not scale', { limit: 8 }],
+    ])('keeps the standard window %s', async (_, extra) => {
+      expect((await readWindow(extra)).length).toBe(8_000)
+    })
+  })
   it('refuses a chunk index other than zero before reading the document from its provider', async () => {
     const [result] = (await searchLiveKnowledge.execute({ principal, input })).results
     if (!result) throw new Error('Expected the search fixture to return a result')
 
@@ -288,8 +288,45 @@ export const LIVE_NOT_STARTED_MESSAGE =
 export const LIVE_OVER_ACCOUNT_LIMIT_MESSAGE = `Not searched: one search covers at most ${MAX_ACCOUNTS} accounts. Search this source or account alone.`
 /** Previews center on the query's longest matching term, like indexed passages. */
 const PREVIEW_CHARACTERS = 1800
-/** Characters one read returns, the same page budget indexed document reads use. */
+/** Characters one read returns at the default limit, the page budget indexed document reads use. */
 const READ_WINDOW_CHARACTERS = 8000
+/** The read limit {@link READ_WINDOW_CHARACTERS} is sized for, which is the default limit. */
+const READ_WINDOW_LIMIT = 3
+/**
+ * Characters the documents of one scaled read call share. Through four documents it keeps the
+ * call's result, with about a thousand characters of metadata per document, under the
+ * 50,000-character size at which MCP clients such as Claude Code save a tool result to a file
+ * rather than show it. From five documents the standard page per document is the larger, so
+ * those calls read exactly what they read without scaling.
+ */
+const SCALED_READ_CALL_CHARACTERS = 40_000
+
+/**
+ * Where one read's window ends. A live document is one chunk, so a caller that scales the window
+ * gets a longer one when it asks for more chunks than the default, bounded by an even share of the
+ * call's budget across the documents it reads. The share counts the window as the result encodes
+ * it, since JSON escapes quotes, backslashes and line breaks, so a longer window is shortened until
+ * its encoded text fits. The window is never shorter than the standard page, which is also what a
+ * read at or below the default limit, or from any other caller, returns.
+ */
+function readWindowEnd(
+  content: string,
+  start: number,
+  { limit, scaledWindow }: Pick<LiveReadInput, 'limit' | 'scaledWindow'>
+): number {
+  const standardEnd = Math.min(content.length, start + READ_WINDOW_CHARACTERS)
+  if (!scaledWindow || limit <= READ_WINDOW_LIMIT) return standardEnd
+  const scaled = Math.floor((READ_WINDOW_CHARACTERS * limit) / READ_WINDOW_LIMIT)
+  const share = Math.floor(SCALED_READ_CALL_CHARACTERS / Math.max(1, scaledWindow.documentsInCall))
+  const budget = Math.min(scaled, share)
+  let end = Math.min(content.length, start + budget)
+  for (let attempt = 0; attempt < 3 && end > standardEnd; attempt++) {
+    const encoded = JSON.stringify(content.slice(start, end)).length - 2
+    if (encoded <= budget) return end
+    end = start + Math.floor(((end - start) * budget) / encoded)
+  }
+  return standardEnd
+}
 
 /**
  * Verifies candidates in rank order. A revoked grant fails the whole account; any other
@@ -990,6 +1027,11 @@ export type LiveReadInput = ResourceOwner & {
   documentId: string
   filters?: WorkspaceSearchFilters
   limit: number
+  /**
+   * Lengthens the window for a limit above the default, sharing one call's budget across the
+   * documents it reads, as {@link readWindowEnd} sizes it.
+   */
+  scaledWindow?: { documentsInCall: number }
   startChunkIndex?: number
   startOffset?: number
   resultSecretRegistry: ResolvedSecretTraceRegistry
@@ -1135,7 +1177,7 @@ export const readLiveDocument = defineAuthorizedKnowledgeUseCase({
         'validation',
         'This document changed. Read again from the beginning'
       )
-    const end = Math.min(content.length, start + READ_WINDOW_CHARACTERS)
+    const end = readWindowEnd(content, start, input)
     return {
       documentId: input.documentId,
       knowledgeBaseId: '',
 
@@ -171,7 +171,6 @@
         "**/*.spec.ts",
         "apps/desktop/e2e/**",
         "apps/sim/vitest.setup.ts",
-        "packages/cli/**",
         "packages/sim-cli/**",
         "packages/sim-setup/**",
         "packages/db/script-migrations/**",
 
@@ -153,7 +153,6 @@
       "ignoreIssues": { "components/icons/icons.tsx": ["exports", "types", "duplicates"] }
     },
     "apps/pii": { "includeEntryExports": false },
-    "packages/cli": { "includeEntryExports": false },
     "packages/db": {
       "includeEntryExports": false,
       "entry": [