jupyterlab-codex-sidebar 0.1.4 → 0.1.6

package/tests/e2e/queue-multitab-repro.spec.js

@@ -0,0 +1,189 @@
+const path = require('path');
+const { test, expect } = require('@playwright/test');
+
+const NOTEBOOKS = [
+  { path: 'tests/e2e/fixtures/notebooks/tab1.ipynb', name: 'tab1.ipynb' },
+  { path: 'tests/e2e/fixtures/notebooks/tab2.ipynb', name: 'tab2.ipynb' },
+  { path: 'tests/e2e/fixtures/notebooks/tab3.ipynb', name: 'tab3.ipynb' }
+];
+
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function buildInitialNotebookUrl(baseLabUrl, notebookPath) {
+  const parsed = new URL(baseLabUrl);
+  const basePath = parsed.pathname.replace(/\/$/, '');
+  parsed.pathname = `${basePath}/tree/${notebookPath}`;
+  parsed.searchParams.set('reset', '1');
+  return parsed.toString();
+}
+
+async function dismissBlockingDialogs(page) {
+  for (let attempt = 0; attempt < 8; attempt += 1) {
+    const dialog = page.locator('dialog.jp-Dialog, [role="dialog"].jp-Dialog, [role="dialog"]').first();
+    if (!(await dialog.count()) || !(await dialog.isVisible())) {
+      return;
+    }
+
+    const noKernelButton = page.getByRole('button', { name: /^No Kernel$/ }).first();
+    if ((await noKernelButton.count()) > 0 && (await noKernelButton.isVisible())) {
+      await noKernelButton.click();
+      await page.waitForTimeout(150);
+      continue;
+    }
+
+    const selectKernelButton = page.getByRole('button', { name: /^Select Kernel$/ }).first();
+    if ((await selectKernelButton.count()) > 0 && (await selectKernelButton.isVisible())) {
+      await selectKernelButton.click();
+      await page.waitForTimeout(150);
+      continue;
+    }
+
+    await page.keyboard.press('Escape');
+    await page.waitForTimeout(150);
+  }
+}
+
+async function ensureFileBrowserVisible(page) {
+  await dismissBlockingDialogs(page);
+  const fileBrowserTab = page.getByRole('tab', { name: /File Browser/i }).first();
+  if (await fileBrowserTab.count()) {
+    const isActiveBefore = await fileBrowserTab.evaluate(
+      element =>
+        element.getAttribute('aria-selected') === 'true' ||
+        (typeof element.className === 'string' && element.className.includes('lm-mod-current'))
+    );
+    if (!isActiveBefore) {
+      await fileBrowserTab.click();
+    }
+    const isActiveAfter = await fileBrowserTab.evaluate(
+      element =>
+        element.getAttribute('aria-selected') === 'true' ||
+        (typeof element.className === 'string' && element.className.includes('lm-mod-current'))
+    );
+    if (!isActiveAfter) {
+      await fileBrowserTab.click();
+    }
+  }
+  await expect(page.locator('.jp-BreadCrumbs-home')).toBeVisible({ timeout: 10000 });
+}
+
+async function openNotebookFromFileBrowser(page, notebookName) {
+  await ensureFileBrowserVisible(page);
+  let item = page
+    .getByRole('listitem', { name: new RegExp(`\\b${escapeRegExp(notebookName)}\\b`, 'i') })
+    .first();
+  if (!(await item.count())) {
+    item = page.locator('.jp-DirListing-item', { hasText: notebookName }).first();
+  }
+  if (!(await item.count())) {
+    item = page.locator('.jp-FileBrowser').getByText(notebookName, { exact: true }).first();
+  }
+  await expect(item).toBeVisible({ timeout: 20000 });
+  await item.dblclick();
+  await dismissBlockingDialogs(page);
+}
+
+async function activateNotebookTab(page, notebookName) {
+  await dismissBlockingDialogs(page);
+  const tab = page.getByRole('tab', { name: new RegExp(`^${escapeRegExp(notebookName)}$`) }).first();
+  await expect(tab).toBeVisible({ timeout: 20000 });
+  await tab.click();
+  await expect(page.locator('.jp-CodexChat-notebook')).toHaveText(notebookName, { timeout: 20000 });
+}
+
+async function ensureCodexPanel(page) {
+  await dismissBlockingDialogs(page);
+  const composer = page.locator('.jp-CodexPanel .jp-CodexComposer textarea');
+  if ((await composer.count()) > 0 && (await composer.first().isVisible())) {
+    return;
+  }
+
+  const codexSideTab = page
+    .locator('.jp-SideBar.jp-mod-right .lm-TabBar-tab[title="Codex"], .jp-SideBar.jp-mod-right .lm-TabBar-tab')
+    .filter({ hasText: 'Codex' })
+    .first();
+  await expect(codexSideTab).toBeVisible({ timeout: 20000 });
+  await codexSideTab.click();
+
+  if ((await composer.count()) > 0) {
+    await expect(composer.first()).toBeVisible({ timeout: 20000 });
+    return;
+  }
+  throw new Error('Codex panel could not be activated from right sidebar tab.');
+}
+
+async function sendMessage(page, text) {
+  await dismissBlockingDialogs(page);
+  const composer = page.locator('.jp-CodexComposer textarea');
+  const sendBtn = page.locator('.jp-CodexSendBtn');
+
+  await expect(composer).toBeVisible();
+  await composer.fill(text);
+  await expect(sendBtn).toBeEnabled({ timeout: 15000 });
+  await sendBtn.click();
+  await expect(page.locator('.jp-CodexSendBtn.is-stop')).toBeVisible({ timeout: 15000 });
+}
+
+test('rapid 3-tab send while in-flight does not freeze Codex sidebar', async ({ page, baseURL }) => {
+  const codexCommandPath =
+    process.env.PLAYWRIGHT_CODEX_COMMAND || path.resolve(__dirname, 'mock-codex-cli.py');
+  const targetUrl = baseURL || process.env.JUPYTERLAB_URL || 'http://127.0.0.1:8888/lab';
+  const initialNotebookUrl = buildInitialNotebookUrl(targetUrl, NOTEBOOKS[0].path);
+  const pageErrors = [];
+  const codexConsoleErrors = [];
+
+  page.on('pageerror', err => {
+    pageErrors.push(String(err?.message || err));
+  });
+  page.on('console', msg => {
+    if (msg.type() !== 'error') {
+      return;
+    }
+    const text = msg.text();
+    if (text.includes('[Codex] onSocketMessage failed') || text.includes('WebSocketClosedError')) {
+      codexConsoleErrors.push(text);
+    }
+  });
+
+  await page.addInitScript(commandPath => {
+    window.localStorage.setItem('jupyterlab-codex:command-path', commandPath);
+  }, codexCommandPath);
+
+  await page.goto(initialNotebookUrl, { waitUntil: 'domcontentloaded' });
+  await page.waitForSelector('main[aria-label="Main Content"], .jp-LabShell, .lm-DockPanel', {
+    timeout: 30000
+  });
+  await dismissBlockingDialogs(page);
+  await ensureCodexPanel(page);
+
+  for (const notebook of NOTEBOOKS.slice(1)) {
+    await openNotebookFromFileBrowser(page, notebook.name);
+  }
+
+  let sendIndex = 1;
+  for (const notebook of NOTEBOOKS) {
+    await activateNotebookTab(page, notebook.name);
+    await sendMessage(page, `playwright-multitab-repro-${sendIndex}`);
+    sendIndex += 1;
+  }
+
+  // While runs are in-flight, switch tabs rapidly to stress session/socket mapping.
+  for (let round = 0; round < 2; round += 1) {
+    for (const notebook of NOTEBOOKS) {
+      await activateNotebookTab(page, notebook.name);
+      await page.waitForTimeout(120);
+    }
+  }
+
+  for (const notebook of NOTEBOOKS) {
+    await activateNotebookTab(page, notebook.name);
+    await expect(page.locator('.jp-CodexSendBtn.is-stop')).toHaveCount(0, { timeout: 45000 });
+  }
+
+  await expect(page.locator('.jp-CodexChat-reconnectNotice')).toHaveCount(0);
+  await expect(page.getByText('Internal UI error while processing a server message')).toHaveCount(0);
+  expect(pageErrors).toEqual([]);
+  expect(codexConsoleErrors).toEqual([]);
+});

