@xopcai/xopc 0.0.210 → 0.0.211

package/dist/src/connectors/content-enrichment.js

@@ -0,0 +1,273 @@
+import { getKnowledgeSourceItem, listKnowledgeSourceItems, upsertKnowledgeSourceItems } from "../storage/sqlite/knowledge-repository.js";
+import { getConnectorConnection, getConnectorInstallation } from "../storage/sqlite/connector-repository.js";
+import "../storage/sqlite/index.js";
+import { ComposioSessionsAdapter } from "./composio-sessions.js";
+import { ConnectedKnowledgePipeline } from "../knowledge/connected-knowledge-pipeline.js";
+import { sanitizeConnectedSourceValue } from "./connected-source-sanitization.js";
+import { tmpdir } from "node:os";
+import { isAbsolute, join, relative, sep } from "node:path";
+import { createHash } from "node:crypto";
+import { mkdtemp, readFile, realpath, rm } from "node:fs/promises";
+//#region src/connectors/content-enrichment.ts
+const MAX_SELECTION = 5;
+const MAX_CONTENT_BYTES = 1e6;
+const MAX_CONTENT_CHARS = 24e3;
+const GOOGLE_DOCUMENT_MIME = "application/vnd.google-apps.document";
+const DOWNLOADABLE_TEXT_MIMES = new Set([
+	"application/json",
+	"application/xml",
+	"text/csv",
+	"text/html",
+	"text/markdown",
+	"text/plain",
+	"text/tab-separated-values",
+	"text/xml"
+]);
+function record(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function normalizedRecord(item) {
+	if (!item.normalizedText) return {};
+	try {
+		return record(JSON.parse(item.normalizedText));
+	} catch {
+		return {};
+	}
+}
+function text(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function candidateFor(item) {
+	if (item.deletedAt || item.sensitivity === "secret" || item.sensitivity === "regulated") return void 0;
+	const toolkit = text(item.metadata.toolkit);
+	const value = normalizedRecord(item);
+	const title = text(value.title) ?? text(value.subject);
+	if (!title) return void 0;
+	if (toolkit === "gmail" && item.itemType === "email") return {
+		sourceItemId: item.id,
+		sourceInstanceId: item.sourceInstanceId,
+		toolkit,
+		title,
+		occurredAt: item.occurredAt
+	};
+	const mimeType = text(item.metadata.mimeType) ?? text(value.mimeType);
+	if (toolkit === "googledrive" && item.itemType === "cloud_document" && mimeType && (mimeType === GOOGLE_DOCUMENT_MIME || DOWNLOADABLE_TEXT_MIMES.has(mimeType))) return {
+		sourceItemId: item.id,
+		sourceInstanceId: item.sourceInstanceId,
+		toolkit,
+		title,
+		occurredAt: item.occurredAt,
+		mimeType
+	};
+}
+function listConnectedContentCandidates(options) {
+	const limit = Math.max(1, Math.min(20, options.limit ?? 10));
+	const items = listKnowledgeSourceItems({
+		agentId: options.agentId,
+		includeDeleted: false,
+		limit: 500
+	});
+	const completedReads = new Set(items.map((item) => text(item.metadata.sourceMetadataItemId)).filter((id) => Boolean(id)));
+	return items.filter((item) => !completedReads.has(item.id)).map(candidateFor).filter((candidate) => Boolean(candidate)).slice(0, limit);
+}
+function contentRecipe(item) {
+	const toolkit = text(item.metadata.toolkit);
+	if (toolkit === "gmail" && item.itemType === "email") return {
+		actionId: "GMAIL_GET_EMAIL",
+		args: { message_id: item.externalId },
+		mode: "inline"
+	};
+	const value = normalizedRecord(item);
+	const mimeType = text(item.metadata.mimeType) ?? text(value.mimeType);
+	if (toolkit === "googledrive" && item.itemType === "cloud_document" && mimeType === GOOGLE_DOCUMENT_MIME) return {
+		actionId: "GOOGLEDRIVE_EXPORT_GOOGLE_WORKSPACE_FILE",
+		args: {
+			fileId: item.externalId,
+			mimeType: "text/plain"
+		},
+		mode: "file"
+	};
+	if (toolkit === "googledrive" && item.itemType === "cloud_document" && mimeType && DOWNLOADABLE_TEXT_MIMES.has(mimeType)) return {
+		actionId: "GOOGLEDRIVE_DOWNLOAD_FILE",
+		args: { file_id: item.externalId },
+		mode: "file"
+	};
+	throw new Error("This source item does not support bounded content reading.");
+}
+function collectInlineText(value, output, depth = 0) {
+	if (depth > 8 || output.join("\n").length >= MAX_CONTENT_CHARS) return;
+	if (Array.isArray(value)) {
+		for (const item of value) collectInlineText(item, output, depth + 1);
+		return;
+	}
+	const row = record(value);
+	for (const [key, nested] of Object.entries(row)) {
+		if (typeof nested === "string" && [
+			"body",
+			"content",
+			"plainText",
+			"plain_text",
+			"snippet",
+			"text"
+		].includes(key)) {
+			if (nested.trim()) output.push(nested.trim());
+			continue;
+		}
+		if (nested && typeof nested === "object") collectInlineText(nested, output, depth + 1);
+	}
+}
+function inlineContent(result) {
+	const values = [];
+	collectInlineText(result, values);
+	return [...new Set(values)].join("\n\n").slice(0, MAX_CONTENT_CHARS);
+}
+function candidateFilePaths(value, output, depth = 0) {
+	if (depth > 8) return;
+	if (typeof value === "string") {
+		if (value.startsWith("file://")) output.push(new URL(value).pathname);
+		else if (isAbsolute(value)) output.push(value);
+		return;
+	}
+	if (Array.isArray(value)) {
+		for (const item of value) candidateFilePaths(item, output, depth + 1);
+		return;
+	}
+	for (const nested of Object.values(record(value))) candidateFilePaths(nested, output, depth + 1);
+}
+async function downloadedContent(result, downloadDirectory) {
+	const directory = await realpath(downloadDirectory);
+	const paths = [];
+	candidateFilePaths(result, paths);
+	for (const path of paths) {
+		const resolved = await realpath(path).catch(() => void 0);
+		if (!resolved) continue;
+		const pathFromDirectory = relative(directory, resolved);
+		if (pathFromDirectory.startsWith(`..${sep}`) || pathFromDirectory === ".." || isAbsolute(pathFromDirectory)) continue;
+		const content = await readFile(resolved);
+		if (content.byteLength > MAX_CONTENT_BYTES) throw new Error("Downloaded content exceeds the 1 MB read limit.");
+		return content.toString("utf8").slice(0, MAX_CONTENT_CHARS);
+	}
+	throw new Error("The connector did not return readable text content.");
+}
+function updatedSourceItem(item, content, actionId) {
+	const contentReadAt = (/* @__PURE__ */ new Date()).toISOString();
+	const sanitizedContent = String(sanitizeConnectedSourceValue(content));
+	const normalizedText = JSON.stringify({
+		...normalizedRecord(item),
+		content: sanitizedContent,
+		contentReadAt
+	});
+	return {
+		sourceInstanceId: item.sourceInstanceId,
+		collectionScope: "content-reads",
+		externalId: item.id,
+		itemType: "connected_content",
+		authorRole: item.authorRole,
+		occurredAt: item.occurredAt,
+		sourceUpdatedAt: item.sourceUpdatedAt,
+		contentHash: createHash("sha256").update(normalizedText).digest("hex"),
+		normalizedText,
+		payloadRef: item.payloadRef,
+		metadata: {
+			...item.metadata,
+			explicitContentRead: true,
+			sourceMetadataItemId: item.id,
+			contentReadActionId: actionId,
+			contentReadAt
+		},
+		sensitivity: item.sensitivity,
+		retentionClass: "bounded",
+		synthesisPipeline: "connected_knowledge",
+		synthesisStatus: "pending"
+	};
+}
+async function readConnectedContent(input) {
+	const sourceItemIds = [...new Set(input.sourceItemIds.map((id) => id.trim()).filter(Boolean))];
+	if (!sourceItemIds.length || sourceItemIds.length > MAX_SELECTION) throw new Error(`Select between 1 and ${MAX_SELECTION} source items.`);
+	const downloadDirectory = await mkdtemp(join(tmpdir(), "xopc-content-read-"));
+	const adapter = input.adapterFactory?.(downloadDirectory) ?? new ComposioSessionsAdapter({ fileDownloadDir: downloadDirectory });
+	const result = {
+		requested: sourceItemIds.length,
+		completed: 0,
+		failed: [],
+		recordIds: []
+	};
+	const updatedSources = /* @__PURE__ */ new Set();
+	const completedReads = new Set(listKnowledgeSourceItems({
+		agentId: input.agentId,
+		includeDeleted: false,
+		limit: 500
+	}).map((item) => text(item.metadata.sourceMetadataItemId)).filter((id) => Boolean(id)));
+	try {
+		for (const sourceItemId of sourceItemIds) try {
+			const item = getKnowledgeSourceItem(sourceItemId);
+			if (!item || item.deletedAt || item.metadata.agentId !== input.agentId) throw new Error("Source item is unavailable.");
+			if (completedReads.has(item.id)) throw new Error("Source item content was already read.");
+			if (!candidateFor(item)) throw new Error("Source item is not eligible for content reading.");
+			const connectorId = text(item.metadata.connectorId);
+			const connectionId = text(item.metadata.connectionId);
+			const toolkit = text(item.metadata.toolkit);
+			if (!connectorId || !connectionId || !toolkit) throw new Error("Source item has incomplete connector provenance.");
+			const connection = getConnectorConnection(connectionId);
+			const installation = getConnectorInstallation(`${connectorId}-local-owner`);
+			if (!connection || connection.status !== "active" || !installation?.enabled) throw new Error("The connected account is not active.");
+			const recipe = contentRecipe(item);
+			const execution = await adapter.executeWithPolicy({
+				context: {
+					principalId: connection.principalId,
+					toolkits: [toolkit]
+				},
+				installation: {
+					...installation,
+					maxScope: "read",
+					confirmationPolicy: "always"
+				},
+				connection,
+				agentId: input.agentId,
+				action: {
+					connectorId,
+					actionId: recipe.actionId,
+					toolkit,
+					scope: "read",
+					curated: true,
+					cachedAt: (/* @__PURE__ */ new Date()).toISOString()
+				},
+				args: recipe.args,
+				confirmed: true
+			});
+			if (execution.decision !== "allowed") throw new Error(execution.reason);
+			const content = recipe.mode === "inline" ? inlineContent(execution.result) : await downloadedContent(execution.result, downloadDirectory);
+			if (!content.trim()) throw new Error("The connector returned empty text content.");
+			upsertKnowledgeSourceItems([updatedSourceItem(item, content, recipe.actionId)]);
+			completedReads.add(item.id);
+			updatedSources.add(item.sourceInstanceId);
+			result.completed += 1;
+		} catch (error) {
+			result.failed.push({
+				sourceItemId,
+				error: error instanceof Error ? error.message : String(error)
+			});
+		}
+		for (const sourceInstanceId of updatedSources) {
+			const item = listKnowledgeSourceItems({
+				sourceInstanceId,
+				synthesisStatus: "pending",
+				limit: 1
+			})[0];
+			if (!item) continue;
+			const synthesized = await new ConnectedKnowledgePipeline({
+				agentId: input.agentId,
+				workspaceId: text(item.metadata.workspaceId) ?? "default"
+			}).processPending(sourceInstanceId);
+			result.recordIds.push(...synthesized.recordIds);
+		}
+		return result;
+	} finally {
+		await rm(downloadDirectory, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+//#endregion
+export { listConnectedContentCandidates, readConnectedContent };

package/dist/src/connectors/health.js

@@ -1,6 +1,6 @@
+import { getWorkspacePath } from "../config/workspace-path-helpers.js";
 import { materializeConnectorMcpServer } from "./materialize.js";
 import { getConnectorInstance } from "./instances.js";
-import { getWorkspacePath } from "../config/workspace-path-helpers.js";
 import { listBundleMcpServerCapabilitiesForGateway } from "../agent/mcp/bundle-mcp-gateway.js";
 //#region src/connectors/health.ts
 function classifyConnectorHealthError(error) {

package/dist/src/connectors/learning-coordinator.js

@@ -27,7 +27,6 @@ function connectorSourceCategory(toolkit) {
 	if (toolkit === "gmail") return "mail";
 	if (toolkit === "googlecalendar") return "calendar";
 	if (toolkit === "github" || toolkit === "linear") return "code_activity";
-	if (toolkit === "slack") return "messages";
 	return "files";
 }
 function ensureUnderstandingSourceRun(job, toolkit, displayName) {
@@ -189,7 +188,7 @@ function startConnectorLearningCoordinator(options) {
 			itemsIndexed
 		}));
 		publish(updateConnectorLearningJob(job.id, { phase: "deriving" }));
-		const understanding = await new ConnectedUnderstandingPipeline(options.getMemoryManager()).process(job.sourceInstanceId, job.connectorId, job.agentId);
+		const understanding = await new ConnectedUnderstandingPipeline(options.getMemoryManager()).process(job.agentId);
 		for (const record of understanding.createdRecords.filter((item) => item.kind === "project_context")) upsertUserFocus({
 			canonicalKey: `connector-focus:${job.accountId}:${record.id}`,
 			title: record.content.slice(0, 120),

package/dist/src/connectors/learning-recipes.js

@@ -1,5 +1,7 @@
+import { decodeConnectedSourceCursor } from "./connected-source-cursor.js";
 //#region src/connectors/learning-recipes.ts
 function buildConnectorLearningArguments(plan, stream, input, identity) {
+	const cursor = decodeConnectedSourceCursor(input.cursor);
 	if (plan.toolkit === "github" && stream.scope === "authored-work") {
 		const username = typeof identity.username === "string" ? identity.username.trim() : "";
 		if (!username) throw new Error("GitHub activity sync requires the authenticated username.");
@@ -8,18 +10,28 @@ function buildConnectorLearningArguments(plan, stream, input, identity) {
 			q: `author:${username} sort:updated-desc`
 		};
 	}
-	if (!input.cursor) return { ...stream.arguments };
 	if (plan.toolkit === "gmail") {
-		const after = Math.floor(Date.parse(input.cursor) / 1e3);
-		return Number.isFinite(after) ? {
+		const after = cursor?.checkpoint ? Math.floor(Date.parse(cursor.checkpoint) / 1e3) : NaN;
+		return {
 			...stream.arguments,
-			query: `after:${after} -in:spam -in:trash`
-		} : { ...stream.arguments };
+			...Number.isFinite(after) ? { query: `after:${after} -in:spam -in:trash` } : {},
+			...cursor?.pageToken ? { page_token: cursor.pageToken } : {}
+		};
 	}
 	if (plan.toolkit === "googlecalendar") return {
 		...stream.arguments,
-		time_min: input.cursor
+		...cursor?.syncToken ? { sync_token: cursor.syncToken } : {},
+		...cursor?.pageToken ? { page_token: cursor.pageToken } : {}
 	};
+	if (plan.toolkit === "googledrive") {
+		const checkpoint = cursor?.checkpoint && Number.isFinite(Date.parse(cursor.checkpoint)) ? cursor.checkpoint : void 0;
+		const baseQuery = typeof stream.arguments.q === "string" ? stream.arguments.q : "";
+		return {
+			...stream.arguments,
+			...checkpoint ? { q: [baseQuery, `modifiedTime > '${checkpoint}'`].filter(Boolean).join(" and ") } : {},
+			...cursor?.pageToken ? { pageToken: cursor.pageToken } : {}
+		};
+	}
 	return { ...stream.arguments };
 }
 const PLANS = {
@@ -42,47 +54,30 @@ const PLANS = {
 		toolkit: "googlecalendar",
 		streams: [{
 			scope: "events",
-			actionId: "GOOGLECALENDAR_LIST_EVENTS",
+			actionId: "GOOGLECALENDAR_SYNC_EVENTS",
 			kind: "activity",
-			arguments: { max_results: 200 }
+			arguments: { max_results: 500 }
 		}],
 		bootstrapWindowDays: 90,
 		intervalMinutes: 15
 	},
 	googledrive: {
 		toolkit: "googledrive",
+		identityProbe: { actionId: "GOOGLEDRIVE_GET_ABOUT" },
 		streams: [{
 			scope: "files",
-			actionId: "GOOGLEDRIVE_SEARCH_FILES",
+			actionId: "GOOGLEDRIVE_FIND_FILE",
 			kind: "inventory",
-			arguments: {}
-		}],
-		bootstrapWindowDays: 90,
-		intervalMinutes: 30
-	},
-	notion: {
-		toolkit: "notion",
-		streams: [{
-			scope: "pages",
-			actionId: "NOTION_SEARCH",
-			kind: "inventory",
-			arguments: {}
+			arguments: {
+				q: "trashed = false",
+				orderBy: "modifiedTime desc",
+				pageSize: 100,
+				fields: "nextPageToken,files(id,name,mimeType,createdTime,modifiedTime,owners,webViewLink,trashed)"
+			}
 		}],
 		bootstrapWindowDays: 90,
 		intervalMinutes: 30
 	},
-	slack: {
-		toolkit: "slack",
-		identityProbe: { actionId: "SLACK_TEST_AUTH" },
-		streams: [{
-			scope: "channels",
-			actionId: "SLACK_LIST_CHANNELS",
-			kind: "inventory",
-			arguments: {}
-		}],
-		bootstrapWindowDays: 30,
-		intervalMinutes: 15
-	},
 	github: {
 		toolkit: "github",
 		identityProbe: { actionId: "GITHUB_GET_THE_AUTHENTICATED_USER" },

package/dist/src/discussions/live-worker.d.ts

@@ -28,6 +28,7 @@ export declare class DiscussionLiveWorker {
     start(): void;
     stop(): Promise<void>;
     tick(): Promise<void>;
+    private resolveConcurrency;
     private processOne;
     private transcribeSegment;
     private enrichOnce;

package/dist/src/discussions/live-worker.js

@@ -42,13 +42,19 @@ var DiscussionLiveWorker = class {
 		if (this.running) return;
 		this.running = true;
 		try {
-			await Promise.all(Array.from({ length: this.concurrency }, () => this.processOne()));
+			await Promise.all(Array.from({ length: this.resolveConcurrency() }, () => this.processOne()));
 		} finally {
 			this.running = false;
 			const waiters = this.stoppedWaiters.splice(0);
 			for (const resolve of waiters) resolve();
 		}
 	}
+	resolveConcurrency() {
+		if (this.deps.transcribeSegment) return this.concurrency;
+		const config = this.deps.getConfig();
+		const sttConfig = mergeSttConfigFromAppConfig(config.tools?.media?.audio, config.tools?.media);
+		return sttConfig.provider === "xopc-local" || sttConfig.provider === "local" ? 1 : this.concurrency;
+	}
 	async processOne() {
 		const segment = claimNextDiscussionTranscriptSegment(this.owner);
 		if (!segment) return;

package/dist/src/discussions/repository.js

@@ -128,13 +128,23 @@ function getDiscussionMetrics() {
       WHERE s.discussion_id = d.id AND s.status = 'confirmed') - d.recording_started_at) first_ms,
     AVG(CASE WHEN d.completed_at IS NOT NULL THEN d.completed_at - d.recording_started_at END) complete_ms
     FROM discussion_captures d`).get();
+	const segmentMetrics = db.prepare(`SELECT
+    COUNT(*) total,
+    SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END) failed,
+    SUM(CASE WHEN attempt_count > 1 THEN 1 ELSE 0 END) retried,
+    AVG(CASE WHEN status = 'confirmed' THEN updated_at - created_at END) latency_ms
+    FROM discussion_transcript_segments`).get();
 	const byStatus = Object.fromEntries(DISCUSSION_STATUSES.map((status) => [status, 0]));
 	for (const row of rows) byStatus[row.status] = row.count;
 	return {
 		total: rows.reduce((sum, row) => sum + row.count, 0),
 		byStatus,
 		averageTimeToFirstTranscriptMs: timing.first_ms == null ? null : Math.max(0, Math.round(timing.first_ms)),
-		averageTimeToCompleteMs: timing.complete_ms == null ? null : Math.max(0, Math.round(timing.complete_ms))
+		averageTimeToCompleteMs: timing.complete_ms == null ? null : Math.max(0, Math.round(timing.complete_ms)),
+		totalSegments: segmentMetrics.total,
+		failedSegments: segmentMetrics.failed ?? 0,
+		retriedSegments: segmentMetrics.retried ?? 0,
+		averageSegmentLatencyMs: segmentMetrics.latency_ms == null ? null : Math.max(0, Math.round(segmentMetrics.latency_ms))
 	};
 }
 function updateDiscussionCapture(id, patch, expectedStatuses) {

package/dist/src/discussions/sealer.d.ts

@@ -4,7 +4,7 @@ import type { DiscussionCapture } from './types.js';
 export interface DiscussionSealerDeps {
     notes: NotesService;
     getConfig: () => Config;
-    transcribeRecording?: (buffer: Buffer, capture: DiscussionCapture, signal?: AbortSignal) => Promise<{
+    transcribeRecording?: (filePath: string, capture: DiscussionCapture, signal?: AbortSignal) => Promise<{
         text: string;
         language?: string;
     }>;

package/dist/src/discussions/sealer.js

@@ -1,13 +1,13 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
+import { forEachNormalizedAudioSegment } from "../voice/audio/normalize.js";
 import { transcribe } from "../voice/stt/transcribe-core.js";
 import { isSTTAvailable } from "../voice/stt/availability.js";
 import { mergeSttConfigFromAppConfig } from "../voice/stt/config.js";
 import "../voice/stt/index.js";
 import { getDiscussionCapture, listDiscussionCaptures, listDiscussionTranscriptSegments, updateDiscussionCapture } from "./repository.js";
-import { assembleDiscussionTranscript } from "./transcript.js";
+import { appendTranscriptWithoutOverlap, assembleDiscussionTranscript } from "./transcript.js";
 import { createHash } from "node:crypto";
-import { readFile } from "node:fs/promises";
 //#region src/discussions/sealer.ts
 init_logger();
 const log = createLogger("DiscussionSealer");
@@ -85,15 +85,24 @@ var DiscussionSealer = class {
 	async transcribeFullRecording(capture) {
 		const attachment = await this.deps.notes.getAttachmentPath(capture.noteId, capture.audioAttachmentId);
 		if (!attachment) throw new Error("Discussion audio file is missing");
-		const buffer = await readFile(attachment.filePath);
-		if (this.deps.transcribeRecording) return this.deps.transcribeRecording(buffer, capture);
+		if (this.deps.transcribeRecording) return this.deps.transcribeRecording(attachment.filePath, capture);
 		const config = this.deps.getConfig();
 		const sttConfig = mergeSttConfigFromAppConfig(config.tools?.media?.audio, config.tools?.media);
 		if (!isSTTAvailable(sttConfig)) throw new Error("STT is not configured");
-		return transcribe(buffer, sttConfig, {
-			mime: attachment.mimeType || capture.mimeType,
-			fileName: attachment.fileName
+		let text = "";
+		let language;
+		await forEachNormalizedAudioSegment({ filePath: attachment.filePath }, async (buffer, index) => {
+			const result = await transcribe(buffer, sttConfig, {
+				mime: "audio/wav",
+				fileName: `discussion-recovery-${index}.wav`
+			});
+			text = appendTranscriptWithoutOverlap(text, result.text);
+			language ??= result.language;
 		});
+		return {
+			text,
+			...language ? { language } : {}
+		};
 	}
 	fail(capture, stage, code, message) {
 		const current = getDiscussionCapture(capture.id);

package/dist/src/discussions/transcript.js

@@ -1,11 +1,37 @@
 //#region src/discussions/transcript.ts
+function searchableCharacters(value) {
+	let text = "";
+	const sourceEnds = [];
+	let sourceOffset = 0;
+	for (const character of value) {
+		sourceOffset += character.length;
+		if (!/[\p{L}\p{N}]/u.test(character)) continue;
+		text += character.toLocaleLowerCase();
+		sourceEnds.push(sourceOffset);
+	}
+	return {
+		text,
+		sourceEnds
+	};
+}
+function joinOverlap(left, remainder) {
+	return `${left}${/[\p{P}\p{S}]$/u.test(left) ? remainder.replace(/^[\s\p{P}\p{S}]+/u, "") : remainder}`.trim();
+}
 function appendTranscriptWithoutOverlap(existing, next) {
 	const left = existing.trim();
 	const right = next.trim();
 	if (!left) return right;
 	if (!right) return left;
 	const max = Math.min(200, left.length, right.length);
-	for (let size = max; size >= 8; size -= 1) if (left.slice(-size).toLocaleLowerCase() === right.slice(0, size).toLocaleLowerCase()) return `${left}${right.slice(size)}`.trim();
+	for (let size = max; size >= 8; size -= 1) if (left.slice(-size).toLocaleLowerCase() === right.slice(0, size).toLocaleLowerCase()) return joinOverlap(left, right.slice(size));
+	const leftSearchable = searchableCharacters(left).text.slice(-200);
+	const rightSearchable = searchableCharacters(right);
+	const normalizedMax = Math.min(leftSearchable.length, rightSearchable.text.length);
+	for (let size = normalizedMax; size >= 5; size -= 1) {
+		if (leftSearchable.slice(-size) !== rightSearchable.text.slice(0, size)) continue;
+		const sourceEnd = rightSearchable.sourceEnds[size - 1];
+		return joinOverlap(left, right.slice(sourceEnd));
+	}
 	return `${left}\n${right}`;
 }
 function assembleDiscussionTranscript(segments) {

package/dist/src/discussions/types.d.ts

@@ -132,6 +132,10 @@ export interface DiscussionMetrics {
     byStatus: Record<DiscussionStatus, number>;
     averageTimeToFirstTranscriptMs: number | null;
     averageTimeToCompleteMs: number | null;
+    totalSegments: number;
+    failedSegments: number;
+    retriedSegments: number;
+    averageSegmentLatencyMs: number | null;
 }
 export interface DiscussionDetail {
     discussion: DiscussionCapture;

package/dist/src/gateway/agents-admin.js

@@ -1,5 +1,5 @@
-import { resolveCapabilityPresetLayer, resolveEffectiveAgentManifest } from "../agent-manifest/resolver.js";
 import { init_agent_scope, listAgentEntries, normalizeAgentId, resolveAgentDir, resolveAgentProfileDir, resolveAgentWorkspaceDir, resolveDefaultAgentId, resolveUserPath, validateAgentIdForNewAgent } from "../agent/agent-scope.js";
+import { resolveCapabilityPresetLayer, resolveEffectiveAgentManifest } from "../agent-manifest/resolver.js";
 import { resolveEffectiveAgentProfile } from "../config/agent-profile.js";
 import { WORKSPACE_FILES, init_paths } from "../config/paths.js";
 import { AGENT_PROFILE_MARKDOWN_SYSTEM_FILES, REQUIRED_AGENT_PROFILE_MARKDOWN_FILE_SET } from "../agent/context/workspace.js";

package/dist/src/gateway/heartbeat/service.js

@@ -1,9 +1,9 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { shouldSilence, stripHeartbeatToken } from "../../heartbeat/tokens.js";
-import { appendCronEventLines } from "../../heartbeat/event-prompt.js";
 import { isWithinActiveHours } from "../../heartbeat/active-hours.js";
 import { isHeartbeatContentEmpty } from "../../heartbeat/content-check.js";
+import { appendCronEventLines } from "../../heartbeat/event-prompt.js";
 import { createHeartbeatWake } from "../../heartbeat/wake.js";
 import { resolveHeartbeatMdPath } from "../workspace-heartbeat-path.js";
 import { readFile } from "fs/promises";

package/dist/src/gateway/hono/app.js

@@ -10,7 +10,7 @@ import { buildGatewayConsoleCspHeader } from "../security/csp.js";
 import { checkBrowserOrigin } from "../security/origin-check.js";
 import { auth } from "./middleware/auth.js";
 import { operatorScopes } from "./middleware/scopes.js";
-import { createChannelRateLimitMiddleware, createChatRateLimitMiddleware, createStrictRateLimitMiddleware, createTaskRateLimitMiddleware, createXopcCloudPollRateLimitMiddleware } from "./middleware/strict-rate-limit.js";
+import { createChannelRateLimitMiddleware, createChatRateLimitMiddleware, createMediaRateLimitMiddleware, createStrictRateLimitMiddleware, createTaskRateLimitMiddleware, createXopcCloudPollRateLimitMiddleware } from "./middleware/strict-rate-limit.js";
 import { logContextMiddleware } from "./middleware/log-context.js";
 import { logger } from "./middleware/logger.js";
 import { routeErrorMiddleware } from "./middleware/route-errors.js";
@@ -147,7 +147,7 @@ function createHonoApp(config) {
 	const DEFAULT_API_BODY_MAX = 1 * 1024 * 1024;
 	const SKILL_UPLOAD_BODY_MAX = 10 * 1024 * 1024;
 	const NOTE_MEDIA_BODY_MAX = 25 * 1024 * 1024;
-	const VOICE_TRANSCRIBE_BODY_MAX = 35 * 1024 * 1024;
+	const VOICE_TRANSCRIBE_BODY_MAX = 26 * 1024 * 1024;
 	const SESSION_INPUT_BODY_MAX = maxSessionInputRequestBodyBytes();
 	const isNoteMediaUploadRequest = (path, method, contentType) => {
 		if (method !== "POST") return false;
@@ -175,7 +175,7 @@ function createHonoApp(config) {
 	}));
 	app.use("/api/*", async (c, next) => {
 		const contentType = c.req.header("content-type");
-		const maxSize = c.req.method === "POST" && c.req.path === "/api/tasks" || c.req.method === "POST" && /^\/api\/sessions\/[^/]+\/inputs$/.test(c.req.path) || c.req.method === "POST" && /^\/api\/tasks\/[^/]+\/inputs$/.test(c.req.path) || c.req.method === "PATCH" && /^\/api\/sessions\/[^/]+\/inputs\/[^/]+$/.test(c.req.path) ? SESSION_INPUT_BODY_MAX : c.req.path === "/api/skills/upload" ? SKILL_UPLOAD_BODY_MAX : c.req.path === "/api/voice/transcribe" || c.req.path === "/api/voice/transcriptions" ? VOICE_TRANSCRIBE_BODY_MAX : isNoteMediaUploadRequest(c.req.path, c.req.method, contentType) ? NOTE_MEDIA_BODY_MAX : isProjectFileUploadRequest(c.req.path, c.req.method, contentType) ? NOTE_MEDIA_BODY_MAX : discussionUploadBodyMax(c.req.path, c.req.method, contentType) ?? DEFAULT_API_BODY_MAX;
+		const maxSize = c.req.method === "POST" && c.req.path === "/api/tasks" || c.req.method === "POST" && /^\/api\/sessions\/[^/]+\/inputs$/.test(c.req.path) || c.req.method === "POST" && /^\/api\/tasks\/[^/]+\/inputs$/.test(c.req.path) || c.req.method === "PATCH" && /^\/api\/sessions\/[^/]+\/inputs\/[^/]+$/.test(c.req.path) ? SESSION_INPUT_BODY_MAX : c.req.path === "/api/skills/upload" ? SKILL_UPLOAD_BODY_MAX : c.req.path === "/api/voice/transcriptions" ? VOICE_TRANSCRIBE_BODY_MAX : isNoteMediaUploadRequest(c.req.path, c.req.method, contentType) ? NOTE_MEDIA_BODY_MAX : isProjectFileUploadRequest(c.req.path, c.req.method, contentType) ? NOTE_MEDIA_BODY_MAX : discussionUploadBodyMax(c.req.path, c.req.method, contentType) ?? DEFAULT_API_BODY_MAX;
 		const maxSizeMb = Math.ceil(maxSize / (1024 * 1024));
 		return bodyLimit({
 			maxSize,
@@ -213,6 +213,10 @@ function createHonoApp(config) {
 		trustedProxies: service.currentConfig.gateway?.trustedProxies,
 		allowRealIpFallback: service.currentConfig.gateway?.allowRealIpFallback === true
 	}) });
+	const mediaRateLimitMiddleware = createMediaRateLimitMiddleware({ getTrustedProxyContext: () => ({
+		trustedProxies: service.currentConfig.gateway?.trustedProxies,
+		allowRealIpFallback: service.currentConfig.gateway?.allowRealIpFallback === true
+	}) });
 	const taskRateLimitMiddleware = createTaskRateLimitMiddleware({ getTrustedProxyContext: () => ({
 		trustedProxies: service.currentConfig.gateway?.trustedProxies,
 		allowRealIpFallback: service.currentConfig.gateway?.allowRealIpFallback === true
@@ -225,6 +229,7 @@ function createHonoApp(config) {
 		service,
 		strictRateLimitMiddleware,
 		chatRateLimitMiddleware,
+		mediaRateLimitMiddleware,
 		taskRateLimitMiddleware,
 		xopcCloudPollRateLimitMiddleware: createXopcCloudPollRateLimitMiddleware({ getTrustedProxyContext: () => ({
 			trustedProxies: service.currentConfig.gateway?.trustedProxies,

package/dist/src/gateway/hono/middleware/strict-rate-limit.d.ts

@@ -16,6 +16,10 @@ export declare function createChatRateLimitMiddleware(deps: StrictRateLimitDeps)
     error: string;
     code: string;
 }, 429, "json">>;
+export declare function createMediaRateLimitMiddleware(deps: StrictRateLimitDeps): import("hono").MiddlewareHandler<any, string, {}, Response & import("hono").TypedResponse<{
+    error: string;
+    code: string;
+}, 429, "json">>;
 export declare function createTaskRateLimitMiddleware(deps: StrictRateLimitDeps): import("hono").MiddlewareHandler<any, string, {}, Response & import("hono").TypedResponse<{
     error: string;
     code: string;