@xopcai/xopc 0.0.210 → 0.0.213

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/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 = {
@@ -32,6 +44,8 @@ const PLANS = {
 			kind: "activity",
 			arguments: {
 				max_results: 100,
+				include_payload: false,
+				verbose: false,
 				query: "newer_than:30d -in:spam -in:trash"
 			}
 		}],
@@ -42,47 +56,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/connectors/runtime-adapter-registry.js

@@ -1,7 +1,7 @@
 import { isXopcDatabaseOpen } from "../storage/sqlite/connection.js";
 import { deleteConnectorInstallation, getConnectorInstallation, upsertConnectorInstallation } from "../storage/sqlite/connector-repository.js";
 import "../storage/sqlite/index.js";
-import { assertComposioApiKeyConfigured } from "./composio-sessions.js";
+import { assertComposioAccessConfigured } from "./composio-sessions.js";
 import { saveComposioApiKey } from "./composio.js";
 import { saveConnectorSecrets } from "./secret-store.js";
 import { isManagedConnectorServer, materializeConnectorMcpServer } from "./materialize.js";
@@ -106,7 +106,7 @@ registerConnectorRuntimeAdapter({
 	async install({ config, definition, input, resolver }) {
 		if (definition.runtime.type !== "composio") throw new Error(`Invalid Composio connector definition: ${definition.id}`);
 		if (definition.runtime.role === "credential") await saveComposioApiKey(input, resolver);
-		if (definition.runtime.role === "toolkit") await assertComposioApiKeyConfigured(resolver);
+		if (definition.runtime.role === "toolkit") await assertComposioAccessConfigured(resolver);
 		const instance = installRecord(config, definition, definition.runtime.role === "toolkit" ? { scope: "read" } : {}, definition.runtime.role === "toolkit" ? { config: input.config ?? {} } : {});
 		if (definition.runtime.role === "toolkit" && isXopcDatabaseOpen()) {
 			const installationId = `${definition.id}-local-owner`;

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 { appendSequentialTranscript, 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 = appendSequentialTranscript(text, result.text);
+			language ??= result.language;
 		});
+		return {
+			text,
+			...language ? { language } : {}
+		};
 	}
 	fail(capture, stage, code, message) {
 		const current = getDiscussionCapture(capture.id);

package/dist/src/discussions/service.js

@@ -153,13 +153,16 @@ var DiscussionService = class {
 	uploadSegment(input) {
 		const capture = getDiscussionCapture(input.discussionId);
 		if (!capture) throw new DiscussionServiceError("not_found", "Discussion not found");
-		if (capture.status !== "recording" && capture.status !== "stopping") throw new DiscussionServiceError("conflict", "Discussion no longer accepts transcript segments");
+		const acceptsSegments = capture.status === "recording" || capture.status === "stopping";
+		const originalRecordingSupersedesSegment = capture.audioAttachmentId && (capture.status === "sealing" || capture.status === "organizing" || capture.status === "completed");
+		if (!acceptsSegments && !originalRecordingSupersedesSegment) throw new DiscussionServiceError("conflict", "Discussion no longer accepts transcript segments");
 		if (!Number.isInteger(input.sequence) || input.sequence < 0 || input.sequence > 2e3) throw new DiscussionServiceError("invalid_input", "Invalid segment sequence");
 		if (input.file.mimeType !== "audio/wav" && input.file.mimeType !== "audio/x-wav") throw new DiscussionServiceError("invalid_input", "Live transcript segments must be WAV audio");
 		if (input.file.buffer.length === 0 || input.file.buffer.length > 2097152) throw new DiscussionServiceError("invalid_input", "Live transcript segment is empty or too large");
 		if (!Number.isFinite(input.startedAtMs) || !Number.isFinite(input.endedAtMs) || input.startedAtMs < 0 || input.endedAtMs <= input.startedAtMs || input.endedAtMs - input.startedAtMs > 25e3) throw new DiscussionServiceError("invalid_input", "Invalid live transcript segment timing");
 		const actualSha256 = createHash("sha256").update(input.file.buffer).digest("hex");
 		if (input.sha256 !== actualSha256) throw new DiscussionServiceError("invalid_input", "Segment checksum mismatch");
+		if (originalRecordingSupersedesSegment) return this.transcript(input.discussionId);
 		const existing = getDiscussionTranscriptSegment(input.discussionId, input.sequence);
 		if (existing && existing.audioSha256 !== actualSha256) throw new DiscussionServiceError("conflict", "Segment sequence already contains different audio");
 		if (!existing) {
@@ -219,7 +222,8 @@ var DiscussionService = class {
 				name: file.name.trim().slice(0, 200) || `discussion-${id}.webm`,
 				buffer: file.buffer,
 				mimeType: file.mimeType,
-				duration: Math.round(durationMs / 1e3)
+				duration: Math.round(durationMs / 1e3),
+				retainWithoutReference: true
 			});
 			if (!attachment) throw new DiscussionServiceError("not_found", "Discussion note not found");
 			try {

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

@@ -1,3 +1,5 @@
 import type { DiscussionTranscriptSegment } from './types.js';
+/** Joins transcripts from adjacent audio chunks that have no audio overlap. */
+export declare function appendSequentialTranscript(existing: string, next: string): string;
 export declare function appendTranscriptWithoutOverlap(existing: string, next: string): string;
 export declare function assembleDiscussionTranscript(segments: DiscussionTranscriptSegment[]): string;

package/dist/src/discussions/transcript.js

@@ -1,15 +1,54 @@
 //#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) {
+	const next = /\p{P}$/u.test(left) ? remainder.replace(/^\p{P}+/u, "") : remainder;
+	if (!next || /^\s/u.test(next)) return `${left}${next}`.trim();
+	const leftCharacter = Array.from(left).findLast((character) => /[\p{L}\p{N}\p{S}]/u.test(character));
+	const rightCharacter = Array.from(next).find((character) => /[\p{L}\p{N}\p{S}]/u.test(character));
+	const compactScript = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]/u;
+	return `${left}${leftCharacter && rightCharacter && !compactScript.test(leftCharacter) && !compactScript.test(rightCharacter) ? " " : ""}${next}`.trim();
+}
+/** Joins transcripts from adjacent audio chunks that have no audio overlap. */
+function appendSequentialTranscript(existing, next) {
+	const left = existing.trim();
+	const right = next.trim();
+	if (!left) return right;
+	if (!right) return left;
+	return `${left}\n${right}`;
+}
 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();
-	return `${left}\n${right}`;
+	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 appendSequentialTranscript(left, right);
 }
 function assembleDiscussionTranscript(segments) {
 	return segments.reduce((text, segment) => appendTranscriptWithoutOverlap(text, segment.displayText ?? ""), "");
 }
 //#endregion
-export { appendTranscriptWithoutOverlap, assembleDiscussionTranscript };
+export { appendSequentialTranscript, appendTranscriptWithoutOverlap, assembleDiscussionTranscript };

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/extensions/install.d.ts

@@ -3,6 +3,16 @@
  * Supports installing from npm packages, local directories, and xopc-store zips
  * Supports three-tier storage: workspace, global, bundled
  */
+export type ValidatedNpmPackageSpec = {
+    ok: true;
+    packageName: string;
+    version?: string;
+} | {
+    ok: false;
+    error: string;
+};
+/** Accept registry package names with an optional exact semver; reject URLs, paths, tags, and ranges. */
+export declare function validateNpmPackageSpec(packageSpec: string): ValidatedNpmPackageSpec;
 export interface InstallOptions {
     source: 'npm' | 'local';
     targetDir: string;