package/tests/test_handlers.py

@@ -0,0 +1,116 @@
+import json
+import re
+import unittest
+from unittest.mock import patch
+
+from jupyterlab_codex.handlers import CodexWSHandler, _coerce_session_id
+
+
+_SAFE_SESSION_ID_RE = re.compile(r"^[A-Za-z0-9_-]+$")
+
+
+class _DummySessionStore:
+    def __init__(self, resolved_session_id: str = ""):
+        self.resolved_session_id = resolved_session_id
+        self.ensure_calls: list[tuple[str, str, str]] = []
+
+    def resolve_session_for_notebook(self, notebook_path: str, notebook_os_path: str = "") -> str:
+        return self.resolved_session_id
+
+    def has_session(self, session_id: str) -> bool:
+        return False
+
+    def session_matches_notebook(
+        self,
+        session_id: str,
+        notebook_path: str,
+        notebook_os_path: str = "",
+    ) -> bool:
+        return False
+
+    def ensure_session(self, session_id: str, notebook_path: str, notebook_os_path: str = "") -> None:
+        self.ensure_calls.append((session_id, notebook_path, notebook_os_path))
+
+    def update_notebook_path(
+        self, session_id: str, notebook_path: str, notebook_os_path: str = ""
+    ) -> None:
+        pass
+
+    def load_messages(self, session_id: str):
+        return []
+
+
+class TestSessionIdCoercion(unittest.TestCase):
+    def test_coerce_session_id_accepts_safe_characters(self):
+        self.assertEqual(_coerce_session_id("thread_01-alpha"), "thread_01-alpha")
+
+    def test_coerce_session_id_rejects_path_elements(self):
+        self.assertEqual(_coerce_session_id("../thread-1"), "")
+        self.assertEqual(_coerce_session_id("..\\thread-1"), "")
+        self.assertEqual(_coerce_session_id("thread/../1"), "")
+        self.assertEqual(_coerce_session_id("thread.1"), "")
+
+    def test_coerce_session_id_rejects_non_string(self):
+        self.assertEqual(_coerce_session_id(None), "")
+        self.assertEqual(_coerce_session_id(123), "")
+
+
+class TestHandleStartSessionSessionId(unittest.IsolatedAsyncioTestCase):
+    def _make_handler(self, resolved_session_id: str) -> CodexWSHandler:
+        handler = CodexWSHandler.__new__(CodexWSHandler)
+        handler._store = _DummySessionStore(resolved_session_id=resolved_session_id)
+        handler._runner = None
+        handler._active_runs = {}
+        handler._messages: list[str] = []
+        handler._safe_write_message = handler._messages.append
+        handler._send_model_catalog = lambda *args, **kwargs: None
+        handler._resolve_notebook_os_path = lambda path: ""
+        return handler
+
+    async def test_start_session_uses_sanitized_mapped_session_id_for_invalid_payload_id(self):
+        handler = self._make_handler(resolved_session_id="mapped_thread")
+
+        payload = {
+            "sessionId": "../evil/session",
+            "notebookPath": "/tmp/project/notebook.ipynb",
+            "sessionContextKey": "ctx",
+            "forceNewThread": False,
+            "commandPath": "",
+        }
+
+        with patch(
+            "jupyterlab_codex.handlers._compute_pairing_status",
+            return_value=(True, "", "", "", ""),
+        ):
+            await handler._handle_start_session(payload)
+
+        status = json.loads(handler._messages[-1])
+        self.assertEqual(status["sessionId"], "mapped_thread")
+        self.assertEqual(status["sessionResolution"], "mapping")
+        self.assertEqual(handler._store.ensure_calls[0][0], "mapped_thread")
+
+    async def test_start_session_falls_back_to_generated_safe_session_id(self):
+        handler = self._make_handler(resolved_session_id="../unsafe/mapped")
+
+        payload = {
+            "sessionId": "../../payload",
+            "notebookPath": "",
+            "sessionContextKey": "",
+            "forceNewThread": False,
+            "commandPath": "",
+        }
+
+        with patch(
+            "jupyterlab_codex.handlers._compute_pairing_status",
+            return_value=(False, "", "", "", ""),
+        ):
+            await handler._handle_start_session(payload)
+
+        status = json.loads(handler._messages[-1])
+        generated_id = status["sessionId"]
+
+        self.assertTrue(_SAFE_SESSION_ID_RE.fullmatch(generated_id))
+        self.assertNotIn("/", generated_id)
+        self.assertNotIn("..", generated_id)
+        self.assertNotIn("\\", generated_id)
+        self.assertTrue(handler._store.ensure_calls[0][0], _SAFE_SESSION_ID_RE)

