@roj-ai/sdk 0.1.13 → 0.1.15

package/src/plugins/uploads/plugin.ts

@@ -2,11 +2,24 @@ import z from 'zod/v4'
 import { ValidationErrors } from '~/core/errors.js'
 import type { FileStore } from '~/core/file-store/types.js'
 import { definePlugin } from '~/core/plugins/plugin-builder.js'
+import { SessionId } from '~/core/sessions/schema.js'
 import { Err, Ok } from '~/lib/utils/result.js'
 import type { PreprocessorRegistry } from './preprocessor.js'
 import { generateUploadId, type MessageAttachment, UploadId, type UploadMetadata } from './schema.js'
 import { type PendingUpload, uploadEvents, type UploadsState } from './state.js'
 
+// ============================================================================
+// Notification schemas
+// ============================================================================
+
+const statusChangedSchema = z.object({
+	sessionId: z.string(),
+	uploadId: z.string(),
+	status: z.enum(['processing', 'ready', 'failed']),
+	extractedContent: z.string().optional(),
+	error: z.string().optional(),
+})
+
 // ============================================================================
 // Constants
 // ============================================================================
@@ -66,6 +79,69 @@ function formatUploadsForLLM(uploads: PendingUpload[], sessionRoot: string): str
 	return blocks.join('\n')
 }
 
+/**
+ * Run preprocessor (with timeout) and persist final upload metadata to disk.
+ * Returns the resolved status + extracted/derived data for the caller to emit.
+ */
+async function runPreprocessAndPersist(args: {
+	uploadId: string
+	sessionId: SessionId
+	uploadStore: FileStore
+	filePath: string
+	filename: string
+	mimeType: string
+	size: number
+	createdAt: number
+	preprocessorRegistry?: PreprocessorRegistry
+}): Promise<{
+	status: 'ready' | 'failed'
+	extractedContent?: string
+	derivedPaths?: string[]
+	error?: string
+}> {
+	const preprocessor = args.preprocessorRegistry?.getForMimeType(args.mimeType)
+
+	let status: 'ready' | 'failed' = 'ready'
+	let extractedContent: string | undefined
+	let derivedPaths: string[] | undefined
+	let errorMessage: string | undefined
+
+	if (preprocessor) {
+		const processPromise = preprocessor.process(args.filePath, args.mimeType, {
+			files: args.uploadStore,
+		})
+		const timeoutPromise = sleep(PROCESSING_TIMEOUT_MS).then(() => ({
+			ok: false as const,
+			error: new Error('Processing timeout'),
+		}))
+		const result = await Promise.race([processPromise, timeoutPromise])
+		if (result.ok) {
+			extractedContent = result.value.extractedContent
+			derivedPaths = result.value.derivedPaths
+		} else {
+			status = 'failed'
+			errorMessage = result.error.message
+		}
+	}
+
+	const metadata: UploadMetadata = {
+		uploadId: UploadId(args.uploadId),
+		sessionId: args.sessionId,
+		filename: args.filename,
+		mimeType: args.mimeType,
+		size: args.size,
+		path: args.filePath,
+		status,
+		extractedContent,
+		derivedPaths,
+		createdAt: args.createdAt,
+		completedAt: Date.now(),
+	}
+	await args.uploadStore.write('meta.json', JSON.stringify(metadata, null, 2))
+
+	return { status, extractedContent, derivedPaths, error: errorMessage }
+}
+
 // ============================================================================
 // Plugin
 // ============================================================================
@@ -73,6 +149,7 @@ function formatUploadsForLLM(uploads: PendingUpload[], sessionRoot: string): str
 export const uploadsPlugin = definePlugin('uploads')
 	.pluginConfig<UploadsPluginConfig>()
 	.events([uploadEvents])
