Skip to content

The open-source app everyone uses to manage agents at work

feat(artifacts): bridge Markdown work products into the document review surface (#11822)

Michael Nguyen0fa318b8daee
diff --git a/packages/shared/src/index.ts b/packages/shared/src/index.ts
index 5ce9d5ba9e..7c244e5b88 100644
--- a/packages/shared/src/index.ts
+++ b/packages/shared/src/index.ts
@@ -84,6 +84,19 @@ export {
type ResponsibleUserSource,
type OriginatingActor,
} from "./issue-attribution.js";
+export {
+ ARTIFACT_REVIEW_DOCUMENT_KEY_PREFIX,
+ MARKDOWN_ATTACHMENT_CONTENT_TYPES,
+ MARKDOWN_REVIEW_DOCUMENT_MAX_BYTES,
+ artifactReviewDocumentKey,
+ getAttachmentArtifactWorkProductMetadata,
+ getMarkdownWorkProductAttachmentMetadata,
+ isArtifactReviewDocumentKey,
+ isMarkdownArtifactWorkProduct,
+ isMarkdownAttachmentContent,
+ workProductIdFromArtifactReviewDocumentKey,
+ type AttachmentArtifactWorkProductLike,
+} from "./markdown-work-products.js";
export {
ISSUE_WRITE_DENIAL_CODES,
describeIssueWriteDenial,
diff --git a/packages/shared/src/markdown-work-products.test.ts b/packages/shared/src/markdown-work-products.test.ts
new file mode 100644
index 0000000000..7293d14ad4
--- /dev/null
+++ b/packages/shared/src/markdown-work-products.test.ts
@@ -0,0 +1,178 @@
+import { describe, expect, it } from "vitest";
+import {
+ ARTIFACT_REVIEW_DOCUMENT_KEY_PREFIX,
+ artifactReviewDocumentKey,
+ getAttachmentArtifactWorkProductMetadata,
+ getMarkdownWorkProductAttachmentMetadata,
+ isArtifactReviewDocumentKey,
+ isMarkdownArtifactWorkProduct,
+ isMarkdownAttachmentContent,
+ workProductIdFromArtifactReviewDocumentKey,
+} from "./markdown-work-products.js";
+
+const ATTACHMENT_ID = "00000000-0000-4000-8000-000000000001";
+const WORK_PRODUCT_ID = "11111111-2222-4333-8444-555555555555";
+
+function attachmentMetadata(overrides: Record<string, unknown> = {}) {
+ const contentPath = `/api/attachments/${ATTACHMENT_ID}/content`;
+ return {
+ attachmentId: ATTACHMENT_ID,
+ contentType: "text/markdown",
+ byteSize: 128,
+ contentPath,
+ openPath: contentPath,
+ downloadPath: `${contentPath}?download=1`,
+ originalFilename: "notes.md",
+ ...overrides,
+ };
+}
+
+function workProduct(overrides: Record<string, unknown> = {}) {
+ return {
+ type: "artifact" as const,
+ provider: "paperclip",
+ metadata: attachmentMetadata(),
+ ...overrides,
+ };
+}
+
+describe("isMarkdownAttachmentContent", () => {
+ it.each([
+ "text/markdown",
+ "text/x-markdown",
+ "application/markdown",
+ "application/x-markdown",
+ ])("accepts %s regardless of filename", (contentType) => {
+ expect(isMarkdownAttachmentContent({ contentType, originalFilename: null })).toBe(true);
+ });
+
+ it("ignores MIME parameters and case", () => {
+ expect(
+ isMarkdownAttachmentContent({
+ contentType: "Text/Markdown; charset=utf-8",
+ originalFilename: null,
+ }),
+ ).toBe(true);
+ });
+
+ it.each([
+ "text/plain",
+ "application/octet-stream",
+ "binary/octet-stream",
+ "application/x-binary",
+ ])("accepts a .md filename when the content type is %s", (contentType) => {
+ expect(isMarkdownAttachmentContent({ contentType, originalFilename: "README.md" })).toBe(true);
+ });
+
+ it("accepts a .markdown filename with a generic content type", () => {
+ expect(
+ isMarkdownAttachmentContent({
+ contentType: "application/octet-stream",
+ originalFilename: "guide.markdown",
+ }),
+ ).toBe(true);
+ });
+
+ it("rejects .mdx files", () => {
+ expect(
+ isMarkdownAttachmentContent({
+ contentType: "application/octet-stream",
+ originalFilename: "page.mdx",
+ }),
+ ).toBe(false);
+ expect(
+ isMarkdownAttachmentContent({ contentType: "text/plain", originalFilename: "page.mdx" }),
+ ).toBe(false);
+ });
+
+ it("rejects markdown filenames with non-generic content types", () => {
+ expect(
+ isMarkdownAttachmentContent({ contentType: "text/html", originalFilename: "notes.md" }),
+ ).toBe(false);
+ });
+
+ it("rejects non-markdown filenames with generic content types", () => {
+ expect(
+ isMarkdownAttachmentContent({ contentType: "text/plain", originalFilename: "notes.txt" }),
+ ).toBe(false);
+ });
+
+ it("rejects a missing content type", () => {
+ expect(isMarkdownAttachmentContent({ contentType: null, originalFilename: "notes.md" })).toBe(
+ false,
+ );
+ });
+});
+
+describe("getAttachmentArtifactWorkProductMetadata", () => {
+ it("returns canonical metadata for a valid paperclip artifact work product", () => {
+ const metadata = getAttachmentArtifactWorkProductMetadata(workProduct());
+ expect(metadata?.attachmentId).toBe(ATTACHMENT_ID);
+ });
+
+ it("returns null for non-artifact work products", () => {
+ expect(getAttachmentArtifactWorkProductMetadata(workProduct({ type: "document" }))).toBeNull();
+ });
+
+ it("returns null for non-paperclip providers", () => {
+ expect(getAttachmentArtifactWorkProductMetadata(workProduct({ provider: "github" }))).toBeNull();
+ });
+
+ it("returns null when metadata is missing or non-canonical", () => {
+ expect(getAttachmentArtifactWorkProductMetadata(workProduct({ metadata: null }))).toBeNull();
+ expect(
+ getAttachmentArtifactWorkProductMetadata(
+ workProduct({
+ metadata: attachmentMetadata({ openPath: "https://evil.example/content" }),
+ }),
+ ),
+ ).toBeNull();
+ });
+});
+
+describe("getMarkdownWorkProductAttachmentMetadata", () => {
+ it("returns metadata only when the attachment is markdown-eligible", () => {
+ expect(getMarkdownWorkProductAttachmentMetadata(workProduct())).not.toBeNull();
+ expect(
+ getMarkdownWorkProductAttachmentMetadata(
+ workProduct({
+ metadata: attachmentMetadata({ contentType: "application/pdf", originalFilename: "a.pdf" }),
+ }),
+ ),
+ ).toBeNull();
+ });
+
+ it("backs the boolean eligibility helper", () => {
+ expect(isMarkdownArtifactWorkProduct(workProduct())).toBe(true);
+ expect(
+ isMarkdownArtifactWorkProduct(
+ workProduct({
+ metadata: attachmentMetadata({ contentType: "image/png", originalFilename: "a.png" }),
+ }),
+ ),
+ ).toBe(false);
+ });
+});
+
+describe("artifact review document keys", () => {
+ it("builds a deterministic key that fits the 64-character document key limit", () => {
+ const key = artifactReviewDocumentKey(WORK_PRODUCT_ID);
+ expect(key).toBe(`artifact-review-${WORK_PRODUCT_ID}`);
+ expect(key.length).toBeLessThanOrEqual(64);
+ expect(key).toMatch(/^[a-z0-9][a-z0-9_-]*$/);
+ });
+
+ it("identifies proxy review-document keys", () => {
+ expect(isArtifactReviewDocumentKey(artifactReviewDocumentKey(WORK_PRODUCT_ID))).toBe(true);
+ expect(isArtifactReviewDocumentKey("plan")).toBe(false);
+ expect(isArtifactReviewDocumentKey("notes")).toBe(false);
+ expect(isArtifactReviewDocumentKey(ARTIFACT_REVIEW_DOCUMENT_KEY_PREFIX)).toBe(false);
+ });
+
+ it("round-trips the work product id", () => {
+ expect(
+ workProductIdFromArtifactReviewDocumentKey(artifactReviewDocumentKey(WORK_PRODUCT_ID)),
+ ).toBe(WORK_PRODUCT_ID);
+ expect(workProductIdFromArtifactReviewDocumentKey("plan")).toBeNull();
+ });
+});
diff --git a/packages/shared/src/markdown-work-products.ts b/packages/shared/src/markdown-work-products.ts
new file mode 100644
index 0000000000..16a88cfb71
--- /dev/null
+++ b/packages/shared/src/markdown-work-products.ts
@@ -0,0 +1,99 @@
+import type {
+ AttachmentArtifactWorkProductMetadata,
+ IssueWorkProduct,
+} from "./types/work-product.js";
+import { attachmentArtifactWorkProductMetadataSchema } from "./validators/work-product.js";
+
+/**
+ * Shared classification for bridging attachment-backed Markdown work products
+ * into the issue document review experience. Server materialization and UI
+ * presentation must agree on eligibility, so both sides use these helpers.
+ */
+
+export const MARKDOWN_ATTACHMENT_CONTENT_TYPES = [
+ "text/markdown",
+ "text/x-markdown",
+ "application/markdown",
+ "application/x-markdown",
+] as const;
+
+const MARKDOWN_ATTACHMENT_CONTENT_TYPE_SET = new Set<string>(MARKDOWN_ATTACHMENT_CONTENT_TYPES);
+
+const MARKDOWN_FALLBACK_CONTENT_TYPES = new Set([
+ "text/plain",
+ "application/octet-stream",
+ "binary/octet-stream",
+ "application/x-binary",
+]);
+
+const MARKDOWN_FILENAME_EXTENSIONS = [".md", ".markdown"];
+
+/**
+ * Maximum attachment size eligible for review-document materialization.
+ * Matches the issue-document body limit: a UTF-8 payload of at most this many
+ * bytes always fits the 524288-character body cap.
+ */
+export const MARKDOWN_REVIEW_DOCUMENT_MAX_BYTES = 512 * 1024;
+
+export const ARTIFACT_REVIEW_DOCUMENT_KEY_PREFIX = "artifact-review-";
+
+function normalizeAttachmentContentType(contentType: string | null | undefined): string {
+ return (contentType ?? "").toLowerCase().split(";")[0]?.trim() ?? "";
+}
+
+export function isMarkdownAttachmentContent(input: {
+ contentType: string | null | undefined;
+ originalFilename?: string | null;
+}): boolean {
+ const contentType = normalizeAttachmentContentType(input.contentType);
+ if (MARKDOWN_ATTACHMENT_CONTENT_TYPE_SET.has(contentType)) return true;
+ const filename = (input.originalFilename ?? "").toLowerCase();
+ if (!MARKDOWN_FILENAME_EXTENSIONS.some((extension) => filename.endsWith(extension))) {
+ return false;
+ }
+ return MARKDOWN_FALLBACK_CONTENT_TYPES.has(contentType);
+}
+
+export type AttachmentArtifactWorkProductLike = Pick<
+ IssueWorkProduct,
+ "type" | "provider" | "metadata"
+>;
+
+export function getAttachmentArtifactWorkProductMetadata(
+ workProduct: AttachmentArtifactWorkProductLike,
+): AttachmentArtifactWorkProductMetadata | null {
+ if (workProduct.type !== "artifact" || workProduct.provider !== "paperclip") return null;
+ if (!workProduct.metadata) return null;
+ const parsed = attachmentArtifactWorkProductMetadataSchema.safeParse(workProduct.metadata);
+ return parsed.success ? parsed.data : null;
+}
+
+export function getMarkdownWorkProductAttachmentMetadata(
+ workProduct: AttachmentArtifactWorkProductLike,
+): AttachmentArtifactWorkProductMetadata | null {
+ const metadata = getAttachmentArtifactWorkProductMetadata(workProduct);
+ if (!metadata) return null;
+ return isMarkdownAttachmentContent(metadata) ? metadata : null;
+}
+
+export function isMarkdownArtifactWorkProduct(
+ workProduct: AttachmentArtifactWorkProductLike,
+): boolean {
+ return getMarkdownWorkProductAttachmentMetadata(workProduct) !== null;
+}
+
+export function artifactReviewDocumentKey(workProductId: string): string {
+ return `${ARTIFACT_REVIEW_DOCUMENT_KEY_PREFIX}${workProductId}`;
+}
+
+export function isArtifactReviewDocumentKey(key: string): boolean {
+ return (
+ key.startsWith(ARTIFACT_REVIEW_DOCUMENT_KEY_PREFIX) &&
+ key.length > ARTIFACT_REVIEW_DOCUMENT_KEY_PREFIX.length
+ );
+}
+
+export function workProductIdFromArtifactReviewDocumentKey(key: string): string | null {
+ if (!isArtifactReviewDocumentKey(key)) return null;
+ return key.slice(ARTIFACT_REVIEW_DOCUMENT_KEY_PREFIX.length);
+}
diff --git a/server/src/__tests__/artifact-review-document-routes.test.ts b/server/src/__tests__/artifact-review-document-routes.test.ts
new file mode 100644
index 0000000000..21dd1ae60f
--- /dev/null
+++ b/server/src/__tests__/artifact-review-document-routes.test.ts
@@ -0,0 +1,334 @@
+import express from "express";
+import request from "supertest";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { StorageService } from "../storage/types.js";
+
+const ISSUE_ID = "11111111-1111-4111-8111-111111111111";
+const WORK_PRODUCT_ID = "22222222-2222-4222-8222-222222222222";
+
+const mockIssueService = vi.hoisted(() => ({
+ getById: vi.fn(),
+ getByIdentifier: vi.fn(),
+ getAttachmentById: vi.fn(),
+}));
+const mockCompanyService = vi.hoisted(() => ({
+ getById: vi.fn(),
+}));
+const mockWorkProductService = vi.hoisted(() => ({
+ createForIssue: vi.fn(),
+ getById: vi.fn(),
+ update: vi.fn(),
+}));
+const mockAccessService = vi.hoisted(() => ({
+ decide: vi.fn(async () => ({
+ allowed: true,
+ explanation: "Allowed by test mock",
+ })),
+ canUser: vi.fn(),
+ hasPermission: vi.fn(),
+}));
+const mockLogActivity = vi.hoisted(() => vi.fn(async () => undefined));
+const mockEnsureForWorkProduct = vi.hoisted(() => vi.fn());
+const mockSyncDocumentSafely = vi.hoisted(() => vi.fn(async () => undefined));
+
+function registerRouteMocks() {
+ vi.doMock("@paperclipai/shared/telemetry", () => ({
+ trackAgentTaskCompleted: vi.fn(),
+ trackErrorHandlerCrash: vi.fn(),
+ }));
+
+ vi.doMock("../telemetry.js", () => ({
+ getTelemetryClient: vi.fn(() => ({ track: vi.fn() })),
+ }));
+
+ vi.doMock("../services/issues.js", () => ({
+ issueService: () => mockIssueService,
+ }));
+
+ vi.doMock("../services/activity-log.js", () => ({
+ logActivity: mockLogActivity,
+ }));
+
+ vi.doMock("../services/artifact-review-documents.js", () => ({
+ artifactReviewDocumentService: () => ({
+ ensureForWorkProduct: mockEnsureForWorkProduct,
+ }),
+ }));
+
+ vi.doMock("../services/external-objects.js", () => ({
+ externalObjectService: () => ({
+ syncDocumentSafely: mockSyncDocumentSafely,
+ }),
+ }));
+
+ vi.doMock("../services/index.js", () => ({
+ accessService: () => mockAccessService,
+ agentService: () => ({
+ getById: vi.fn(),
+ }),
+ companySkillService: () => ({}),
+ companyService: () => mockCompanyService,
+ documentAnnotationService: () => ({ remapOpenThreadsForDocument: async () => [] }),
+ documentService: () => ({}),
+ executionWorkspaceService: () => ({}),
+ feedbackService: () => ({
+ listIssueVotesForUser: vi.fn(async () => []),
+ saveIssueVote: vi.fn(async () => ({ vote: null, consentEnabledNow: false, sharingEnabled: false })),
+ }),
+ goalService: () => ({}),
+ heartbeatService: () => ({
+ wakeup: vi.fn(async () => undefined),
+ reportRunActivity: vi.fn(async () => undefined),
+ getRun: vi.fn(async () => null),
+ getActiveRunForAgent: vi.fn(async () => null),
+ cancelRun: vi.fn(async () => null),
+ }),
+ instanceSettingsService: () => ({
+ get: vi.fn(async () => ({
+ id: "instance-settings-1",
+ general: {
+ censorUsernameInLogs: false,
+ feedbackDataSharingPreference: "prompt",
+ },
+ })),
+ listCompanyIds: vi.fn(async () => ["company-1"]),
+ }),
+ issueApprovalService: () => ({}),
+ issueReferenceService: () => ({
+ deleteDocumentSource: async () => undefined,
+ diffIssueReferenceSummary: () => ({
+ addedReferencedIssues: [],
+ removedReferencedIssues: [],
+ currentReferencedIssues: [],
+ }),
+ emptySummary: () => ({ outbound: [], inbound: [] }),
+ listIssueReferenceSummary: async () => ({ outbound: [], inbound: [] }),
+ syncComment: async () => undefined,
+ syncDocument: async () => undefined,
+ syncIssue: async () => undefined,
+ }),
+ issueThreadInteractionService: () => ({
+ listForIssue: vi.fn(async () => []),
+ expireRequestConfirmationsSupersededByComment: vi.fn(async () => []),
+ expireStaleRequestConfirmationsForIssueDocument: vi.fn(async () => []),
+ }),
+ issueRecoveryActionService: () => ({
+ getActiveForIssue: vi.fn(async () => null),
+ listActiveForIssues: vi.fn(async () => new Map()),
+ }),
+ issueService: () => mockIssueService,
+ logActivity: mockLogActivity,
+ projectService: () => ({}),
+ routineService: () => ({
+ syncRunStatusForIssue: vi.fn(async () => undefined),
+ }),
+ workProductService: () => mockWorkProductService,
+ }));
+}
+
+function createStorageService(): StorageService {
+ return {
+ provider: "local_disk",
+ putFile: vi.fn(),
+ getObject: vi.fn(),
+ headObject: vi.fn(),
+ deleteObject: vi.fn(),
+ } as unknown as StorageService;
+}
+
+async function createApp(options?: { companyIds?: string[] }) {
+ const [{ errorHandler }, { issueRoutes }] = await Promise.all([
+ vi.importActual<typeof import("../middleware/index.js")>("../middleware/index.js"),
+ vi.importActual<typeof import("../routes/issues.js")>("../routes/issues.js"),
+ ]);
+ const app = express();
+ app.use(express.json());
+ app.use((req, _res, next) => {
+ (req as any).actor = {
+ type: "board",
+ userId: "local-board",
+ companyIds: options?.companyIds ?? ["company-1"],
+ source: "local_implicit",
+ isInstanceAdmin: false,
+ };
+ next();
+ });
+ app.use("/api", issueRoutes({} as any, createStorageService()));
+ app.use(errorHandler);
+ return app;
+}
+
+function makeIssue() {
+ return {
+ id: ISSUE_ID,
+ companyId: "company-1",
+ identifier: "PAP-1",
+ projectId: null,
+ status: "in_progress",
+ assigneeAgentId: null,
+ };
+}
+
+function makeWorkProduct(overrides: Record<string, unknown> = {}) {
+ const attachmentId = "55555555-5555-4555-8555-555555555555";
+ const contentPath = `/api/attachments/${attachmentId}/content`;
+ return {
+ id: WORK_PRODUCT_ID,
+ companyId: "company-1",
+ issueId: ISSUE_ID,
+ type: "artifact",
+ provider: "paperclip",
+ title: "Verification report",
+ metadata: {
+ attachmentId,
+ contentType: "text/markdown",
+ byteSize: 128,
+ contentPath,
+ openPath: contentPath,
+ downloadPath: `${contentPath}?download=1`,
+ originalFilename: "verification-report.md",
+ },
+ createdByRunId: null,
+ sourceTrust: null,
+ ...overrides,
+ };
+}
+
+function makeDocument(overrides: Record<string, unknown> = {}) {
+ return {
+ id: "33333333-3333-4333-8333-333333333333",
+ companyId: "company-1",
+ issueId: ISSUE_ID,
+ key: `artifact-review-${WORK_PRODUCT_ID}`,
+ title: "Verification report",
+ format: "markdown",
+ body: "# Report",
+ latestRevisionId: "44444444-4444-4444-8444-444444444444",
+ latestRevisionNumber: 1,
+ ...overrides,
+ };
+}
+
+describe("work product review-document route", () => {
+ beforeEach(() => {
+ vi.resetModules();
+ vi.clearAllMocks();
+ registerRouteMocks();
+ mockIssueService.getById.mockResolvedValue(makeIssue());
+ mockWorkProductService.getById.mockResolvedValue(makeWorkProduct());
+ });
+
+ it("returns 404 when the work product belongs to another issue", async () => {
+ mockWorkProductService.getById.mockResolvedValue(
+ makeWorkProduct({ issueId: "55555555-5555-4555-8555-555555555555" }),
+ );
+
+ const app = await createApp();
+ const res = await request(app).post(
+ `/api/issues/${ISSUE_ID}/work-products/${WORK_PRODUCT_ID}/review-document`,
+ );
+
+ expect(res.status).toBe(404);
+ expect(mockEnsureForWorkProduct).not.toHaveBeenCalled();
+ });
+
+ it("returns 404 when the work product does not exist", async () => {
+ mockWorkProductService.getById.mockResolvedValue(null);
+
+ const app = await createApp();
+ const res = await request(app).post(
+ `/api/issues/${ISSUE_ID}/work-products/${WORK_PRODUCT_ID}/review-document`,
+ );
+
+ expect(res.status).toBe(404);
+ expect(mockEnsureForWorkProduct).not.toHaveBeenCalled();
+ });
+
+ it("materializes the review document and logs document creation", async () => {
+ mockEnsureForWorkProduct.mockResolvedValue({
+ document: makeDocument(),
+ created: true,
+ revisionChanged: true,
+ remappedAnnotations: [],
+ });
+
+ const app = await createApp();
+ const res = await request(app).post(
+ `/api/issues/${ISSUE_ID}/work-products/${WORK_PRODUCT_ID}/review-document`,
+ );
+
+ expect(res.status).toBe(201);
+ expect(res.body.key).toBe(`artifact-review-${WORK_PRODUCT_ID}`);
+ expect(mockEnsureForWorkProduct).toHaveBeenCalledWith({
+ issue: { id: ISSUE_ID, companyId: "company-1" },
+ workProduct: expect.objectContaining({ id: WORK_PRODUCT_ID }),
+ });
+ expect(mockLogActivity).toHaveBeenCalledWith(
+ expect.anything(),
+ expect.objectContaining({
+ action: "issue.document_created",
+ details: expect.objectContaining({
+ workProductId: WORK_PRODUCT_ID,
+ artifactReviewDocument: true,
+ }),
+ }),
+ );
+ expect(mockSyncDocumentSafely).toHaveBeenCalledWith(makeDocument().id);
+ });
+
+ it("returns 200 without side effects when the document is already current", async () => {
+ mockEnsureForWorkProduct.mockResolvedValue({
+ document: makeDocument(),
+ created: false,
+ revisionChanged: false,
+ remappedAnnotations: [],
+ });
+
+ const app = await createApp();
+ const res = await request(app).post(
+ `/api/issues/${ISSUE_ID}/work-products/${WORK_PRODUCT_ID}/review-document`,
+ );
+
+ expect(res.status).toBe(200);
+ expect(res.body.id).toBe(makeDocument().id);
+ expect(mockLogActivity).not.toHaveBeenCalled();
+ expect(mockSyncDocumentSafely).not.toHaveBeenCalled();
+ });
+
+ it("passes typed materialization errors through to the response", async () => {
+ const { HttpError } = await vi.importActual<typeof import("../errors.js")>("../errors.js");
+ mockEnsureForWorkProduct.mockRejectedValue(
+ new HttpError(415, "Work product attachment is not Markdown"),
+ );
+
+ const app = await createApp();
+ const res = await request(app).post(
+ `/api/issues/${ISSUE_ID}/work-products/${WORK_PRODUCT_ID}/review-document`,
+ );
+
+ expect(res.status).toBe(415);
+ expect(res.body.error).toBe("Work product attachment is not Markdown");
+ });
+
+ it("resynchronizes an eligible review document after a title-only work product update", async () => {
+ const renamed = makeWorkProduct({ title: "Renamed verification report" });
+ mockWorkProductService.update.mockResolvedValue(renamed);
+ mockEnsureForWorkProduct.mockResolvedValue({
+ document: makeDocument({ title: "Renamed verification report", latestRevisionNumber: 2 }),
+ created: false,
+ revisionChanged: true,
+ remappedAnnotations: [],
+ });
+
+ const app = await createApp();
+ const res = await request(app)
+ .patch(`/api/work-products/${WORK_PRODUCT_ID}`)
+ .send({ title: "Renamed verification report" });
+
+ expect(res.status).toBe(200);
+ expect(mockEnsureForWorkProduct).toHaveBeenCalledWith({
+ issue: { id: ISSUE_ID, companyId: "company-1" },
+ workProduct: renamed,
+ });
+ });
+});
diff --git a/server/src/__tests__/artifact-review-documents-service.test.ts b/server/src/__tests__/artifact-review-documents-service.test.ts
new file mode 100644
index 0000000000..01dc766af4
--- /dev/null
+++ b/server/src/__tests__/artifact-review-documents-service.test.ts
@@ -0,0 +1,403 @@
+import { randomUUID } from "node:crypto";
+import { Readable } from "node:stream";
+import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from "vitest";
+import {
+ agents,
+ assets,
+ companies,
+ createDb,
+ documentRevisions,
+ documents,
+ heartbeatRuns,
+ issueAttachments,
+ issueDocuments,
+ issues,
+} from "@paperclipai/db";
+import { artifactReviewDocumentKey } from "@paperclipai/shared";
+import {
+ getEmbeddedPostgresTestSupport,
+ startEmbeddedPostgresTestDatabase,
+} from "./helpers/embedded-postgres.js";
+import { artifactReviewDocumentService } from "../services/artifact-review-documents.js";
+import { documentService } from "../services/documents.js";
+import { HttpError } from "../errors.js";
+import type { StorageService } from "../storage/types.js";
+
+const embeddedPostgresSupport = await getEmbeddedPostgresTestSupport();
+const describeEmbeddedPostgres = embeddedPostgresSupport.supported ? describe : describe.skip;
+
+if (!embeddedPostgresSupport.supported) {
+ console.warn(
+ `Skipping embedded Postgres artifact review document tests on this host: ${embeddedPostgresSupport.reason ?? "unsupported environment"}`,
+ );
+}
+
+function createStorageService(files: Record<string, Buffer> = {}): StorageService {
+ return {
+ provider: "local_disk",
+ putFile: vi.fn(),
+ getObject: vi.fn(async (_companyId, objectKey, options) => {
+ const body = files[objectKey] ?? Buffer.alloc(0);
+ const range = options?.range;
+ const ranged = range ? body.subarray(range.start, range.end + 1) : body;
+ return {
+ stream: Readable.from(ranged),
+ contentType: "text/markdown",
+ contentLength: ranged.length,
+ };
+ }),
+ headObject: vi.fn(),
+ deleteObject: vi.fn(),
+ };
+}
+
+describeEmbeddedPostgres("artifactReviewDocumentService", () => {
+ let tempDb: Awaited<ReturnType<typeof startEmbeddedPostgresTestDatabase>> | null = null;
+ let db!: ReturnType<typeof createDb>;
+
+ beforeAll(async () => {
+ tempDb = await startEmbeddedPostgresTestDatabase("paperclip-artifact-review-docs-");
+ db = createDb(tempDb.connectionString);
+ }, 20_000);
+
+ afterEach(async () => {
+ await db.delete(documentRevisions);
+ await db.delete(issueDocuments);
+ await db.delete(documents);
+ await db.delete(issueAttachments);
+ await db.delete(assets);
+ await db.delete(issues);
+ await db.delete(heartbeatRuns);
+ await db.delete(agents);
+ await db.delete(companies);
+ });
+
+ afterAll(async () => {
+ await tempDb?.cleanup();
+ });
+
+ async function seedFixture(options: {
+ body?: Buffer;
+ contentType?: string;
+ originalFilename?: string | null;
+ byteSize?: number;
+ } = {}) {
+ const companyId = randomUUID();
+ const issueId = randomUUID();
+ const agentId = randomUUID();
+ const assetId = randomUUID();
+ const attachmentId = randomUUID();
+ const workProductId = randomUUID();
+ const body = options.body ?? Buffer.from("# Report\n\nHello **markdown**.\n", "utf8");
+ const contentType = options.contentType ?? "text/markdown";
+ const originalFilename = options.originalFilename === undefined ? "report.md" : options.originalFilename;
+ const objectKey = `issues/${issueId}/${assetId}`;
+
+ await db.insert(companies).values({
+ id: companyId,
+ name: "Paperclip",
+ issuePrefix: `T${companyId.replace(/-/g, "").slice(0, 6).toUpperCase()}`,
+ requireBoardApprovalForNewAgents: false,
+ });
+ await db.insert(issues).values({
+ id: issueId,
+ companyId,
+ identifier: "PAP-1534",
+ title: "Bridge markdown work products",
+ description: null,
+ status: "in_progress",
+ priority: "medium",
+ });
+ await db.insert(agents).values({
+ id: agentId,
+ companyId,
+ name: "ReportWriter",
+ role: "engineer",
+ status: "idle",
+ adapterType: "codex_local",
+ adapterConfig: {},
+ runtimeConfig: {},
+ permissions: {},
+ });
+ await db.insert(assets).values({
+ id: assetId,
+ companyId,
+ provider: "local_disk",
+ objectKey,
+ contentType,
+ byteSize: options.byteSize ?? body.length,
+ sha256: `sha256-${assetId}`,
+ originalFilename,
+ createdByAgentId: agentId,
+ });
+ await db.insert(issueAttachments).values({
+ id: attachmentId,
+ companyId,
+ issueId,
+ assetId,
+ });
+
+ const contentPath = `/api/attachments/${attachmentId}/content`;
+ const workProduct = {
+ id: workProductId,
+ companyId,
+ issueId,
+ type: "artifact" as const,
+ provider: "paperclip",
+ metadata: {
+ attachmentId,
+ contentType,
+ byteSize: options.byteSize ?? body.length,
+ contentPath,
+ openPath: contentPath,
+ downloadPath: `${contentPath}?download=1`,
+ originalFilename,
+ },
+ title: "Verification report",
+ createdByRunId: null,
+ sourceTrust: null,
+ };
+
+ const files: Record<string, Buffer> = { [objectKey]: body };
+ const storage = createStorageService(files);
+ const svc = artifactReviewDocumentService(db, storage);
+ return { companyId, issueId, agentId, assetId, attachmentId, workProduct, files, objectKey, svc };
+ }
+
+ it("materializes a review document with promoted attribution", async () => {
+ const fixture = await seedFixture();
+ const result = await fixture.svc.ensureForWorkProduct({
+ issue: { id: fixture.issueId, companyId: fixture.companyId },
+ workProduct: fixture.workProduct,
+ });
+
+ expect(result.created).toBe(true);
+ expect(result.revisionChanged).toBe(true);
+ expect(result.document.key).toBe(artifactReviewDocumentKey(fixture.workProduct.id));
+ expect(result.document.title).toBe("Verification report");
+ expect(result.document.latestRevisionNumber).toBe(1);
+ expect(result.document.latestRevisionId).toBeTruthy();
+ expect(result.document.body).toBe("# Report\n\nHello **markdown**.\n");
+ expect(result.document.createdByAgentId).toBe(fixture.agentId);
+ expect(result.document.createdByUserId).toBeNull();
+
+ const listed = await documentService(db).getIssueDocumentByKey(
+ fixture.issueId,
+ artifactReviewDocumentKey(fixture.workProduct.id),
+ );
+ expect(listed?.id).toBe(result.document.id);
+ });
+
+ it("is idempotent for unchanged content", async () => {
+ const fixture = await seedFixture();
+ const first = await fixture.svc.ensureForWorkProduct({
+ issue: { id: fixture.issueId, companyId: fixture.companyId },
+ workProduct: fixture.workProduct,
+ });
+ const second = await fixture.svc.ensureForWorkProduct({
+ issue: { id: fixture.issueId, companyId: fixture.companyId },
+ workProduct: fixture.workProduct,
+ });
+
+ expect(second.created).toBe(false);
+ expect(second.revisionChanged).toBe(false);
+ expect(second.document.id).toBe(first.document.id);
+ expect(second.document.latestRevisionNumber).toBe(1);
+
+ const revisions = await db.select().from(documentRevisions);
+ expect(revisions).toHaveLength(1);
+ });
+
+ it("converges concurrent ensures onto one document", async () => {
+ const fixture = await seedFixture();
+ const input = {
+ issue: { id: fixture.issueId, companyId: fixture.companyId },
+ workProduct: fixture.workProduct,
+ };
+ const [first, second] = await Promise.all([
+ fixture.svc.ensureForWorkProduct(input),
+ fixture.svc.ensureForWorkProduct(input),
+ ]);
+
+ expect(first.document.id).toBe(second.document.id);
+ const links = await db.select().from(issueDocuments);
+ expect(links).toHaveLength(1);
+ const revisions = await db.select().from(documentRevisions);
+ expect(revisions).toHaveLength(1);
+ });
+
+ it("writes a new revision when the attachment content changes", async () => {
+ const fixture = await seedFixture();
+ const first = await fixture.svc.ensureForWorkProduct({
+ issue: { id: fixture.issueId, companyId: fixture.companyId },
+ workProduct: fixture.workProduct,
+ });
+
+ fixture.files[fixture.objectKey] = Buffer.from("# Report v2\n", "utf8");
+ const second = await fixture.svc.ensureForWorkProduct({
+ issue: { id: fixture.issueId, companyId: fixture.companyId },
+ workProduct: fixture.workProduct,
+ });
+
+ expect(second.created).toBe(false);
+ expect(second.revisionChanged).toBe(true);
+ expect(second.document.id).toBe(first.document.id);
+ expect(second.document.latestRevisionNumber).toBe(2);
+ expect(second.document.body).toBe("# Report v2\n");
+ expect(Array.isArray(second.remappedAnnotations)).toBe(true);
+ });
+
+ it("synchronizes title and run provenance when the attachment body is unchanged", async () => {
+ const fixture = await seedFixture();
+ const first = await fixture.svc.ensureForWorkProduct({
+ issue: { id: fixture.issueId, companyId: fixture.companyId },
+ workProduct: fixture.workProduct,
+ });
+
+ const renamed = await fixture.svc.ensureForWorkProduct({
+ issue: { id: fixture.issueId, companyId: fixture.companyId },
+ workProduct: { ...fixture.workProduct, title: "Renamed verification report" },
+ });
+ expect(renamed.created).toBe(false);
+ expect(renamed.revisionChanged).toBe(true);
+ expect(renamed.document.id).toBe(first.document.id);
+ expect(renamed.document.title).toBe("Renamed verification report");
+ expect(renamed.document.latestRevisionNumber).toBe(2);
+
+ const runId = randomUUID();
+ await db.insert(heartbeatRuns).values({
+ id: runId,
+ companyId: fixture.companyId,
+ agentId: fixture.agentId,
+ status: "succeeded",
+ });
+ const reattributed = await fixture.svc.ensureForWorkProduct({
+ issue: { id: fixture.issueId, companyId: fixture.companyId },
+ workProduct: {
+ ...fixture.workProduct,
+ title: "Renamed verification report",
+ createdByRunId: runId,
+ },
+ });
+ expect(reattributed.revisionChanged).toBe(true);
+ expect(reattributed.document.latestRevisionNumber).toBe(3);
+
+ const latestRevision = await db
+ .select()
+ .from(documentRevisions)
+ .then((rows) => rows.find((row) => row.id === reattributed.document.latestRevisionId));
+ expect(latestRevision?.createdByRunId).toBe(runId);
+
+ const unchanged = await fixture.svc.ensureForWorkProduct({
+ issue: { id: fixture.issueId, companyId: fixture.companyId },
+ workProduct: {
+ ...fixture.workProduct,
+ title: "Renamed verification report",
+ createdByRunId: runId,
+ },
+ });
+ expect(unchanged.revisionChanged).toBe(false);
+ expect(unchanged.document.latestRevisionNumber).toBe(3);
+ });
+
+ it("rejects work products that are not attachment-backed Paperclip artifacts", async () => {
+ const fixture = await seedFixture();
+ await expect(
+ fixture.svc.ensureForWorkProduct({
+ issue: { id: fixture.issueId, companyId: fixture.companyId },
+ workProduct: { ...fixture.workProduct, provider: "github" },
+ }),
+ ).rejects.toMatchObject({ status: 422 });
+ await expect(
+ fixture.svc.ensureForWorkProduct({
+ issue: { id: fixture.issueId, companyId: fixture.companyId },
+ workProduct: { ...fixture.workProduct, metadata: { attachmentId: "not-a-uuid" } },
+ }),
+ ).rejects.toMatchObject({ status: 422 });
+ });
+
+ it("rejects non-Markdown attachments with 415", async () => {
+ const fixture = await seedFixture({ contentType: "application/pdf", originalFilename: "report.pdf" });
+ await expect(
+ fixture.svc.ensureForWorkProduct({
+ issue: { id: fixture.issueId, companyId: fixture.companyId },
+ workProduct: fixture.workProduct,
+ }),
+ ).rejects.toMatchObject({ status: 415 });
+ });
+
+ it("rejects mismatched issues and cross-issue attachments", async () => {
+ const fixture = await seedFixture();
+ await expect(
+ fixture.svc.ensureForWorkProduct({
+ issue: { id: randomUUID(), companyId: fixture.companyId },
+ workProduct: fixture.workProduct,
+ }),
+ ).rejects.toMatchObject({ status: 404 });
+
+ const otherIssueId = randomUUID();
+ await db.insert(issues).values({
+ id: otherIssueId,
+ companyId: fixture.companyId,
+ identifier: "PAP-1535",
+ title: "Other issue",
+ description: null,
+ status: "todo",
+ priority: "medium",
+ });
+ await expect(
+ fixture.svc.ensureForWorkProduct({
+ issue: { id: otherIssueId, companyId: fixture.companyId },
+ workProduct: { ...fixture.workProduct, issueId: otherIssueId },
+ }),
+ ).rejects.toMatchObject({ status: 422 });
+ });
+
+ it("rejects oversized attachments with 413", async () => {
+ const fixture = await seedFixture({ byteSize: 512 * 1024 + 1 });
+ await expect(
+ fixture.svc.ensureForWorkProduct({
+ issue: { id: fixture.issueId, companyId: fixture.companyId },
+ workProduct: fixture.workProduct,
+ }),
+ ).rejects.toMatchObject({ status: 413 });
+ });
+
+ it("rejects invalid UTF-8 content with 422", async () => {
+ const fixture = await seedFixture({ body: Buffer.from([0x23, 0x20, 0xff, 0xfe, 0x00]) });
+ await expect(
+ fixture.svc.ensureForWorkProduct({
+ issue: { id: fixture.issueId, companyId: fixture.companyId },
+ workProduct: fixture.workProduct,
+ }),
+ ).rejects.toMatchObject({ status: 422 });
+ });
+
+ it("surfaces a conflict when the review document is locked and content changed", async () => {
+ const fixture = await seedFixture();
+ await fixture.svc.ensureForWorkProduct({
+ issue: { id: fixture.issueId, companyId: fixture.companyId },
+ workProduct: fixture.workProduct,
+ });
+ await documentService(db).lockIssueDocument({
+ issueId: fixture.issueId,
+ key: artifactReviewDocumentKey(fixture.workProduct.id),
+ lockedByUserId: "user-board",
+ });
+
+ // Unchanged content still resolves without a write.
+ const unchanged = await fixture.svc.ensureForWorkProduct({
+ issue: { id: fixture.issueId, companyId: fixture.companyId },
+ workProduct: fixture.workProduct,
+ });
+ expect(unchanged.revisionChanged).toBe(false);
+
+ fixture.files[fixture.objectKey] = Buffer.from("# Locked update\n", "utf8");
+ await expect(
+ fixture.svc.ensureForWorkProduct({
+ issue: { id: fixture.issueId, companyId: fixture.companyId },
+ workProduct: fixture.workProduct,
+ }),
+ ).rejects.toSatisfy((error: unknown) => error instanceof HttpError && error.status === 409);
+ });
+});
diff --git a/server/src/__tests__/issue-attachment-routes.test.ts b/server/src/__tests__/issue-attachment-routes.test.ts
index 2103aa5880..d8f72d1daf 100644
--- a/server/src/__tests__/issue-attachment-routes.test.ts
+++ b/server/src/__tests__/issue-attachment-routes.test.ts
@@ -515,6 +515,36 @@ describe("issue attachment routes", () => {
expect(res.headers["x-content-type-options"]).toBe("nosniff");
});
+ it("declares utf-8 for inline markdown attachments", async () => {
+ const storage = createStorageService(Buffer.from("# Hello\n"));
+ mockIssueService.getAttachmentById.mockResolvedValue({
+ ...makeAttachment("text/markdown", "notes.md"),
+ byteSize: 8,
+ });
+
+ const app = await createApp(storage);
+ const res = await request(app).get("/api/attachments/attachment-1/content");
+
+ expect(res.status).toBe(200);
+ expect(res.headers["content-type"]).toBe("text/markdown; charset=utf-8");
+ expect(res.headers["x-content-type-options"]).toBe("nosniff");
+ });
+
+ it("keeps the charset declaration on forced markdown downloads", async () => {
+ const storage = createStorageService(Buffer.from("# Hello\n"));
+ mockIssueService.getAttachmentById.mockResolvedValue({
+ ...makeAttachment("text/markdown", "notes.md"),
+ byteSize: 8,
+ });
+
+ const app = await createApp(storage);
+ const res = await request(app).get("/api/attachments/attachment-1/content?download=1");
+
+ expect(res.status).toBe(200);
+ expect(res.headers["content-type"]).toBe("text/markdown; charset=utf-8");
+ expect(res.headers["content-disposition"]).toBe('attachment; filename="notes.md"');
+ });
+
it("keeps image attachments inline for previews", async () => {
const storage = createStorageService();
mockIssueService.getAttachmentById.mockResolvedValue(makeAttachment("image/png", "preview.png"));
diff --git a/server/src/__tests__/openapi-routes.test.ts b/server/src/__tests__/openapi-routes.test.ts
index 2d1eeabfdc..d417e0b831 100644
--- a/server/src/__tests__/openapi-routes.test.ts
+++ b/server/src/__tests__/openapi-routes.test.ts
@@ -210,6 +210,11 @@ describe("openapi routes", () => {
},
});
expect(res.body.paths["/api/companies/{companyId}/folders"].post.responses["201"]).toBeDefined();
+ expect(
+ Object.keys(
+ res.body.paths["/api/issues/{id}/work-products/{workProductId}/review-document"].post.responses,
+ ).sort(),
+ ).toEqual(["200", "201", "401", "403", "404", "409", "413", "415", "422"]);
expect(
res.body.paths["/api/issues/{id}/interactions/{interactionId}/withdraw"].post.summary,
).toBe("Withdraw a pending issue thread interaction");
diff --git a/server/src/errors.ts b/server/src/errors.ts
index d1d7d15f8d..07213e99b6 100644
--- a/server/src/errors.ts
+++ b/server/src/errors.ts
@@ -29,6 +29,14 @@ export function conflict(message: string, details?: unknown) {
return new HttpError(409, message, details);
}
+export function payloadTooLarge(message: string, details?: unknown) {
+ return new HttpError(413, message, details);
+}
+
+export function unsupportedMediaType(message: string, details?: unknown) {
+ return new HttpError(415, message, details);
+}
+
export function unprocessable(message: string, details?: unknown) {
return new HttpError(422, message, details);
}
diff --git a/server/src/routes/issues.ts b/server/src/routes/issues.ts
index e3c90bb6fd..2413acaa9e 100644
--- a/server/src/routes/issues.ts
+++ b/server/src/routes/issues.ts
@@ -67,6 +67,8 @@ import {
upsertIssueDocumentSchema,
updateIssueSchema,
isClosedIsolatedExecutionWorkspace,
+ isMarkdownArtifactWorkProduct,
+ isMarkdownAttachmentContent,
isUuidLike,
normalizeIssueIdentifier as normalizeIssueReferenceIdentifier,
type CompactIssue,
@@ -138,6 +140,7 @@ import {
routineService,
workProductService,
} from "../services/index.js";
+import { artifactReviewDocumentService } from "../services/artifact-review-documents.js";
import { assertCanResolveProposal } from "../services/secret-proposal-authorization.js";
import { buildDocumentReviewContext, buildPlanReviewContext } from "../services/plan-review-context.js";
import {
@@ -2830,6 +2833,7 @@ export function issueRoutes(
const executionWorkspacesSvc = executionWorkspaceServiceDirect(db);
const workProductsSvc = workProductService(db);
const documentsSvc = documentService(db);
+ const artifactReviewDocumentsSvc = artifactReviewDocumentService(db, storage);
const companySkillsSvc = companySkillService(db);
const documentAnnotationsSvc = documentAnnotationService(db);
const decisionTrainingSvc = decisionTrainingService(db);
@@ -7888,9 +7892,110 @@ export function issueRoutes(
actor,
workProductChanged: true,
});
+ await materializeArtifactReviewDocumentBestEffort({ issue, workProduct: product, actor });
res.status(201).json(product);
});
+ async function ensureArtifactReviewDocumentForWorkProduct(input: {
+ issue: NonNullable<Awaited<ReturnType<typeof svc.getById>>>;
+ workProduct: NonNullable<Awaited<ReturnType<typeof workProductsSvc.getById>>>;
+ actor: ReturnType<typeof getActorInfo>;
+ }) {
+ const { issue, workProduct, actor } = input;
+ const result = await artifactReviewDocumentsSvc.ensureForWorkProduct({
+ issue: { id: issue.id, companyId: issue.companyId },
+ workProduct,
+ });
+ if (!result.revisionChanged) return result;
+ const doc = result.document;
+ await issueReferencesSvc.syncDocument(doc.id);
+ await externalObjectsSvc.syncDocumentSafely(doc.id);
+ await logActivity(db, {
+ companyId: issue.companyId,
+ actorType: actor.actorType,
+ actorId: actor.actorId,
+ agentId: actor.agentId,
+ runId: actor.runId,
+ agentApiKeyId: actor.agentApiKeyId,
+ action: result.created ? "issue.document_created" : "issue.document_updated",
+ entityType: "issue",
+ entityId: issue.id,
+ details: {
+ key: doc.key,
+ documentId: doc.id,
+ title: doc.title,
+ format: doc.format,
+ revisionNumber: doc.latestRevisionNumber,
+ workProductId: workProduct.id,
+ artifactReviewDocument: true,
+ },
+ });
+ for (const remap of result.remappedAnnotations) {
+ await logActivity(db, {
+ companyId: issue.companyId,
+ actorType: actor.actorType,
+ actorId: actor.actorId,
+ agentId: actor.agentId,
+ runId: actor.runId,
+ agentApiKeyId: actor.agentApiKeyId,
+ action: "issue.document_annotation_remapped",
+ entityType: "issue",
+ entityId: issue.id,
+ details: {
+ key: doc.key,
+ documentId: doc.id,
+ threadId: remap.thread.id,
+ revisionNumber: doc.latestRevisionNumber,
+ anchorState: remap.thread.anchorState,
+ anchorConfidence: remap.thread.anchorConfidence,
+ snapshotId: remap.snapshot.id,
+ },
+ });
+ }
+ await revalidateActiveSourceRecoveryAfterCommittedWrite({
+ issue,
+ trigger: "document",
+ actor,
+ documentChanged: true,
+ });
+ return result;
+ }
+
+ async function materializeArtifactReviewDocumentBestEffort(input: {
+ issue: NonNullable<Awaited<ReturnType<typeof svc.getById>>>;
+ workProduct: NonNullable<Awaited<ReturnType<typeof workProductsSvc.getById>>>;
+ actor: ReturnType<typeof getActorInfo>;
+ }) {
+ if (!isMarkdownArtifactWorkProduct(input.workProduct)) return;
+ try {
+ await ensureArtifactReviewDocumentForWorkProduct(input);
+ } catch (error) {
+ // Work-product writes stay fail-open: raw open and download remain
+ // available, and the explicit review-document endpoint is the retry path.
+ logger.warn(
+ { err: error, issueId: input.issue.id, workProductId: input.workProduct.id },
+ "markdown work product review-document materialization failed",
+ );
+ }
+ }
+
+ router.post("/issues/:id/work-products/:workProductId/review-document", async (req, res) => {
+ const id = req.params.id as string;
+ const workProductId = req.params.workProductId as string;
+ const issue = await getAccessibleResource(req, res, svc.getById(id), "Issue not found");
+ if (!issue) return;
+ if (!(await assertAgentIssueMutationAllowed(req, res, issue))) return;
+ if (!(await assertDeliverableMutationAllowedByRunContext(req, res, issue))) return;
+ const workProduct = await workProductsSvc.getById(workProductId);
+ if (!workProduct || workProduct.issueId !== issue.id || workProduct.companyId !== issue.companyId) {
+ res.status(404).json({ error: "Work product not found" });
+ return;
+ }
+ const actor = getActorInfo(req);
+ const result = await ensureArtifactReviewDocumentForWorkProduct({ issue, workProduct, actor });
+ res.status(result.created ? 201 : 200).json(result.document);
+ });
+
router.post("/issues/:id/low-trust/promotions", validate(promoteLowTrustOutputSchema), async (req, res) => {
const id = req.params.id as string;
const issue = await getAccessibleResource(req, res, svc.getById(id), "Issue not found");
@@ -8087,6 +8192,11 @@ export function issueRoutes(
actor,
workProductChanged: true,
});
+ const reviewDocumentInputChanged = ["type", "provider", "metadata", "title", "createdByRunId"]
+ .some((key) => Object.prototype.hasOwnProperty.call(patch, key));
+ if (reviewDocumentInputChanged || sourceTrust) {
+ await materializeArtifactReviewDocumentBestEffort({ issue, workProduct: product, actor });
+ }
res.json(product);
});
@@ -12997,7 +13107,16 @@ export function issueRoutes(
objectContentType: object.contentType,
originalFilename: attachment.originalFilename,
});
- res.setHeader("Content-Type", responseContentType);
+ // Markdown bodies are stored as UTF-8; declare the charset so inline
+ // (raw) views do not mojibake. SVG/inline checks below stay on the bare type.
+ const isMarkdownResponse = isMarkdownAttachmentContent({
+ contentType: responseContentType,
+ originalFilename: attachment.originalFilename,
+ });
+ res.setHeader(
+ "Content-Type",
+ isMarkdownResponse ? `${responseContentType}; charset=utf-8` : responseContentType,
+ );
res.setHeader("Cache-Control", "private, max-age=60");
res.setHeader("X-Content-Type-Options", "nosniff");
if (responseContentType === SVG_CONTENT_TYPE) {
diff --git a/server/src/routes/openapi.ts b/server/src/routes/openapi.ts
index 01cb4f05b0..d70249047b 100644
--- a/server/src/routes/openapi.ts
+++ b/server/src/routes/openapi.ts
@@ -536,6 +536,14 @@ const responses = {
description: "Conflict",
content: { "application/json": { schema: ErrorSchema } },
},
+ payloadTooLarge: {
+ description: "Payload too large",
+ content: { "application/json": { schema: ErrorSchema } },
+ },
+ unsupportedMediaType: {
+ description: "Unsupported media type",
+ content: { "application/json": { schema: ErrorSchema } },
+ },
unprocessable: {
description: "Unprocessable entity",
content: { "application/json": { schema: ErrorSchema } },
@@ -2318,6 +2326,25 @@ registry.registerPath({
responses: { 200: r.ok(), 400: r.badRequest, 401: r.unauthorized },
});
+registry.registerPath({
+ method: "post",
+ path: "/api/issues/{id}/work-products/{workProductId}/review-document",
+ tags: ["issues"],
+ summary: "Ensure the review document for a Markdown work product",
+ request: { params: z.object({ id: z.string(), workProductId: z.string() }) },
+ responses: {
+ 200: r.ok(),
+ 201: r.ok(),
+ 401: r.unauthorized,
+ 403: r.forbidden,
+ 404: r.notFound,
+ 409: r.conflict,
+ 413: r.payloadTooLarge,
+ 415: r.unsupportedMediaType,
+ 422: r.unprocessable,
+ },
+});
+
registry.registerPath({
method: "patch",
path: "/api/work-products/{id}",
diff --git a/server/src/services/artifact-review-documents.ts b/server/src/services/artifact-review-documents.ts
new file mode 100644
index 0000000000..3e86b189ef
--- /dev/null
+++ b/server/src/services/artifact-review-documents.ts
@@ -0,0 +1,245 @@
+import { isDeepStrictEqual } from "node:util";
+import { and, eq } from "drizzle-orm";
+import type { Db } from "@paperclipai/db";
+import { assets, documentRevisions, documents, issueAttachments, issueDocuments } from "@paperclipai/db";
+import {
+ MARKDOWN_REVIEW_DOCUMENT_MAX_BYTES,
+ artifactReviewDocumentKey,
+ getAttachmentArtifactWorkProductMetadata,
+ isMarkdownAttachmentContent,
+ type AttachmentArtifactWorkProductMetadata,
+ type IssueWorkProduct,
+} from "@paperclipai/shared";
+import {
+ HttpError,
+ conflict,
+ notFound,
+ payloadTooLarge,
+ unprocessable,
+ unsupportedMediaType,
+} from "../errors.js";
+import type { StorageService } from "../storage/types.js";
+import { documentAnnotationService } from "./document-annotations.js";
+import { documentService, issueDocumentSelect, mapIssueDocumentRow } from "./documents.js";
+
+export type EnsureArtifactReviewWorkProduct = Pick<
+ IssueWorkProduct,
+ "id" | "companyId" | "issueId" | "type" | "provider" | "metadata" | "title" | "createdByRunId" | "sourceTrust"
+>;
+
+export interface EnsureArtifactReviewDocumentInput {
+ issue: { id: string; companyId: string };
+ workProduct: EnsureArtifactReviewWorkProduct;
+}
+
+type RemappedAnnotations = Awaited<
+ ReturnType<ReturnType<typeof documentAnnotationService>["remapOpenThreadsForDocument"]>
+>;
+
+export interface EnsureArtifactReviewDocumentResult {
+ document: ReturnType<typeof mapIssueDocumentRow> & { body?: string };
+ created: boolean;
+ revisionChanged: boolean;
+ remappedAnnotations: RemappedAnnotations;
+}
+
+/**
+ * Materializes the review IssueDocument for an eligible Markdown
+ * attachment-backed work product under the deterministic
+ * `artifact-review-<workProductId>` key. The operation is idempotent: repeated
+ * calls return the existing document and only write a new revision when the
+ * review content or its work-product provenance changed.
+ */
+export function artifactReviewDocumentService(db: Db, storage: StorageService) {
+ const documentsSvc = documentService(db);
+ const annotationsSvc = documentAnnotationService(db);
+
+ const getExistingByKey = async (issueId: string, key: string) => {
+ const document = await db
+ .select(issueDocumentSelect)
+ .from(issueDocuments)
+ .innerJoin(documents, eq(issueDocuments.documentId, documents.id))
+ .where(and(eq(issueDocuments.issueId, issueId), eq(issueDocuments.key, key)))
+ .then((rows) => (rows[0] ? mapIssueDocumentRow(rows[0], true) : null));
+ if (!document) return null;
+ const latestRevision = document.latestRevisionId
+ ? await db
+ .select({
+ createdByAgentId: documentRevisions.createdByAgentId,
+ createdByUserId: documentRevisions.createdByUserId,
+ createdByRunId: documentRevisions.createdByRunId,
+ })
+ .from(documentRevisions)
+ .where(and(
+ eq(documentRevisions.id, document.latestRevisionId),
+ eq(documentRevisions.documentId, document.id),
+ eq(documentRevisions.companyId, document.companyId),
+ ))
+ .then((rows) => rows[0] ?? null)
+ : null;
+ return { document, latestRevision };
+ };
+
+ const readMarkdownAttachmentBody = async (
+ issue: { id: string; companyId: string },
+ metadata: AttachmentArtifactWorkProductMetadata,
+ ) => {
+ const attachment = await db
+ .select({
+ id: issueAttachments.id,
+ companyId: issueAttachments.companyId,
+ issueId: issueAttachments.issueId,
+ objectKey: assets.objectKey,
+ contentType: assets.contentType,
+ byteSize: assets.byteSize,
+ originalFilename: assets.originalFilename,
+ createdByAgentId: assets.createdByAgentId,
+ createdByUserId: assets.createdByUserId,
+ })
+ .from(issueAttachments)
+ .innerJoin(assets, eq(issueAttachments.assetId, assets.id))
+ .where(eq(issueAttachments.id, metadata.attachmentId))
+ .then((rows) => rows[0] ?? null);
+ // Unknown and cross-scope attachment ids are deliberately
+ // indistinguishable: canonical metadata must reference an attachment on
+ // the same issue and company.
+ if (!attachment || attachment.companyId !== issue.companyId || attachment.issueId !== issue.id) {
+ throw unprocessable("Work product attachment must reference an attachment on the same issue", {
+ code: "invalid_attachment_artifact_metadata",
+ attachmentId: metadata.attachmentId,
+ });
+ }
+ if (!isMarkdownAttachmentContent(attachment)) {
+ throw unsupportedMediaType("Work product attachment is not Markdown", {
+ code: "unsupported_review_document_content_type",
+ contentType: attachment.contentType,
+ });
+ }
+ if (attachment.byteSize > MARKDOWN_REVIEW_DOCUMENT_MAX_BYTES) {
+ throw payloadTooLarge("Markdown attachment exceeds the review document size limit", {
+ code: "review_document_too_large",
+ byteSize: attachment.byteSize,
+ maxBytes: MARKDOWN_REVIEW_DOCUMENT_MAX_BYTES,
+ });
+ }
+
+ const object = await storage.getObject(attachment.companyId, attachment.objectKey);
+ const chunks: Buffer[] = [];
+ let total = 0;
+ for await (const chunk of object.stream) {
+ const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+ total += buffer.length;
+ // Defense in depth: enforce the cap during streaming too, so a
+ // metadata/object size mismatch can never exceed the limit.
+ if (total > MARKDOWN_REVIEW_DOCUMENT_MAX_BYTES) {
+ object.stream.destroy();
+ throw payloadTooLarge("Markdown attachment exceeds the review document size limit", {
+ code: "review_document_too_large",
+ maxBytes: MARKDOWN_REVIEW_DOCUMENT_MAX_BYTES,
+ });
+ }
+ chunks.push(buffer);
+ }
+
+ let body: string;
+ try {
+ body = new TextDecoder("utf-8", { fatal: true }).decode(Buffer.concat(chunks));
+ } catch {
+ throw unprocessable("Markdown attachment is not valid UTF-8", {
+ code: "invalid_review_document_encoding",
+ attachmentId: attachment.id,
+ });
+ }
+ return { attachment, body };
+ };
+
+ return {
+ ensureForWorkProduct: async (
+ input: EnsureArtifactReviewDocumentInput,
+ ): Promise<EnsureArtifactReviewDocumentResult> => {
+ const { issue, workProduct } = input;
+ if (workProduct.issueId !== issue.id || workProduct.companyId !== issue.companyId) {
+ throw notFound("Work product not found");
+ }
+ const metadata = getAttachmentArtifactWorkProductMetadata(workProduct);
+ if (!metadata) {
+ throw unprocessable("Work product is not an attachment-backed Paperclip artifact", {
+ code: "not_attachment_backed_artifact",
+ workProductId: workProduct.id,
+ });
+ }
+ if (!isMarkdownAttachmentContent(metadata)) {
+ throw unsupportedMediaType("Work product attachment is not Markdown", {
+ code: "unsupported_review_document_content_type",
+ contentType: metadata.contentType,
+ });
+ }
+
+ const { attachment, body } = await readMarkdownAttachmentBody(issue, metadata);
+ const key = artifactReviewDocumentKey(workProduct.id);
+ // The review document represents agent-authored attachment content, so
+ // attribution promotes the attachment/work-product provenance instead of
+ // the actor who triggered materialization.
+ const attribution = {
+ createdByAgentId: attachment.createdByAgentId ?? null,
+ createdByUserId: attachment.createdByUserId ?? null,
+ createdByRunId: workProduct.createdByRunId ?? null,
+ sourceTrust: workProduct.sourceTrust ?? null,
+ };
+
+ for (let attempt = 0; attempt < 2; attempt += 1) {
+ const existingState = await getExistingByKey(issue.id, key);
+ const existing = existingState?.document ?? null;
+ const latestRevision = existingState?.latestRevision ?? null;
+ const reviewStateMatches = existing &&
+ existing.body === body &&
+ existing.title === (workProduct.title ?? null) &&
+ existing.format === "markdown" &&
+ latestRevision?.createdByAgentId === attribution.createdByAgentId &&
+ latestRevision.createdByUserId === attribution.createdByUserId &&
+ latestRevision.createdByRunId === attribution.createdByRunId &&
+ isDeepStrictEqual(existing.sourceTrust ?? null, attribution.sourceTrust);
+ if (reviewStateMatches) {
+ return { document: existing, created: false, revisionChanged: false, remappedAnnotations: [] };
+ }
+ try {
+ const result = await documentsSvc.upsertIssueDocument({
+ issueId: issue.id,
+ key,
+ title: workProduct.title ?? null,
+ format: "markdown",
+ body,
+ changeSummary: existing
+ ? "Synced from the work product attachment"
+ : "Materialized from the Markdown work product attachment",
+ baseRevisionId: existing?.latestRevisionId ?? null,
+ ...attribution,
+ lockedDocumentStrategy: "conflict",
+ });
+ const remappedAnnotations = result.created
+ ? []
+ : await annotationsSvc.remapOpenThreadsForDocument({
+ issueId: issue.id,
+ key: result.document.key,
+ documentId: result.document.id,
+ nextRevisionId: result.document.latestRevisionId,
+ nextRevisionNumber: result.document.latestRevisionNumber,
+ nextBody: result.document.body,
+ });
+ return {
+ document: result.document,
+ created: result.created,
+ revisionChanged: true,
+ remappedAnnotations,
+ };
+ } catch (error) {
+ // A concurrent materialization or document write raced this one.
+ // Re-read once so identical content converges on the winner.
+ if (error instanceof HttpError && error.status === 409 && attempt === 0) continue;
+ throw error;
+ }
+ }
+ throw conflict("Concurrent review-document updates did not converge", { key });
+ },
+ };
+}
diff --git a/server/src/services/index.ts b/server/src/services/index.ts
index 3b7569b1a6..54e56fc936 100644
--- a/server/src/services/index.ts
+++ b/server/src/services/index.ts
@@ -23,6 +23,7 @@ export {
export { agentInstructionsService, syncInstructionsBundleConfigFromFilePath } from "./agent-instructions.js";
export { assetService } from "./assets.js";
export { documentService, extractLegacyPlanBody } from "./documents.js";
+export { artifactReviewDocumentService } from "./artifact-review-documents.js";
export { statusCardService } from "./status-cards.js";
export { finalizeStatusCardsForStalledGeneration } from "./status-card-finalization.js";
export { documentAnnotationService } from "./document-annotations.js";
diff --git a/ui/src/api/issues.ts b/ui/src/api/issues.ts
index 5eae6f0685..4f00784fd7 100644
--- a/ui/src/api/issues.ts
+++ b/ui/src/api/issues.ts
@@ -342,6 +342,8 @@ export const issuesApi = {
unlinkApproval: (id: string, approvalId: string) =>
api.delete<{ ok: true }>(`/issues/${id}/approvals/${approvalId}`),
listWorkProducts: (id: string) => api.get<IssueWorkProduct[]>(`/issues/${id}/work-products`),
+ ensureWorkProductReviewDocument: (id: string, workProductId: string) =>
+ api.post<IssueDocument>(`/issues/${id}/work-products/${workProductId}/review-document`, {}),
createWorkProduct: (id: string, data: Record<string, unknown>) =>
api.post<IssueWorkProduct>(`/issues/${id}/work-products`, data),
updateWorkProduct: (id: string, data: Record<string, unknown>) =>
diff --git a/ui/src/components/issue-properties/IssueProperties.tsx b/ui/src/components/issue-properties/IssueProperties.tsx
index 4df10852be..2aadb3994b 100644
--- a/ui/src/components/issue-properties/IssueProperties.tsx
+++ b/ui/src/components/issue-properties/IssueProperties.tsx
@@ -5,7 +5,12 @@ import { pickTextColorForPillBg } from "@/lib/color-contrast";
import { issueStatusText } from "@/lib/status-colors";
import { copyTextToClipboard } from "@/lib/clipboard";
import { Link } from "@/lib/router";
-import { deriveOriginatingActor, type Issue, type IssueLabel } from "@paperclipai/shared";
+import {
+ deriveOriginatingActor,
+ isArtifactReviewDocumentKey,
+ type Issue,
+ type IssueLabel,
+} from "@paperclipai/shared";
import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
import { accessApi } from "../../api/access";
import { agentsApi } from "../../api/agents";
@@ -225,10 +230,15 @@ export function IssueProperties({
enabled: taskChatShellEnabled,
});
const { data: paneTabDocuments } = useIssueDocuments(taskChatShellEnabled ? issue.id : null);
+ // Proxy `artifact-review-*` documents surface only through their Work
+ // product row, so they must not summon the Plan or Documents surfaces.
+ const paneTabStandaloneDocuments = (paneTabDocuments ?? []).filter(
+ (doc) => !isArtifactReviewDocumentKey(doc.key),
+ );
const hasPlanTab =
Boolean(paneTabPlanDocument)
|| (paneTabAcceptedPlans?.length ?? 0) > 0
- || (paneTabDocuments?.length ?? 0) > 0
+ || paneTabStandaloneDocuments.length > 0
|| issue.workMode === "planning";
// Artifacts covers the same three sources the tab body composes: work
// products, documents (redundant with the Plan tab, intentionally), and
@@ -236,7 +246,7 @@ export function IssueProperties({
// no longer summon the tab.
const hasArtifactsTab =
(paneTabWorkProducts?.length ?? 0) > 0
- || (paneTabDocuments?.length ?? 0) > 0
+ || paneTabStandaloneDocuments.length > 0
|| selectAgentArtifactAttachments(paneTabAttachments, paneTabWorkProducts).length > 0;
const [paneTab, setPaneTab] = useState("properties");
// Once a plan document exists, surface it: switch the pane to the Plan tab so
diff --git a/ui/src/components/issue-properties/IssuePropertiesArtifactsTab.tsx b/ui/src/components/issue-properties/IssuePropertiesArtifactsTab.tsx
index 4d8ca4749e..dea4ed8a2c 100644
--- a/ui/src/components/issue-properties/IssuePropertiesArtifactsTab.tsx
+++ b/ui/src/components/issue-properties/IssuePropertiesArtifactsTab.tsx
@@ -1,10 +1,22 @@
import { useEffect, useRef, useState } from "react";
import type { CSSProperties } from "react";
-import { useQuery } from "@tanstack/react-query";
-import type { Issue, IssueDocument, IssueWorkProduct } from "@paperclipai/shared";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import type {
+ AttachmentArtifactWorkProductMetadata,
+ Issue,
+ IssueDocument,
+ IssueWorkProduct,
+} from "@paperclipai/shared";
+import {
+ MARKDOWN_REVIEW_DOCUMENT_MAX_BYTES,
+ artifactReviewDocumentKey,
+ getMarkdownWorkProductAttachmentMetadata,
+ isArtifactReviewDocumentKey,
+} from "@paperclipai/shared";
import {
ChevronDown,
ChevronRight,
+ Download,
ExternalLink,
FileText,
GitBranch,
@@ -15,6 +27,7 @@ import {
Server,
} from "lucide-react";
import type { LucideIcon } from "lucide-react";
+import { ApiError } from "@/api/client";
import { issuesApi } from "@/api/issues";
import { queryKeys } from "@/lib/queryKeys";
import { useIssueDocuments } from "@/hooks/useIssueDocuments";
@@ -122,6 +135,186 @@ function WorkProductRow({ workProduct }: { workProduct: IssueWorkProduct }) {
return <div className={ROW_CLASS}>{body}</div>;
}
+/**
+ * Work-product row for an eligible Markdown artifact (LOOA-1533 gap): expands
+ * in place into the shipped document review surface backed by the
+ * server-materialized `artifact-review-<workProductId>` issue document instead
+ * of opening the raw attachment. Raw open and download stay as explicit
+ * secondary actions.
+ */
+function MarkdownWorkProductRow({
+ issueId,
+ workProduct,
+ metadata,
+ reviewDoc,
+ openRequestId,
+}: {
+ issueId: string;
+ workProduct: IssueWorkProduct;
+ metadata: AttachmentArtifactWorkProductMetadata;
+ reviewDoc: IssueDocument | undefined;
+ openRequestId?: number;
+}) {
+ const [expanded, setExpanded] = useState(false);
+ const [annotationPanelOpen, setAnnotationPanelOpen] = useState(false);
+ const headerRef = useRef<HTMLDivElement | null>(null);
+ const location = useLocation();
+ const queryClient = useQueryClient();
+ const badge = workProductStatusBadge(workProduct.status);
+ const Chevron = expanded ? ChevronDown : ChevronRight;
+ const tooLarge = metadata.byteSize > MARKDOWN_REVIEW_DOCUMENT_MAX_BYTES;
+
+ const ensure = useMutation({
+ mutationFn: () => issuesApi.ensureWorkProductReviewDocument(issueId, workProduct.id),
+ onSuccess: async () => {
+ await queryClient.invalidateQueries({ queryKey: queryKeys.issues.documents(issueId) });
+ },
+ });
+
+ const requestPreview = () => {
+ if (reviewDoc || tooLarge) return;
+ if (ensure.isPending || ensure.isSuccess || ensure.isError) return;
+ ensure.mutate();
+ };
+
+ const handleToggle = () => {
+ setExpanded((open) => {
+ if (!open) requestPreview();
+ return !open;
+ });
+ };
+
+ useEffect(() => {
+ if (openRequestId === undefined) return;
+ setExpanded(true);
+ }, [openRequestId]);
+ useEffect(() => {
+ if (openRequestId === undefined || !expanded) return;
+ headerRef.current?.scrollIntoView({ behavior: "smooth", block: "center" });
+ }, [expanded, openRequestId]);
+ // Deep links land before the user clicks, so the deep-link expansion has to
+ // request materialization the same way a manual expand does.
+ useEffect(() => {
+ if (openRequestId === undefined) return;
+ requestPreview();
+ // eslint-disable-next-line react-hooks/exhaustive-deps
+ }, [openRequestId, reviewDoc]);
+
+ const unsupportedError =
+ ensure.error instanceof ApiError && [413, 415, 422].includes(ensure.error.status);
+
+ let expandedBody: React.ReactNode;
+ if (tooLarge) {
+ expandedBody = (
+ <p className="text-sm text-muted-foreground">
+ This Markdown file is too large to preview. Use Raw or Download instead.
+ </p>
+ );
+ } else if (reviewDoc) {
+ expandedBody = reviewDoc.body.trim().length > 0 ? (
+ <IssueDocumentAnnotations
+ issueId={issueId}
+ doc={reviewDoc}
+ bodyMarkdown={reviewDoc.body}
+ draftDirty={false}
+ draftConflicted={false}
+ historicalPreview={false}
+ locationHash={location.hash}
+ panelOpen={annotationPanelOpen}
+ onPanelOpenChange={setAnnotationPanelOpen}
+ panelPlacement="popover"
+ >
+ <MarkdownBody>{reviewDoc.body}</MarkdownBody>
+ </IssueDocumentAnnotations>
+ ) : (
+ <p className="text-sm text-muted-foreground">Document is empty.</p>
+ );
+ } else if (ensure.isError) {
+ expandedBody = (
+ <div className="flex flex-col items-start gap-1.5">
+ <p className="text-sm text-muted-foreground">
+ {unsupportedError
+ ? "This file can't be previewed as Markdown. Use Raw or Download instead."
+ : "Preview failed to load."}
+ </p>
+ {!unsupportedError ? (
+ <button
+ type="button"
+ className="rounded-md border border-border px-2 py-0.5 text-(length:--text-micro) text-muted-foreground hover:bg-accent/50"
+ onClick={() => {
+ ensure.reset();
+ ensure.mutate();
+ }}
+ >
+ Retry
+ </button>
+ ) : null}
+ </div>
+ );
+ } else {
+ expandedBody = <p className="text-sm text-muted-foreground">Preparing preview…</p>;
+ }
+
+ return (
+ <div className="rounded-md border border-border bg-card/50">
+ <div ref={headerRef} className="flex items-center hover:bg-accent/50">
+ <button
+ type="button"
+ onClick={handleToggle}
+ className="flex min-w-0 flex-1 items-center gap-2 px-2.5 py-1.5 text-left text-sm"
+ aria-expanded={expanded}
+ >
+ <FileText className="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
+ <span className="min-w-0 flex-1 truncate">{workProduct.title}</span>
+ {badge ? (
+ <span
+ className="status-chip inline-flex shrink-0 items-center rounded-full border px-1.5 py-0.5 text-(length:--text-nano) leading-none whitespace-nowrap"
+ style={{ "--sc": `var(${badge.cssVar})` } as CSSProperties}
+ >
+ {badge.label}
+ </span>
+ ) : null}
+ {reviewDoc ? (
+ <span className="shrink-0 text-(length:--text-micro) text-muted-foreground">
+ {`Rev ${reviewDoc.latestRevisionNumber ?? 1}`}
+ </span>
+ ) : null}
+ <Chevron className="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
+ </button>
+ {reviewDoc ? (
+ <DocumentAnnotationsCountChip
+ issueId={issueId}
+ docKey={reviewDoc.key}
+ panelOpen={annotationPanelOpen}
+ onToggle={() => setAnnotationPanelOpen((open) => !open)}
+ />
+ ) : null}
+ <a
+ href={metadata.openPath}
+ target="_blank"
+ rel="noreferrer"
+ aria-label={`Open raw ${workProduct.title}`}
+ title="Open raw"
+ className="shrink-0 px-1.5 py-1.5 text-muted-foreground hover:text-foreground"
+ >
+ <ExternalLink className="h-3 w-3" />
+ </a>
+ <a
+ href={metadata.downloadPath}
+ aria-label={`Download ${workProduct.title}`}
+ title="Download"
+ className="shrink-0 py-1.5 pr-2 pl-0.5 text-muted-foreground hover:text-foreground"
+ >
+ <Download className="h-3 w-3" />
+ </a>
+ </div>
+ {expanded ? (
+ <div className="border-t border-border px-2.5 py-2">{expandedBody}</div>
+ ) : null}
+ </div>
+ );
+}
+
function DocumentRow({
issueId,
doc,
@@ -215,7 +408,10 @@ export function IssuePropertiesArtifactsTab({ issue, documentDeepLink }: IssuePr
const { data: documents } = useIssueDocuments(issue.id);
const workProductRows = workProducts ?? [];
- const documentRows = documents ?? [];
+ // Proxy review documents (`artifact-review-*`) present only through their
+ // originating Work product row, never as standalone Documents rows.
+ const documentRows = (documents ?? []).filter((doc) => !isArtifactReviewDocumentKey(doc.key));
+ const reviewDocsByKey = new Map((documents ?? []).map((doc) => [doc.key, doc]));
const fileRows = selectAgentArtifactAttachments(attachments, workProducts);
if (workProductRows.length === 0 && documentRows.length === 0 && fileRows.length === 0) {
@@ -232,11 +428,30 @@ export function IssuePropertiesArtifactsTab({ issue, documentDeepLink }: IssuePr
<>
<SectionHeading>Work products</SectionHeading>
<ul className="flex flex-col gap-1">
- {workProductRows.map((wp) => (
- <li key={wp.id}>
- <WorkProductRow workProduct={wp} />
- </li>
- ))}
+ {workProductRows.map((wp) => {
+ const markdownMetadata = getMarkdownWorkProductAttachmentMetadata(wp);
+ if (!markdownMetadata) {
+ return (
+ <li key={wp.id}>
+ <WorkProductRow workProduct={wp} />
+ </li>
+ );
+ }
+ const reviewKey = artifactReviewDocumentKey(wp.id);
+ return (
+ <li key={wp.id}>
+ <MarkdownWorkProductRow
+ issueId={issue.id}
+ workProduct={wp}
+ metadata={markdownMetadata}
+ reviewDoc={reviewDocsByKey.get(reviewKey)}
+ openRequestId={documentDeepLink?.documentKey === reviewKey
+ ? documentDeepLink.requestId
+ : undefined}
+ />
+ </li>
+ );
+ })}
</ul>
</>
) : null}
diff --git a/ui/src/components/issue-properties/IssuePropertiesMarkdownWorkProduct.test.tsx b/ui/src/components/issue-properties/IssuePropertiesMarkdownWorkProduct.test.tsx
new file mode 100644
index 0000000000..b8c640daf6
--- /dev/null
+++ b/ui/src/components/issue-properties/IssuePropertiesMarkdownWorkProduct.test.tsx
@@ -0,0 +1,344 @@
+// @vitest-environment jsdom
+
+import { flushSync } from "react-dom";
+import { createRoot, type Root } from "react-dom/client";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { Issue, IssueAttachment, IssueDocument, IssueWorkProduct } from "@paperclipai/shared";
+import { artifactReviewDocumentKey } from "@paperclipai/shared";
+import { IssuePropertiesArtifactsTab } from "./IssuePropertiesArtifactsTab";
+import { ApiError } from "@/api/client";
+
+const mockIssuesApi = vi.hoisted(() => ({
+ listAttachments: vi.fn(async (): Promise<unknown[]> => []),
+ listWorkProducts: vi.fn(async (): Promise<unknown[]> => []),
+ ensureWorkProductReviewDocument: vi.fn(async (): Promise<unknown> => ({})),
+}));
+vi.mock("@/api/issues", () => ({ issuesApi: mockIssuesApi }));
+
+const mockUseIssueDocuments = vi.hoisted(() =>
+ vi.fn((): { data: IssueDocument[] } => ({ data: [] })),
+);
+vi.mock("@/hooks/useIssueDocuments", () => ({ useIssueDocuments: mockUseIssueDocuments }));
+vi.mock("@/lib/router", () => ({ useLocation: () => ({ hash: "" }) }));
+vi.mock("@/components/MarkdownBody", () => ({
+ MarkdownBody: ({ children }: { children: string }) => (
+ <div data-testid="markdown-body">{children}</div>
+ ),
+}));
+vi.mock("@/components/IssueDocumentAnnotations", () => ({
+ DocumentAnnotationsCountChip: ({ docKey }: { docKey: string }) => (
+ <span data-testid={`annotation-count-${docKey}`} />
+ ),
+ IssueDocumentAnnotations: ({ doc, children }: { doc: IssueDocument; children: React.ReactNode }) => (
+ <div data-testid={`annotation-surface-${doc.key}`} data-document-id={doc.id}>{children}</div>
+ ),
+}));
+
+const ATTACHMENT_ID = "00000000-0000-4000-8000-000000000001";
+const WORK_PRODUCT_ID = "11111111-1111-4111-8111-111111111111";
+const REVIEW_KEY = artifactReviewDocumentKey(WORK_PRODUCT_ID);
+
+const issue = { id: "issue-1", identifier: "PAP-1534", workMode: "standard" } as Issue;
+
+function makeMarkdownWorkProduct(overrides: Partial<IssueWorkProduct> = {}): IssueWorkProduct {
+ const contentPath = `/api/attachments/${ATTACHMENT_ID}/content`;
+ return {
+ id: WORK_PRODUCT_ID,
+ companyId: "company-1",
+ projectId: null,
+ issueId: "issue-1",
+ executionWorkspaceId: null,
+ runtimeServiceId: null,
+ type: "artifact",
+ provider: "paperclip",
+ externalId: null,
+ title: "Verification report",
+ url: null,
+ status: "ready_for_review",
+ reviewState: "none",
+ isPrimary: false,
+ healthStatus: "unknown",
+ summary: null,
+ metadata: {
+ attachmentId: ATTACHMENT_ID,
+ contentType: "text/markdown",
+ byteSize: 64,
+ contentPath,
+ openPath: contentPath,
+ downloadPath: `${contentPath}?download=1`,
+ originalFilename: "report.md",
+ },
+ createdByRunId: null,
+ createdAt: new Date("2026-08-01T12:00:00Z"),
+ updatedAt: new Date("2026-08-01T12:00:00Z"),
+ ...overrides,
+ } as IssueWorkProduct;
+}
+
+function makeReviewDocument(overrides: Partial<IssueDocument> = {}): IssueDocument {
+ return {
+ id: "document-1",
+ companyId: "company-1",
+ issueId: "issue-1",
+ key: REVIEW_KEY,
+ title: "Verification report",
+ format: "markdown",
+ body: "# Report\n\nRendered body",
+ latestRevisionId: "revision-1",
+ latestRevisionNumber: 1,
+ createdByAgentId: null,
+ createdByUserId: null,
+ updatedByAgentId: null,
+ updatedByUserId: null,
+ lockedAt: null,
+ lockedByAgentId: null,
+ lockedByUserId: null,
+ createdAt: new Date("2026-08-01T12:00:00Z"),
+ updatedAt: new Date("2026-08-01T12:00:00Z"),
+ ...overrides,
+ } as IssueDocument;
+}
+
+function makeMarkdownAttachment(): IssueAttachment {
+ return {
+ id: ATTACHMENT_ID,
+ companyId: "company-1",
+ issueId: "issue-1",
+ issueCommentId: null,
+ assetId: "asset-1",
+ provider: "local",
+ objectKey: `objects/${ATTACHMENT_ID}`,
+ contentType: "text/markdown",
+ byteSize: 64,
+ sha256: "0".repeat(64),
+ originalFilename: "report.md",
+ createdByAgentId: "agent-1",
+ createdByUserId: null,
+ createdAt: new Date("2026-08-01T12:00:00Z"),
+ updatedAt: new Date("2026-08-01T12:00:00Z"),
+ contentPath: `/api/attachments/${ATTACHMENT_ID}/content`,
+ } as IssueAttachment;
+}
+
+async function act(callback: () => void | Promise<void>) {
+ let result: void | Promise<void> = undefined;
+ flushSync(() => {
+ result = callback();
+ });
+ await result;
+}
+
+async function flush() {
+ await act(async () => {
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ });
+}
+
+async function waitForAssertion(assertion: () => void, attempts = 20) {
+ let lastError: unknown;
+ for (let attempt = 0; attempt < attempts; attempt += 1) {
+ try {
+ assertion();
+ return;
+ } catch (error) {
+ lastError = error;
+ await flush();
+ }
+ }
+ throw lastError;
+}
+
+describe("markdown work product review row", () => {
+ let container: HTMLDivElement;
+ let root: Root | null = null;
+
+ beforeEach(() => {
+ vi.clearAllMocks();
+ container = document.createElement("div");
+ document.body.appendChild(container);
+ Element.prototype.scrollIntoView = vi.fn();
+ mockIssuesApi.listAttachments.mockResolvedValue([]);
+ mockIssuesApi.listWorkProducts.mockResolvedValue([makeMarkdownWorkProduct()]);
+ mockUseIssueDocuments.mockReturnValue({ data: [] });
+ });
+
+ afterEach(async () => {
+ if (root) {
+ const currentRoot = root;
+ await act(async () => currentRoot.unmount());
+ root = null;
+ }
+ container.remove();
+ });
+
+ async function renderTab(props: { documentDeepLink?: { requestId: number; documentKey: string } | null } = {}) {
+ const queryClient = new QueryClient({
+ defaultOptions: { queries: { retry: false }, mutations: { retry: false } },
+ });
+ root = createRoot(container);
+ const currentRoot = root;
+ await act(async () =>
+ currentRoot.render(
+ <QueryClientProvider client={queryClient}>
+ <IssuePropertiesArtifactsTab issue={issue} {...props} />
+ </QueryClientProvider>,
+ ),
+ );
+ await waitForAssertion(() => {
+ expect(container.textContent).toContain("Verification report");
+ });
+ }
+
+ function expandButton() {
+ return container.querySelector('button[aria-expanded]') as HTMLButtonElement;
+ }
+
+ it("renders an expandable row with explicit raw and download actions", async () => {
+ await renderTab();
+
+ expect(expandButton().textContent).toContain("Verification report");
+ const raw = container.querySelector('a[title="Open raw"]') as HTMLAnchorElement;
+ const download = container.querySelector('a[title="Download"]') as HTMLAnchorElement;
+ expect(raw?.getAttribute("href")).toBe(`/api/attachments/${ATTACHMENT_ID}/content`);
+ expect(raw?.getAttribute("target")).toBe("_blank");
+ expect(download?.getAttribute("href")).toBe(`/api/attachments/${ATTACHMENT_ID}/content?download=1`);
+ });
+
+ it("expands into the existing document surface without a server call when the document exists", async () => {
+ mockUseIssueDocuments.mockReturnValue({ data: [makeReviewDocument()] });
+ await renderTab();
+
+ // The proxy document maps onto the work-product row instead of a
+ // standalone Documents row.
+ expect(container.textContent).not.toContain("Documents");
+ expect(container.querySelector(`[data-testid="annotation-count-${REVIEW_KEY}"]`)).not.toBeNull();
+
+ await act(async () => expandButton().click());
+ expect(
+ container.querySelector(`[data-testid="annotation-surface-${REVIEW_KEY}"]`)?.getAttribute("data-document-id"),
+ ).toBe("document-1");
+ expect(container.querySelector('[data-testid="markdown-body"]')?.textContent).toContain("Rendered body");
+ expect(mockIssuesApi.ensureWorkProductReviewDocument).not.toHaveBeenCalled();
+ });
+
+ it("materializes the document on first expand", async () => {
+ mockIssuesApi.ensureWorkProductReviewDocument.mockResolvedValue(makeReviewDocument());
+ await renderTab();
+
+ await act(async () => expandButton().click());
+ expect(container.textContent).toContain("Preparing preview…");
+ await waitForAssertion(() => {
+ expect(mockIssuesApi.ensureWorkProductReviewDocument).toHaveBeenCalledWith("issue-1", WORK_PRODUCT_ID);
+ });
+ expect(mockIssuesApi.ensureWorkProductReviewDocument).toHaveBeenCalledTimes(1);
+ });
+
+ it("shows an unsupported state without retry for typed rejections", async () => {
+ mockIssuesApi.ensureWorkProductReviewDocument.mockRejectedValue(
+ new ApiError("Work product attachment is not Markdown", 415, {}),
+ );
+ await renderTab();
+
+ await act(async () => expandButton().click());
+ await waitForAssertion(() => {
+ expect(container.textContent).toContain("can't be previewed as Markdown");
+ });
+ expect(container.textContent).not.toContain("Retry");
+ });
+
+ it("offers an explicit retry for recoverable errors", async () => {
+ mockIssuesApi.ensureWorkProductReviewDocument.mockRejectedValue(
+ new ApiError("Internal error", 500, {}),
+ );
+ await renderTab();
+
+ await act(async () => expandButton().click());
+ await waitForAssertion(() => {
+ expect(container.textContent).toContain("Preview failed to load.");
+ });
+
+ const retry = Array.from(container.querySelectorAll("button")).find(
+ (button) => button.textContent === "Retry",
+ );
+ expect(retry).toBeDefined();
+ await act(async () => retry?.click());
+ await waitForAssertion(() => {
+ expect(mockIssuesApi.ensureWorkProductReviewDocument).toHaveBeenCalledTimes(2);
+ });
+ });
+
+ it("marks oversized markdown as too large without calling the server", async () => {
+ mockIssuesApi.listWorkProducts.mockResolvedValue([
+ makeMarkdownWorkProduct({
+ metadata: {
+ ...(makeMarkdownWorkProduct().metadata as Record<string, unknown>),
+ byteSize: 512 * 1024 + 1,
+ },
+ }),
+ ]);
+ await renderTab();
+
+ await act(async () => expandButton().click());
+ expect(container.textContent).toContain("too large to preview");
+ expect(mockIssuesApi.ensureWorkProductReviewDocument).not.toHaveBeenCalled();
+ });
+
+ it("expands from a document deep link and requests materialization", async () => {
+ mockIssuesApi.ensureWorkProductReviewDocument.mockResolvedValue(makeReviewDocument());
+ await renderTab({ documentDeepLink: { documentKey: REVIEW_KEY, requestId: 1 } });
+
+ await waitForAssertion(() => {
+ expect(container.querySelector('button[aria-expanded="true"]')).not.toBeNull();
+ expect(mockIssuesApi.ensureWorkProductReviewDocument).toHaveBeenCalledTimes(1);
+ expect(Element.prototype.scrollIntoView).toHaveBeenCalledWith({ behavior: "smooth", block: "center" });
+ });
+ });
+
+ it("hides the promoted markdown attachment from Files but keeps loose attachments", async () => {
+ const loose = {
+ ...makeMarkdownAttachment(),
+ id: "22222222-2222-4222-8222-222222222222",
+ originalFilename: "loose-notes.md",
+ contentPath: "/api/attachments/22222222-2222-4222-8222-222222222222/content",
+ };
+ mockIssuesApi.listAttachments.mockResolvedValue([makeMarkdownAttachment(), loose]);
+ await renderTab();
+
+ await waitForAssertion(() => {
+ expect(container.textContent).toContain("loose-notes.md");
+ });
+ expect(container.textContent).not.toContain("report.md");
+ const looseLink = Array.from(container.querySelectorAll("a")).find(
+ (anchor) => anchor.textContent?.includes("loose-notes.md"),
+ );
+ expect(looseLink?.getAttribute("href")).toBe("/api/attachments/22222222-2222-4222-8222-222222222222/content");
+ });
+
+ it("keeps non-markdown work products on the raw link row", async () => {
+ const contentPath = `/api/attachments/${ATTACHMENT_ID}/content`;
+ mockIssuesApi.listWorkProducts.mockResolvedValue([
+ makeMarkdownWorkProduct({
+ metadata: {
+ attachmentId: ATTACHMENT_ID,
+ contentType: "application/pdf",
+ byteSize: 64,
+ contentPath,
+ openPath: contentPath,
+ downloadPath: `${contentPath}?download=1`,
+ originalFilename: "report.pdf",
+ },
+ }),
+ ]);
+ await renderTab();
+
+ await waitForAssertion(() => {
+ const row = Array.from(container.querySelectorAll("a")).find(
+ (anchor) => anchor.textContent?.includes("Verification report"),
+ );
+ expect(row?.getAttribute("href")).toBe(contentPath);
+ expect(row?.getAttribute("target")).toBe("_blank");
+ });
+ expect(container.querySelector("button[aria-expanded]")).toBeNull();
+ });
+});
diff --git a/ui/src/components/issue-properties/IssuePropertiesPlansTab.tsx b/ui/src/components/issue-properties/IssuePropertiesPlansTab.tsx
index 1a5f90ea4c..b3458fbaa4 100644
--- a/ui/src/components/issue-properties/IssuePropertiesPlansTab.tsx
+++ b/ui/src/components/issue-properties/IssuePropertiesPlansTab.tsx
@@ -1,6 +1,7 @@
import { useState } from "react";
import { useQuery } from "@tanstack/react-query";
import type { Issue, IssueDocument, IssueThreadInteraction } from "@paperclipai/shared";
+import { isArtifactReviewDocumentKey } from "@paperclipai/shared";
import { issuesApi } from "@/api/issues";
import { queryKeys } from "@/lib/queryKeys";
import { IssuePlanDecompositionsSection } from "@/components/IssuePlanDecompositionsSection";
@@ -92,8 +93,11 @@ export function IssuePropertiesPlansTab({ issue }: IssuePropertiesPlansTabProps)
const hasPlans = (data?.length ?? 0) > 0;
const pendingPlanConfirmation = hasPendingPlanConfirmation(interactions);
// Every other non-system document (e.g. `synthesis`) renders below the plan;
- // the `plan` doc itself stays on its dedicated annotated surface above.
- const otherDocuments = (documents ?? []).filter((doc) => doc.key !== "plan");
+ // the `plan` doc itself stays on its dedicated annotated surface above, and
+ // proxy `artifact-review-*` documents surface only through their Work product.
+ const otherDocuments = (documents ?? []).filter(
+ (doc) => doc.key !== "plan" && !isArtifactReviewDocumentKey(doc.key),
+ );
if (!planDocument && !hasPlans && otherDocuments.length === 0) {
return (
diff --git a/ui/src/lib/issue-artifacts.test.ts b/ui/src/lib/issue-artifacts.test.ts
index 026cff4739..42dc6d3ee8 100644
--- a/ui/src/lib/issue-artifacts.test.ts
+++ b/ui/src/lib/issue-artifacts.test.ts
@@ -2,6 +2,7 @@ import { describe, expect, it } from "vitest";
import type { IssueAttachment, IssueWorkProduct } from "@paperclipai/shared";
import {
documentDisplayTitle,
+ getAttachmentBackedWorkProductAttachmentIds,
isAgentAttachment,
selectAgentArtifactAttachments,
workProductHref,
@@ -112,6 +113,54 @@ describe("selectAgentArtifactAttachments", () => {
it("tolerates missing inputs", () => {
expect(selectAgentArtifactAttachments(null, null)).toEqual([]);
});
+
+ it("dedupes markdown attachments promoted to work products", () => {
+ // Markdown is excluded from the binary Output surface, so this dedupe must
+ // not depend on getPromotedOutputAttachmentIds (LOOA-1533 duplicate rows).
+ const promotedId = "00000000-0000-4000-8000-000000000002";
+ const promoted = makeAttachment({
+ id: promotedId,
+ createdByAgentId: "agent-1",
+ contentType: "text/markdown",
+ originalFilename: "report.md",
+ });
+ const workProduct = makePromotingWorkProduct(promotedId);
+ workProduct.metadata = {
+ ...(workProduct.metadata as Record<string, unknown>),
+ contentType: "text/markdown",
+ originalFilename: "report.md",
+ };
+ expect(selectAgentArtifactAttachments([promoted], [workProduct])).toEqual([]);
+ });
+});
+
+describe("getAttachmentBackedWorkProductAttachmentIds", () => {
+ it("collects attachment ids across content types", () => {
+ const imageId = "00000000-0000-4000-8000-000000000001";
+ const markdownId = "00000000-0000-4000-8000-000000000002";
+ const markdownWorkProduct = makePromotingWorkProduct(markdownId);
+ markdownWorkProduct.metadata = {
+ ...(markdownWorkProduct.metadata as Record<string, unknown>),
+ contentType: "text/markdown",
+ originalFilename: "report.md",
+ };
+ const ids = getAttachmentBackedWorkProductAttachmentIds([
+ makePromotingWorkProduct(imageId),
+ markdownWorkProduct,
+ ]);
+ expect(ids).toEqual(new Set([imageId, markdownId]));
+ });
+
+ it("ignores non-canonical or non-paperclip work products", () => {
+ const attachmentId = "00000000-0000-4000-8000-000000000003";
+ const foreign = { ...makePromotingWorkProduct(attachmentId), provider: "github" };
+ const invalid = {
+ ...makePromotingWorkProduct(attachmentId),
+ metadata: { attachmentId, openPath: "https://evil.example/content" },
+ };
+ expect(getAttachmentBackedWorkProductAttachmentIds([foreign, invalid])).toEqual(new Set());
+ expect(getAttachmentBackedWorkProductAttachmentIds(null)).toEqual(new Set());
+ });
});
describe("workProductHref", () => {
diff --git a/ui/src/lib/issue-artifacts.ts b/ui/src/lib/issue-artifacts.ts
index 7563638c49..f3f3d8a6d1 100644
--- a/ui/src/lib/issue-artifacts.ts
+++ b/ui/src/lib/issue-artifacts.ts
@@ -1,5 +1,5 @@
import type { IssueAttachment, IssueDocumentSummary, IssueWorkProduct } from "@paperclipai/shared";
-import { getPromotedOutputAttachmentIds } from "./issue-output";
+import { getAttachmentArtifactWorkProductMetadata } from "@paperclipai/shared";
/**
* Selectors for the properties pane's Artifacts tab (PAP-491): which
@@ -19,6 +19,23 @@ export function isAgentAttachment(
return !attachment.createdByUserId && !attachment.issueCommentId;
}
+/**
+ * Attachment ids owned by valid attachment-backed Paperclip work products.
+ * Unlike `getPromotedOutputAttachmentIds`, this includes document-like content
+ * types (e.g. Markdown) that the binary Output surface intentionally excludes,
+ * so it is the right dedupe set for the Artifacts tab's Files section.
+ */
+export function getAttachmentBackedWorkProductAttachmentIds(
+ workProducts: IssueWorkProduct[] | null | undefined,
+): Set<string> {
+ const ids = new Set<string>();
+ for (const workProduct of workProducts ?? []) {
+ const metadata = getAttachmentArtifactWorkProductMetadata(workProduct);
+ if (metadata) ids.add(metadata.attachmentId);
+ }
+ return ids;
+}
+
/**
* Agent-authored attachments minus the ones already promoted to
* attachment-backed work products (`metadata.attachmentId`), so the Artifacts
@@ -28,7 +45,7 @@ export function selectAgentArtifactAttachments(
attachments: IssueAttachment[] | null | undefined,
workProducts: IssueWorkProduct[] | null | undefined,
): IssueAttachment[] {
- const promoted = getPromotedOutputAttachmentIds(workProducts);
+ const promoted = getAttachmentBackedWorkProductAttachmentIds(workProducts);
return (attachments ?? []).filter(
(attachment) => isAgentAttachment(attachment) && !promoted.has(attachment.id),
);
diff --git a/ui/src/lib/issue-attachments.ts b/ui/src/lib/issue-attachments.ts
index a772527522..3f2b4167a5 100644
--- a/ui/src/lib/issue-attachments.ts
+++ b/ui/src/lib/issue-attachments.ts
@@ -1,12 +1,7 @@
import type { IssueAttachment } from "@paperclipai/shared";
+import { isMarkdownAttachmentContent } from "@paperclipai/shared";
import { isVideoLikeOutput } from "./issue-output";
-const GENERIC_ATTACHMENT_CONTENT_TYPES = new Set([
- "application/octet-stream",
- "binary/octet-stream",
- "application/x-binary",
-]);
-
type AttachmentPathLike = {
contentPath: string;
openPath?: string;
@@ -42,17 +37,5 @@ export function isVideoAttachment(
export function isMarkdownAttachment(
attachment: Pick<IssueAttachment, "contentType" | "originalFilename">,
) {
- const contentType = normalizedContentType(attachment);
- if (
- contentType === "text/markdown" ||
- contentType === "text/x-markdown" ||
- contentType === "application/markdown" ||
- contentType === "application/x-markdown"
- ) {
- return true;
- }
-
- const filename = (attachment.originalFilename ?? "").toLowerCase();
- if (!filename.endsWith(".md") && !filename.endsWith(".markdown")) return false;
- return contentType === "text/plain" || GENERIC_ATTACHMENT_CONTENT_TYPES.has(contentType);
+ return isMarkdownAttachmentContent(attachment);
}