package/tests/test_protocol.py

@@ -0,0 +1,169 @@
+import unittest
+
+from jupyterlab_codex.protocol import (
+    ProtocolParseError,
+    build_cli_defaults_payload,
+    build_delete_all_payload,
+    build_done_payload,
+    build_error_payload,
+    build_event_payload,
+    build_output_payload,
+    build_rate_limits_payload,
+    build_status_payload,
+    parse_client_message,
+)
+
+
+class TestProtocolBuilders(unittest.TestCase):
+    def test_parse_client_start_session_trims_fields(self):
+        message = {
+            "type": "start_session",
+            "sessionId": "  thread-1  ",
+            "notebookPath": " /notebooks/a.ipynb ",
+            "sessionContextKey": " key ",
+            "forceNewThread": "true",
+            "commandPath": " /usr/bin/codex ",
+        }
+        msg_type, payload = parse_client_message(message)
+        self.assertEqual(msg_type, "start_session")
+        self.assertEqual(payload["sessionId"], "thread-1")
+        self.assertEqual(payload["notebookPath"], "/notebooks/a.ipynb")
+        self.assertEqual(payload["sessionContextKey"], "key")
+        self.assertTrue(payload["forceNewThread"])
+        self.assertEqual(payload["commandPath"], "/usr/bin/codex")
+
+    def test_parse_client_send_normalizes_fields(self):
+        message = {
+            "type": "send",
+            "sessionId": "thread-1",
+            "sessionContextKey": "k",
+            "content": "  hello  ",
+            "notebookPath": "",
+            "commandPath": 42,
+            "model": None,
+            "reasoningEffort": "medium",
+            "sandbox": "  read-only  ",
+            "selection": "sel",
+            "cellOutput": "out",
+            "images": [{"a": 1}],
+            "uiSelectionPreview": {"locationLabel": "x", "previewText": "y"},
+            "uiCellOutputPreview": {"locationLabel": "Cell 8 Output", "previewText": "42"},
+            "selectionTruncated": "true",
+            "cellOutputTruncated": 0,
+        }
+        msg_type, payload = parse_client_message(message)
+        self.assertEqual(msg_type, "send")
+        self.assertEqual(payload["commandPath"], "")
+        self.assertEqual(payload["content"], "hello")
+        self.assertEqual(payload["sandbox"], "read-only")
+        self.assertEqual(payload["model"], "")
+        self.assertEqual(payload["selection"], "sel")
+        self.assertEqual(payload["images"], [{"a": 1}])
+        self.assertEqual(payload["uiCellOutputPreview"], {"locationLabel": "Cell 8 Output", "previewText": "42"})
+        self.assertTrue(payload["selectionTruncated"])
+        self.assertFalse(payload["cellOutputTruncated"])
+
+    def test_parse_client_send_preserves_selection_and_cell_output_whitespace(self):
+        message = {
+            "type": "send",
+            "sessionId": "thread-1",
+            "sessionContextKey": "k",
+            "content": "  hello  ",
+            "selection": "  def run():\\n    return 1\\n",
+            "cellOutput": "\\n>>>   foo()\\nbar()  \\n",
+        }
+        msg_type, payload = parse_client_message(message)
+        self.assertEqual(msg_type, "send")
+        self.assertEqual(payload["selection"], "  def run():\\n    return 1\\n")
+        self.assertEqual(payload["cellOutput"], "\\n>>>   foo()\\nbar()  \\n")
+
+    def test_parse_client_invalid_message(self):
+        with self.assertRaises(ProtocolParseError):
+            parse_client_message({"type": "unknown"})
+
+    def test_builders_shape(self):
+        self.assertEqual(
+            build_status_payload(
+                state="ready",
+                run_id="run-1",
+                session_id="thread-1",
+                session_context_key="ctx-1",
+                notebook_path="/notebooks/a.ipynb",
+                run_mode="resume",
+                paired_ok=True,
+                paired_path="/paired",
+                paired_os_path="/paired-os",
+                paired_message="paired",
+                notebook_mode="ipynb",
+                history=[{"role": "user", "content": "hi"}],
+            )["type"],
+            "status",
+        )
+
+        output = build_output_payload(
+            run_id="run-1",
+            session_id="thread-1",
+            session_context_key="ctx-1",
+            notebook_path="/notebooks/a.ipynb",
+            text="ok",
+            role="system",
+        )
+        self.assertEqual(output["role"], "system")
+
+        event = build_event_payload(
+            run_id="run-1",
+            session_id="thread-1",
+            session_context_key="ctx-1",
+            notebook_path="/notebooks/a.ipynb",
+            payload={"kind": "log"},
+        )
+        self.assertEqual(event["payload"], {"kind": "log"})
+
+        done = build_done_payload(
+            run_id="run-1",
+            session_id="thread-1",
+            session_context_key="ctx-1",
+            notebook_path="/notebooks/a.ipynb",
+            exit_code=0,
+            file_changed=False,
+            run_mode="resume",
+            paired_ok=True,
+            paired_path="/paired",
+            paired_os_path="/paired-os",
+            paired_message="paired",
+            notebook_mode="ipynb",
+            cancelled=True,
+        )
+        self.assertTrue(done["cancelled"])
+
+        error = build_error_payload(
+            message="bad",
+            run_id="run-1",
+            session_id="thread-1",
+            session_context_key="ctx-1",
+            notebook_path="/notebooks/a.ipynb",
+            run_mode="fallback",
+            suggested_command_path="/usr/bin/codex",
+            paired_ok=True,
+        )
+        self.assertEqual(error["message"], "bad")
+        self.assertEqual(error["runMode"], "fallback")
+
+        rates = build_rate_limits_payload({"x": 1})
+        self.assertEqual(rates["snapshot"], {"x": 1})
+
+        delete_all = build_delete_all_payload(
+            ok=True,
+            deleted_count=1,
+            failed_count=0,
+            message="deleted",
+        )
+        self.assertTrue(delete_all["ok"])
+        self.assertEqual(delete_all["message"], "deleted")
+
+        defaults = build_cli_defaults_payload(model="o4-mini", reasoning_effort="low")
+        self.assertEqual(defaults["model"], "o4-mini")
+
+
+if __name__ == "__main__":
+    unittest.main()