+	.notification('uploadStatusChanged', { schema: statusChangedSchema })
 	.state<UploadsState>({
 		key: 'uploads',
 		initial: (): UploadsState => ({ pending: [] }),
@@ -315,91 +392,179 @@ export const uploadsPlugin = definePlugin('uploads')
 		handler: async (ctx, input) => {
 			const { dataFileStore, preprocessorRegistry } = ctx.pluginConfig
 
-			// Validate
 			if (input.size > MAX_FILE_SIZE) {
 				return Err(ValidationErrors.invalid(`File too large: max ${MAX_FILE_SIZE / (1024 * 1024)}MB`))
 			}
-
 			if (!isAllowedMimeType(input.mimeType)) {
 				return Err(ValidationErrors.invalid(`Unsupported file type: ${input.mimeType}`))
 			}
 
-			// Generate upload ID and scoped store
 			const uploadId = generateUploadId()
 			const uploadStore = dataFileStore.scoped(`sessions/${input.sessionId}/uploads/${uploadId}`)
 
-			// Write file to disk
 			const writeResult = await uploadStore.write(input.filename, input.fileBuffer)
-
 			if (!writeResult.ok) {
 				return Err(ValidationErrors.invalid('Failed to write file'))
 			}
 
-			const filePath = writeResult.value.path
-
-			// Run preprocessor (with timeout)
-			let processingResult: 'success' | 'failed' | 'skipped' = 'skipped'
-			let extractedContent: string | undefined
-			let derivedPaths: string[] | undefined
+			const result = await runPreprocessAndPersist({
+				uploadId: String(uploadId),
+				sessionId: ctx.sessionId,
+				uploadStore,
+				filePath: writeResult.value.path,
+				filename: input.filename,
+				mimeType: input.mimeType,
+				size: input.size,
+				createdAt: Date.now(),
+				preprocessorRegistry,
+			})
 
-			const preprocessor = preprocessorRegistry?.getForMimeType(input.mimeType)
+			await ctx.emitEvent(uploadEvents.create('attachment_uploaded', {
+				uploadId,
+				filename: input.filename,
+				mimeType: input.mimeType,
+				size: input.size,
+				status: result.status,
+				extractedContent: result.extractedContent,
+				derivedPaths: result.derivedPaths,
+				error: result.error,
+			}))
 
-			if (preprocessor) {
-				const processPromise = preprocessor.process(filePath, input.mimeType, {
-					files: uploadStore,
-				})
+			return Ok({
+				uploadId: String(uploadId),
+				status: result.status,
+				extractedContent: result.extractedContent,
+			})
+		},
+	})
+	.method('uploadAsync', {
+		input: z.object({
+			sessionId: z.string(),
+			filename: z.string(),
+			mimeType: z.string(),
+			size: z.number(),
+			fileBuffer: z.custom<Buffer>(),
+		}),
+		output: z.object({
+			uploadId: z.string(),
+			status: z.enum(['processing']),
+		}),
+		handler: async (ctx, input) => {
+			const { dataFileStore, preprocessorRegistry } = ctx.pluginConfig
 
-				const timeoutPromise = sleep(PROCESSING_TIMEOUT_MS).then(() => ({
-					ok: false as const,
-					error: new Error('Processing timeout'),
-				}))
+			if (input.size > MAX_FILE_SIZE) {
+				return Err(ValidationErrors.invalid(`File too large: max ${MAX_FILE_SIZE / (1024 * 1024)}MB`))
+			}
+			if (!isAllowedMimeType(input.mimeType)) {
+				return Err(ValidationErrors.invalid(`Unsupported file type: ${input.mimeType}`))
+			}
 
-				const result = await Promise.race([processPromise, timeoutPromise])
+			const uploadId = generateUploadId()
+			const uploadIdStr = String(uploadId)
+			const uploadStore = dataFileStore.scoped(`sessions/${input.sessionId}/uploads/${uploadId}`)
 
-				if (result.ok) {
-					processingResult = 'success'
-					extractedContent = result.value.extractedContent
-					derivedPaths = result.value.derivedPaths
-				} else {
-					processingResult = 'failed'
-				}
+			const writeResult = await uploadStore.write(input.filename, input.fileBuffer)
+			if (!writeResult.ok) {
+				return Err(ValidationErrors.invalid('Failed to write file'))
 			}
 
-			// Create upload metadata
-			const now = Date.now()
-			const uploadStatus = processingResult === 'failed' ? 'failed' as const : 'ready' as const
-			const metadata: UploadMetadata = {
+			const filePath = writeResult.value.path
+			const createdAt = Date.now()
+
+			// Persist initial 'processing' metadata so listPending sees it before preprocessor finishes.
+			const processingMeta: UploadMetadata = {
 				uploadId,
 				sessionId: ctx.sessionId,
 				filename: input.filename,
 				mimeType: input.mimeType,
 				size: input.size,
 				path: filePath,
-				status: uploadStatus,
-				extractedContent,
-				derivedPaths,
-				createdAt: now,
-				completedAt: now,
+				status: 'processing',
+				createdAt,
+				completedAt: createdAt,
 			}
+			await uploadStore.write('meta.json', JSON.stringify(processingMeta, null, 2))
 
-			// Save metadata
-			await uploadStore.write('meta.json', JSON.stringify(metadata, null, 2))
-
-			// Emit event
 			await ctx.emitEvent(uploadEvents.create('attachment_uploaded', {
 				uploadId,
 				filename: input.filename,
 				mimeType: input.mimeType,
 				size: input.size,
-				status: uploadStatus,
-				extractedContent,
-				derivedPaths,
+				status: 'processing',
 			}))
+			ctx.notify('uploadStatusChanged', {
+				sessionId: input.sessionId,
+				uploadId: uploadIdStr,
+				status: 'processing',
+			})
+
+			// Capture refs from ctx before the handler returns — `notify`/`emitEvent`
+			// closures stay valid for the lifetime of the session, which in roj
+			// outlives any single handler call.
+			const { emitEvent, notify, logger } = ctx
+			const sessionId = ctx.sessionId
+
+			void (async () => {
+				try {
+					const result = await runPreprocessAndPersist({
+						uploadId: uploadIdStr,
+						sessionId,
+						uploadStore,
+						filePath,
+						filename: input.filename,
+						mimeType: input.mimeType,
+						size: input.size,
+						createdAt,
+						preprocessorRegistry,
+					})
+
+					await emitEvent(uploadEvents.create('attachment_uploaded', {
+						uploadId,
+						filename: input.filename,
+						mimeType: input.mimeType,
+						size: input.size,
+						status: result.status,
+						extractedContent: result.extractedContent,
+						derivedPaths: result.derivedPaths,
+						error: result.error,
+					}))
+					notify('uploadStatusChanged', {
+						sessionId: input.sessionId,
+						uploadId: uploadIdStr,
+						status: result.status,
+						extractedContent: result.extractedContent,
+						error: result.error,
+					})
+				} catch (err) {
+					const message = err instanceof Error ? err.message : String(err)
+					logger.error('Async upload processing crashed', err instanceof Error ? err : undefined, {
+						uploadId: uploadIdStr,
+						filename: input.filename,
+					})
+					try {
+						await emitEvent(uploadEvents.create('attachment_uploaded', {
+							uploadId,
+							filename: input.filename,
+							mimeType: input.mimeType,
+							size: input.size,
+							status: 'failed',
+							error: message,
+						}))
+					} catch {
+						// Even event emission failed — best-effort; nothing useful left to do.
+					}
+					notify('uploadStatusChanged', {
+						sessionId: input.sessionId,
+						uploadId: uploadIdStr,
+						status: 'failed',
+						error: message,
+					})
+				}
+			})()
 
 			return Ok({
-				uploadId: String(uploadId),
-				status: uploadStatus,
-				extractedContent,
+				uploadId: uploadIdStr,
+				status: 'processing' as const,
 			})
 		},
 	})

package/src/plugins/uploads/preprocessors/image-classifier.test.ts

@@ -0,0 +1,142 @@
+import { afterAll, beforeAll, describe, expect, it } from 'bun:test'
+import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { SessionFileStore } from '~/core/file-store/file-store.js'
+import { MockLLMProvider } from '~/core/llm/mock.js'
+import { Semaphore } from '~/lib/utils/concurrency.js'
+import { silentLogger } from '../../../lib/logger/logger.js'
+import { createNodePlatform } from '../../../testing/node-platform.js'
+import { ImageClassifierPreprocessor } from './image-classifier.js'
+
+function defer<T = void>(): { promise: Promise<T>; resolve: (v: T) => void } {
+	let resolve!: (v: T) => void
+	const promise = new Promise<T>((res) => {
+		resolve = res
+	})
+	return { promise, resolve }
+}
+
+describe('ImageClassifierPreprocessor.gate', () => {
+	const platform = createNodePlatform()
+	let workDir: string
+
+	beforeAll(async () => {
+		workDir = await mkdtemp(join(tmpdir(), 'roj-classifier-gate-'))
+	})
+
+	afterAll(async () => {
+		await rm(workDir, { recursive: true, force: true }).catch(() => {})
+	})
+
+	it('caps concurrent vision LLM calls when a gate is provided', async () => {
+		const N = 8
+		const LIMIT = 3
+
+		// Track concurrency inside the mock LLM handler — each call increments
+		// `active` on entry, awaits a release barrier, then decrements on exit.
+		let active = 0
+		let peak = 0
+		const release = defer()
+
+		const llmProvider = new MockLLMProvider(async () => {
+			active++
+			peak = Math.max(peak, active)
+			await release.promise
+			active--
+			return {
+				content: 'desc',
+				toolCalls: [],
+				finishReason: 'stop',
+				metrics: MockLLMProvider.defaultMetrics(),
+			}
+		})
+
+		const gate = new Semaphore(LIMIT)
+		const classifier = new ImageClassifierPreprocessor({
+			llmProvider,
+			logger: silentLogger,
+			fs: platform.fs,
+			gate,
+		})
+
+		// Create N tiny dummy image files — content doesn't matter, classifier
+		// only stats them and hands the path to the (mocked) LLM.
+		const imagePaths = await Promise.all(
+			Array.from({ length: N }, async (_, i) => {
+				const p = join(workDir, `img-${i}.png`)
+				await writeFile(p, Buffer.from([0x89, 0x50, 0x4e, 0x47]))
+				return p
+			}),
+		)
+
+		const fileStore = new SessionFileStore(workDir, undefined, false, platform.fs, 'session')
+
+		const tasks = imagePaths.map((p, i) =>
+			classifier.process(p, 'image/png', { files: fileStore.scoped(`img-${i}-meta`) }),
+		)
+
+		// Let the workers queue up; the first LIMIT should be in-flight.
+		await new Promise(r => setTimeout(r, 20))
+		expect(active).toBeLessThanOrEqual(LIMIT)
+		expect(active).toBe(LIMIT)
+
+		// Release everyone; wait for completion and check peak.
+		release.resolve()
+		const results = await Promise.all(tasks)
+
+		expect(peak).toBe(LIMIT)
+		expect(active).toBe(0)
+		expect(llmProvider.getCallCount()).toBe(N)
+		for (const r of results) {
+			expect(r.ok).toBe(true)
+		}
+	})
+
+	it('does not gate when no semaphore is provided (all run concurrently)', async () => {
+		const N = 6
+		let active = 0
+		let peak = 0
+		const release = defer()
+
+		const llmProvider = new MockLLMProvider(async () => {
+			active++
+			peak = Math.max(peak, active)
+			await release.promise
+			active--
+			return {
+				content: 'desc',
+				toolCalls: [],
+				finishReason: 'stop',
+				metrics: MockLLMProvider.defaultMetrics(),
+			}
+		})
+
+		const classifier = new ImageClassifierPreprocessor({
+			llmProvider,
+			logger: silentLogger,
+			fs: platform.fs,
+		})
+
+		const imagePaths = await Promise.all(
+			Array.from({ length: N }, async (_, i) => {
+				const p = join(workDir, `nogate-${i}.png`)
+				await writeFile(p, Buffer.from([0x89, 0x50, 0x4e, 0x47]))
+				return p
+			}),
+		)
+
+		const fileStore = new SessionFileStore(workDir, undefined, false, platform.fs, 'session')
+
+		const tasks = imagePaths.map((p, i) =>
+			classifier.process(p, 'image/png', { files: fileStore.scoped(`nogate-${i}-meta`) }),
+		)
+
+		await new Promise(r => setTimeout(r, 20))
+		expect(active).toBe(N)
+
+		release.resolve()
+		await Promise.all(tasks)
+		expect(peak).toBe(N)
+	})
+})

package/src/plugins/uploads/preprocessors/image-classifier.ts

@@ -7,6 +7,7 @@
 
 import type { LLMProvider } from '~/core/llm/provider.js'
 import { ModelId } from '~/core/llm/schema.js'
+import type { Semaphore } from '~/lib/utils/concurrency.js'
 import type { Result } from '~/lib/utils/result.js'
 import { Err, Ok } from '~/lib/utils/result.js'
 import type { FileSystem } from '~/platform/fs.js'
@@ -28,6 +29,13 @@ export interface ImageClassifierConfig {
 	fs: FileSystem
 	/** Whether to skip vision and just return metadata */
 	skipVision?: boolean
+	/**
+	 * Optional semaphore to bound concurrent vision LLM calls. All callers
+	 * sharing one instance compete for the same set of permits — useful when
+	 * recursive preprocessors (ZIP → docs → images) would otherwise fan out
+	 * into many simultaneous inferences.
+	 */
+	gate?: Semaphore
 }
 
 // ============================================================================
@@ -47,6 +55,7 @@ export class ImageClassifierPreprocessor implements Preprocessor {
 	private readonly logger: Logger
 	private readonly fs: FileSystem
 	private readonly skipVision: boolean
+	private readonly gate: Semaphore | undefined
 
 	constructor(config: ImageClassifierConfig) {
 		this.llmProvider = config.llmProvider
@@ -54,6 +63,7 @@ export class ImageClassifierPreprocessor implements Preprocessor {
 		this.logger = config.logger
 		this.fs = config.fs
 		this.skipVision = config.skipVision ?? false
+		this.gate = config.gate
 	}
 
 	async process(
@@ -124,7 +134,7 @@ export class ImageClassifierPreprocessor implements Preprocessor {
 	): Promise<string | null> {
 		try {
 			// Use file:// URL - resolved to base64 lazily in LLM provider
-			const result = await this.llmProvider.inference({
+			const inferenceCall = () => this.llmProvider.inference({
 				model: this.visionModel,
 				systemPrompt: 'You are an image description assistant. Describe images concisely in 1-2 sentences.',
 				messages: [
@@ -146,6 +156,8 @@ export class ImageClassifierPreprocessor implements Preprocessor {
 				temperature: 0.3,
 			})
 
+			const result = await (this.gate ? this.gate.run(inferenceCall) : inferenceCall())
+
 			if (result.ok && result.value.content) {
 				return result.value.content.trim()
 			}

package/src/plugins/uploads/preprocessors/markitdown-preprocessor.ts

@@ -13,6 +13,7 @@
  */
 
 import { dirname } from 'node:path'
+import { mapWithConcurrency } from '~/lib/utils/concurrency.js'
 import type { Result } from '~/lib/utils/result.js'
 import { Err, Ok } from '~/lib/utils/result.js'
 import type { FileSystem } from '~/platform/fs.js'
@@ -22,6 +23,7 @@ import type { Logger } from '../../../lib/logger/logger.js'
 import type { Preprocessor, PreprocessorContext, PreprocessorRegistry, PreprocessorResult } from '../preprocessor.js'
 
 const MAX_IMAGES = 50
+const IMAGE_CLASSIFY_CONCURRENCY = 10
 
 function makeExec(processRunner: ProcessRunner) {
 	return (cmd: string, args: string[]) => processRunner.execFile(cmd, args, { timeout: 60_000, maxBuffer: 50 * 1024 * 1024 })
@@ -228,19 +230,17 @@ export async function classifyExtractedImages(
 	registry: PreprocessorRegistry,
 	logger: Logger,
 ): Promise<Array<{ relativePath: string; description: string }>> {
-	const results: Array<{ relativePath: string; description: string }> = []
-
 	const listResult = await imageStore.list('', { maxDepth: 3 })
-	if (!listResult.ok) return results
+	if (!listResult.ok) return []
 
 	const imageFiles = listResult.value
 		.filter(e => e.type === 'file' && IMAGE_EXT_RE.test(e.name))
 		.sort((a, b) => a.name.localeCompare(b.name))
 		.slice(0, MAX_IMAGES)
 
-	for (const imgFile of imageFiles) {
+	const settled = await mapWithConcurrency(imageFiles, IMAGE_CLASSIFY_CONCURRENCY, async (imgFile) => {
 		const imgPathResult = imageStore.realPath(imgFile.name)
-		if (!imgPathResult.ok) continue
+		if (!imgPathResult.ok) return null
 
 		const imgMime = guessImageMime(imgFile.name)
 		let description = imgMime
@@ -255,8 +255,8 @@ export async function classifyExtractedImages(
 			}
 		}
 
-		results.push({ relativePath: `${relativePrefix}/${imgFile.name}`, description })
-	}
+		return { relativePath: `${relativePrefix}/${imgFile.name}`, description }
+	})
 
-	return results
+	return settled.filter((r): r is { relativePath: string; description: string } => r !== null)
 }

package/src/plugins/uploads/preprocessors/zip-preprocessor.ts

@@ -8,6 +8,7 @@
  */
 
 import { extname } from 'node:path'
+import { mapWithConcurrency } from '~/lib/utils/concurrency.js'
 import type { Result } from '~/lib/utils/result.js'
 import { Err, Ok } from '~/lib/utils/result.js'
 import type { ProcessRunner } from '~/platform/process.js'
@@ -17,6 +18,7 @@ import type { Preprocessor, PreprocessorContext, PreprocessorRegistry, Preproces
 const MAX_DEPTH = 3
 const MAX_FILES = 500
 const MAX_TOTAL_SIZE = 100 * 1024 * 1024 // 100MB
+const ZIP_FILE_CONCURRENCY = 10
 
 const MIME_MAP: Record<string, string> = {
 	'.pdf': 'application/pdf',
@@ -116,38 +118,45 @@ export class ZipPreprocessor implements Preprocessor {
 			return Err(new Error('Failed to list extracted files'))
 		}
 
-		const derivedPaths: string[] = []
-		const manifest: string[] = []
-		let fileCount = 0
-		let totalSize = 0
-
 		const files = listResult.value
 			.filter(e => e.type === 'file')
 			.sort((a, b) => a.name.localeCompare(b.name))
 
+		// Pick eligible files first (limits depend on cumulative iteration order, so this stays sequential)
+		const eligible: typeof files = []
+		let totalSize = 0
+		let truncationNotice: string | null = null
+
 		for (const file of files) {
-			if (fileCount >= MAX_FILES) {
-				manifest.push(`... (truncated, ${files.length - fileCount} more files)`)
+			if (eligible.length >= MAX_FILES) {
+				truncationNotice = `... (truncated, ${files.length - eligible.length} more files)`
 				break
 			}
-
 			const fileSize = file.size ?? 0
-			totalSize += fileSize
-			if (totalSize > MAX_TOTAL_SIZE) {
-				manifest.push('... (total size limit reached)')
+			if (totalSize + fileSize > MAX_TOTAL_SIZE) {
+				truncationNotice = '... (total size limit reached)'
 				break
 			}
+			totalSize += fileSize
+			eligible.push(file)
+		}
+
+		const fileCount = eligible.length
 
-			fileCount++
+		// Process eligible files in parallel with bounded concurrency
+		const processed = await mapWithConcurrency(eligible, ZIP_FILE_CONCURRENCY, async (file) => {
+			const collectedPaths: string[] = []
 
 			const fileRealPath = extractStore.realPath(file.name)
 			if (!fileRealPath.ok) {
-				manifest.push(`- ${file.name} (path resolution failed)`)
-				continue
+				return {
+					manifestEntry: `- ${file.name} (path resolution failed)`,
+					derivedPaths: collectedPaths,
+				}
 			}
 
 			const relativePath = `extracted/${file.name}`
-			derivedPaths.push(relativePath)
+			collectedPaths.push(relativePath)
 
 			const mime = getMimeType(file.name)
 			let contentSummary = ''
@@ -171,7 +180,7 @@ export class ZipPreprocessor implements Preprocessor {
 					if (subResult.ok) {
 						if (subResult.value.derivedPaths) {
 							for (const dp of subResult.value.derivedPaths) {
-								derivedPaths.push(`extracted/${file.name}-content/${dp}`)
+								collectedPaths.push(`extracted/${file.name}-content/${dp}`)
 							}
 						}
 						if (subResult.value.extractedContent) {
@@ -186,8 +195,19 @@ export class ZipPreprocessor implements Preprocessor {
 				}
 			}
 
-			manifest.push(`- ${file.name} (${formatSize(fileSize)})${contentSummary}`)
+			return {
+				manifestEntry: `- ${file.name} (${formatSize(file.size ?? 0)})${contentSummary}`,
+				derivedPaths: collectedPaths,
+			}
+		})
+
+		const derivedPaths: string[] = []
+		const manifest: string[] = []
+		for (const item of processed) {
+			derivedPaths.push(...item.derivedPaths)
+			manifest.push(item.manifestEntry)
 		}
+		if (truncationNotice) manifest.push(truncationNotice)
 
 		const fullManifest = `## ZIP Contents (${fileCount} files)\n\n${manifest.join('\n')}`
 

package/src/plugins/uploads/state.ts

@@ -9,7 +9,7 @@ export const uploadEvents = createEventsFactory({
 			filename: z4.string(),
 			mimeType: z4.string(),
 			size: z4.number(),
-			status: z4.enum(['ready', 'failed']),
+			status: z4.enum(['processing', 'ready', 'failed']),
 			extractedContent: z4.string().optional(),
 			derivedPaths: z4.array(z4.string()).optional(),
 			error: z4.string().optional(),