- "); expect(clipboard.html).toContain( 'First issue', ); expect(clipboard.html).toContain("apply_patch"); expect(clipboard.html).toContain("
5. Fifth item
"); expect(clipboard.html).toContain("A hard break
"); expect(clipboard.html).toContain( 'www.example.com stays plain Markdown text.', ); expect(clipboard.html).toContain( 'docs', ); expect(clipboard.html).toContain( 'https://autolink.example.com', ); expect(clipboard.html).toContain( 'workspace file', ); expect(clipboard.html).toContain("https://example.com/generated"); expect(clipboard.html).toContain( 'https://example.com/generated', ); expect(clipboard.html).toContain('
');
    expect(clipboard.html).toContain(
      'before\n```\nafter\n',
    );
    expect(clipboard.html).toContain("");
    expect(clipboard.html).toContain('');
    expect(clipboard.html.match(/obsolete");
    expect(clipboard.html).toContain('');
    expect(clipboard.html).toContain('');
    expect(clipboard.html).toContain('');

    await doubleClickAssistantMarkdownText(page, "code", "apply_patch");
    await copySelection(page);

    const doubleClickedCodeClipboard = await readRichClipboard(page);
    expect(doubleClickedCodeClipboard.plainText).toBe("apply_patch");
    expect(doubleClickedCodeClipboard.html).not.toContain("");

    await doubleClickAssistantMarkdownText(page, "strong", "strong prose");
    await copySelection(page);

    const doubleClickedBoldClipboard = await readRichClipboard(page);
    expect(doubleClickedBoldClipboard.plainText).toBe("strong");
    expect(doubleClickedBoldClipboard.html).not.toContain("");

    await selectAssistantTextRange(
      page,
      "P1 — High-value UI behavior",
      "Smoke with an older saved Fabel/model alias and with daemon/client version drift.",
    );
    await copySelection(page);

    const headingAndListClipboard = await readRichClipboard(page);
    expect(headingAndListClipboard.plainText).toBe(
      [
        "P1 — High-value UI behavior",
        "===========================",
        "",
        "5. Claude model and thinking preferences",
        "    - Switch Claude models and confirm each model retains its own thinking choice.",
        "    - Cover new-workspace drafts, queued launches, schedules, and editing existing schedules.",
        "    - Confirm Opus 5 exposes the Fast toggle.",
        "    - Smoke with an older saved Fabel/model alias and with daemon/client version drift.",
      ].join("\n"),
    );
    expect(headingAndListClipboard.html).toMatch(
      /P1 — High-value UI behavior<\/h1>\s*5\. Claude model and thinking preferences\s*<\/div>- Switch Claude models/,
    );

    await selectAssistantText(page, "First");
    await copySelection(page);

    const partialClipboard = await readRichClipboard(page);
    expect(partialClipboard.plainText).toBe("First");
    expect(partialClipboard.html).toContain("First");

    await selectAssistantTextRange(page, "Direct matches:", "repeated sandbox setup.");
    await copySelection(page);

    const paragraphAndListClipboard = await readRichClipboard(page);
    expect(paragraphAndListClipboard.plainText).toBe(
      [
        "Direct matches:",
        "",
        "Formatted **strong prose**, _emphasized prose_, and ~~struck prose~~.",
        "",
        "- **[First issue](https://example.com/issues/1)**: exact `apply_patch` failure.",
        "- [Second issue](https://example.com/issues/2): repeated sandbox setup.",
      ].join("\n"),
    );
    expect(paragraphAndListClipboard.html).not.toContain("");
    expect(paragraphAndListClipboard.html).not.toContain("");
    expect(paragraphAndListClipboard.html).toContain(
      '- First issue',
    );

    await selectAssistantListItemFromMarker(page, "ul", "First issue", "failure.");
    await copySelection(page);

    const draggedBulletClipboard = await readRichClipboard(page);
    expect(draggedBulletClipboard.plainText).toBe(
      "- **[First issue](https://example.com/issues/1)**: exact `apply_patch` failure.",
    );
    expect(draggedBulletClipboard.html).toContain(
      '- First issue',
    );

    await selectAssistantListItemFromMarker(page, "ol", "Sixth item", "Sixth item");
    await copySelection(page);

    const draggedNumberClipboard = await readRichClipboard(page);
    expect(draggedNumberClipboard.plainText).toBe("6. Sixth item");
    expect(draggedNumberClipboard.html).toContain("6. Sixth item");

    await selectAssistantText(page, "docs");
    await copySelection(page);

    const titledLinkClipboard = await readRichClipboard(page);
    expect(titledLinkClipboard.plainText).toBe("docs");
    expect(titledLinkClipboard.html).not.toContain("8. Eighth item
");

    await selectAssistantTextRange(page, "Inner eight", "Inner nine");
    await copySelection(page);

    const nestedListClipboard = await readRichClipboard(page);
    expect(nestedListClipboard.plainText).toBe("Inner eight\n\n9. Inner nine");
    expect(nestedListClipboard.html).toContain("9. Inner nine");

    await selectAssistantTextRange(page, "Seventh item", "Nested list:");
    await copySelection(page);

    const crossBlockClipboard = await readRichClipboard(page);
    expect(crossBlockClipboard.plainText).toBe("Seventh item\n\n8. Eighth item\n\nNested list:");
    expect(crossBlockClipboard.html).toContain("8. Eighth item");

    await selectAssistantText(page, "Current");
    await copySelection(page);

    const partialTableClipboard = await readRichClipboard(page);
    expect(partialTableClipboard.plainText).toBe("Current");
    expect(partialTableClipboard.html).toContain("Current");
    expect(partialTableClipboard.html).not.toContain("<table");

    await selectAssistantTextRange(page, "Right", "ready");
    await copySelection(page);

    const columnSliceClipboard = await readRichClipboard(page);
    expect(columnSliceClipboard.plainText).toContain("ready");
    expect(columnSliceClipboard.html).not.toContain("Current | active Left Right Center
");
    expect(columnSliceClipboard.html).toContain("ready");
    expect(columnSliceClipboard.html).toContain("obsolete");

    // A partial selection loses its `pre` wrapper, so the code reaches Turndown as
    // prose unless it is diverted first: the line break and the indentation go, and
    // Markdown-significant characters get escaped.
    await selectAssistantAcrossCodeLines(page, "const", "return");
    await copySelection(page);

    const codeLinesClipboard = await readRichClipboard(page);
    expect(codeLinesClipboard.plainText).toBe('const answer = "yes";\n  return');
    expect(codeLinesClipboard.html).toContain('');

    // Selecting inside code expresses an intent to copy code, even when the selection
    // contains every character in the block.
    await selectAssistantElement(
      page,
      '[data-paseo-markdown-language="typescript"] [data-paseo-markdown-tag="code"]',
    );
    await copySelection(page);

    const completeCodeClipboard = await readRichClipboard(page);
    expect(completeCodeClipboard.plainText).toBe('const answer = "yes";\n  return answer;');

    // Touching the block before it without selecting any of its text is still a
    // selection inside the code.
    await selectAssistantElementFromEndOf(
      page,
      "not a generated link.",
      '[data-paseo-markdown-language="typescript"] [data-paseo-markdown-tag="code"]',
    );
    await copySelection(page);

    expect((await readRichClipboard(page)).plainText).toBe(
      'const answer = "yes";\n  return answer;',
    );

    // Crossing the block boundary expresses an intent to carry its Markdown structure.
    await selectAssistantAcrossCodeLines(page, "const", "After code.");
    await copySelection(page);

    const crossedCodeClipboard = await readRichClipboard(page);
    expect(crossedCodeClipboard.plainText).toBe(
      '```typescript\nconst answer = "yes";\n  return answer;\n```\n\nAfter code.',
    );

    // Selecting a whole line runs off its end into the newline node. A trailing
    // newline auto-executes the line when it is pasted into a terminal.
    await selectAssistantAcrossCodeLines(page, "const", "  ");
    await copySelection(page);

    expect((await readRichClipboard(page)).plainText).toBe('const answer = "yes";');

    // The block's own Copy button had the same hazard: a Markdown fence body ends in
    // a newline, and the button copied it raw.
    const typescriptFence = assistantMessage.locator('[data-paseo-markdown-language="typescript"]');
    // The button is opacity 0 / pointerEvents none until the fence is hovered.
    await typescriptFence.hover();
    await typescriptFence.locator("[data-paseo-markdown-ignore]").click();

    expect(await readPlainClipboard(page)).toBe('const answer = "yes";\n  return answer;');

    // A blank line before the closing fence leaves the body ending in two newlines,
    // so stripping only the terminal one still hands the terminal an executable line.
    const bashFence = assistantMessage.locator('[data-paseo-markdown-language="bash"]');
    await bashFence.hover();
    await bashFence.locator("[data-paseo-markdown-ignore]").click();

    expect(await readPlainClipboard(page)).toBe("echo trailing");
  } finally {
    await agent.cleanup();
  }
});

test("copying a selection across an assistant image keeps its Markdown source and alt text", async ({
  context,
  page,
}) => {
  const image =
    "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==";
  const agent = await seedMockAgentWorkspace({
    repoPrefix: "assistant-selection-copy-image-",
    title: "Assistant selection copy image",
    initialPrompt: "Render the image fixture.",
    featureValues: {
      mockAssistantResponse: [
        "Before the image.",
        "",
        `![chart](${image})`,
        "",
        "After the image.",
      ].join("\n"),
    },
  });

  try {
    await allowRichClipboard(context);
    await agent.client.waitForAgentUpsert(
      agent.agentId,
      (snapshot) => snapshot.status === "idle",
      30_000,
    );
    await openAgentRoute(page, agent);
    await expect(assistantMessageBlocks(page).locator("img")).toHaveCount(1);

    await selectAssistantTextRange(page, "Before the image.", "After the image.");
    await copySelection(page);

    expect((await readRichClipboard(page)).plainText).toBe(
      `Before the image.\n\n![chart](${image})\n\nAfter the image.`,
    );

    await selectAssistantImage(page);
    await copySelection(page);

    expect((await readRichClipboard(page)).plainText).toBe(`![chart](${image})`);

    await dragFromBelowImageTo(page, "After the");
    await copySelection(page);

    expect((await readRichClipboard(page)).plainText).toBe("After the");
  } finally {
    await agent.cleanup();
  }
});