package/tests/test_session_store_limits.py

@@ -0,0 +1,50 @@
+import os
+import tempfile
+import unittest
+
+from jupyterlab_codex.sessions import SessionStore
+
+
+class TestSessionStoreMessageLimits(unittest.TestCase):
+    def test_append_message_trims_to_default_max_of_100(self):
+        previous = os.environ.pop("JUPYTERLAB_CODEX_SESSION_MAX_MESSAGES", None)
+        try:
+            with tempfile.TemporaryDirectory() as base_dir:
+                store = SessionStore(base_dir=base_dir)
+                session_id = "session-default-limit"
+
+                for index in range(150):
+                    store.append_message(session_id, "user", f"message-{index}")
+
+                messages = store.load_messages(session_id)
+
+                self.assertEqual(len(messages), 100)
+                self.assertEqual(messages[0]["content"], "message-50")
+                self.assertEqual(messages[-1]["content"], "message-149")
+        finally:
+            if previous is None:
+                os.environ.pop("JUPYTERLAB_CODEX_SESSION_MAX_MESSAGES", None)
+            else:
+                os.environ["JUPYTERLAB_CODEX_SESSION_MAX_MESSAGES"] = previous
+
+    def test_custom_max_environment_variable_is_respected(self):
+        previous = os.environ.get("JUPYTERLAB_CODEX_SESSION_MAX_MESSAGES")
+        try:
+            os.environ["JUPYTERLAB_CODEX_SESSION_MAX_MESSAGES"] = "12"
+            with tempfile.TemporaryDirectory() as base_dir:
+                store = SessionStore(base_dir=base_dir)
+                session_id = "session-custom-limit"
+
+                for index in range(20):
+                    store.append_message(session_id, "user", f"message-{index}")
+
+                messages = store.load_messages(session_id)
+
+                self.assertEqual(len(messages), 12)
+                self.assertEqual(messages[0]["content"], "message-8")
+                self.assertEqual(messages[-1]["content"], "message-19")
+        finally:
+            if previous is None:
+                os.environ.pop("JUPYTERLAB_CODEX_SESSION_MAX_MESSAGES", None)
+            else:
+                os.environ["JUPYTERLAB_CODEX_SESSION_MAX_MESSAGES"] = previous

package/tests/unit/codexChatAttachmentDedup.spec.ts

@@ -0,0 +1,56 @@
+import { expect, test } from '@playwright/test';
+
+import {
+  buildActiveCellOutputSignature,
+  buildActiveCellSelectionSignature,
+  isDuplicateActiveCellAttachmentSignature,
+  makeActiveCellAttachmentDedupKey
+} from '../../src/codexChatAttachmentDedup';
+
+test('makeActiveCellAttachmentDedupKey prefers thread id', () => {
+  expect(makeActiveCellAttachmentDedupKey('/notebook.ipynb', 'thread-123')).toBe('thread:thread-123');
+  expect(makeActiveCellAttachmentDedupKey('/notebook.ipynb', '')).toBe('session:/notebook.ipynb');
+});
+
+test('buildActiveCellSelectionSignature normalizes text and includes location labels', () => {
+  const signatureA = buildActiveCellSelectionSignature({
+    notebookMode: 'ipynb',
+    text: 'print(1)\r\n',
+    locationLabel: 'Cell 1'
+  });
+  const signatureB = buildActiveCellSelectionSignature({
+    notebookMode: 'ipynb',
+    text: 'print(1)\n',
+    locationLabel: 'Cell 1'
+  });
+  const signatureDifferentCell = buildActiveCellSelectionSignature({
+    notebookMode: 'ipynb',
+    text: 'print(1)\n',
+    locationLabel: 'Cell 2'
+  });
+
+  expect(signatureA).toBe(signatureB);
+  expect(signatureA).not.toBe(signatureDifferentCell);
+});
+
+test('selection and output signatures are independent', () => {
+  const selectionSignature = buildActiveCellSelectionSignature({
+    notebookMode: 'ipynb',
+    text: 'value = 1',
+    locationLabel: 'Cell 3'
+  });
+  const outputSignature = buildActiveCellOutputSignature({
+    notebookMode: 'ipynb',
+    text: '1',
+    locationLabel: 'Cell 3 Output'
+  });
+
+  expect(selectionSignature).not.toBe(outputSignature);
+});
+
+test('isDuplicateActiveCellAttachmentSignature requires non-empty equal signatures', () => {
+  expect(isDuplicateActiveCellAttachmentSignature('a', 'a')).toBe(true);
+  expect(isDuplicateActiveCellAttachmentSignature('a', 'b')).toBe(false);
+  expect(isDuplicateActiveCellAttachmentSignature(undefined, 'a')).toBe(false);
+  expect(isDuplicateActiveCellAttachmentSignature('a', '')).toBe(false);
+});

package/tests/unit/codexChatAttachmentLimit.spec.ts

@@ -0,0 +1,57 @@
+import { expect, test } from '@playwright/test';
+
+import {
+  buildAttachmentTruncationNotice,
+  limitActiveCellAttachmentPayload,
+  resolveSentAttachmentTruncation
+} from '../../src/codexChatAttachmentLimit';
+
+test('limitActiveCellAttachmentPayload keeps payload unchanged when within max', () => {
+  const result = limitActiveCellAttachmentPayload('abc', 'def', 10, 10);
+  expect(result).toEqual({
+    selection: 'abc',
+    cellOutput: 'def',
+    selectionTruncated: false,
+    cellOutputTruncated: false
+  });
+});
+
+test('limitActiveCellAttachmentPayload applies separate limits to input and output', () => {
+  const result = limitActiveCellAttachmentPayload('12345', 'abcdef', 2, 6);
+  expect(result).toEqual({
+    selection: '12',
+    cellOutput: 'abcdef',
+    selectionTruncated: true,
+    cellOutputTruncated: false
+  });
+});
+
+test('limitActiveCellAttachmentPayload truncates output independently when output exceeds max', () => {
+  const result = limitActiveCellAttachmentPayload('12345', 'abcdefghij', 4, 4);
+  expect(result).toEqual({
+    selection: '1234',
+    cellOutput: 'abcd',
+    selectionTruncated: true,
+    cellOutputTruncated: true
+  });
+});
+
+test('buildAttachmentTruncationNotice includes source hint when input is truncated', () => {
+  const notice = buildAttachmentTruncationNotice(true, false, 4000, 20000);
+  expect(notice).toContain('source file/cell');
+  expect(notice).toContain('4000');
+});
+
+test('resolveSentAttachmentTruncation only reports truncation for attachments that were sent', () => {
+  expect(
+    resolveSentAttachmentTruncation({
+      includeSelection: false,
+      includeCellOutput: true,
+      selectionTruncated: true,
+      cellOutputTruncated: true
+    })
+  ).toEqual({
+    selectionTruncated: false,
+    cellOutputTruncated: true
+  });
+});