@xopcai/xopc 0.0.389 → 0.0.390

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

@@ -1,5 +1,6 @@
 import type { Config } from '../config/schema.js';
 import type { NotesService } from '../notes/service.js';
+import type { STTResult } from '../voice/stt/types.js';
 import type { DiscussionCapture } from './types.js';
 export interface DiscussionSealerDeps {
     processRecordingJob?: () => Promise<void>;
@@ -9,18 +10,23 @@ export interface DiscussionSealerDeps {
         text: string;
         language?: string;
     }>;
+    transcribeSegment?: (audio: Buffer, signal: AbortSignal) => Promise<STTResult>;
+    requestTimeoutMs?: number;
     onUpdated?: (capture: DiscussionCapture) => void;
 }
 export declare class DiscussionSealer {
     private readonly deps;
     private readonly intervalMs;
+    private readonly owner;
     private timer?;
     private running;
+    private recordingRunning;
+    private stopping;
+    private controller?;
     constructor(deps: DiscussionSealerDeps, intervalMs?: number);
     start(): void;
     stop(): Promise<void>;
     tick(now?: number): Promise<void>;
     private sealWhenReady;
     private transcribeFullRecording;
-    private fail;
 }

package/dist/src/discussions/sealer.js

@@ -1,113 +1,189 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
+import { init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { DISCUSSION_MAX_SAVED_DURATION_MS } from "../../packages/gateway-contract/src/discussions.js";
+import { init_src } from "../../packages/gateway-contract/src/index.js";
+import { init_model_usage, withModelUsageOrigin } from "../providers/model-usage.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 { listDiscussionTranscriptSegments, updateDiscussionCapture } from "./repository.js";
+import { appendTranscriptWithoutOverlap, assembleDiscussionTranscript } from "./transcript.js";
 import { replaceTranscriptSegments, saveTranscriptRevision } from "./revisions.js";
+import { assertProcessingRun, claimSealingCapture, ensureProcessingRun, failOrRetryProcessing, getProcessingRun, readCheckpoint, releaseSealingLease, renewSealingLease, resetProcessingRetry, saveCheckpoint, withProcessingDeadline } from "./processing.js";
 import { missingAudioRanges, slicePcmWav } from "./audio-repair.js";
 import { decodeWavToMonoFloat32 } from "../voice/audio/wav.js";
 import { forEachNormalizedAudioSegment } from "../voice/audio/normalize.js";
 import { getRecordingJob } from "./recordingJobs.js";
-import { createHash } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { createHash, randomUUID } from "node:crypto";
 //#region src/discussions/sealer.ts
+init_src();
+init_model_usage();
+init_transaction();
 init_logger();
 const log = createLogger("DiscussionSealer");
 const UPLOAD_GRACE_MS = 2 * 6e4;
 var DiscussionSealer = class {
+	owner = randomUUID();
 	timer;
 	running = false;
+	recordingRunning = false;
+	stopping = false;
+	controller;
 	constructor(deps, intervalMs = 1e3) {
 		this.deps = deps;
 		this.intervalMs = intervalMs;
 	}
 	start() {
 		if (this.timer) return;
-		this.timer = setInterval(() => void this.tick(), this.intervalMs);
+		this.stopping = false;
+		this.timer = setInterval(() => void this.tick().catch((error) => log.error({ err: error }, "Discussion processing tick failed")), this.intervalMs);
 		this.timer.unref();
-		this.tick();
+		this.tick().catch((error) => log.error({ err: error }, "Discussion processing tick failed"));
 	}
 	async stop() {
+		this.stopping = true;
 		if (this.timer) clearInterval(this.timer);
 		this.timer = void 0;
-		while (this.running) await new Promise((resolve) => setTimeout(resolve, 10));
+		this.controller?.abort(/* @__PURE__ */ new Error("Discussion processing stopped"));
+		while (this.running || this.recordingRunning) await new Promise((resolve) => setTimeout(resolve, 10));
 	}
 	async tick(now = Date.now()) {
-		if (this.running) return;
+		if (this.stopping) return;
+		if (!this.recordingRunning) {
+			this.recordingRunning = true;
+			try {
+				await this.deps.processRecordingJob?.();
+			} finally {
+				this.recordingRunning = false;
+			}
+		}
+		if (this.running || this.stopping) return;
 		this.running = true;
+		const controller = new AbortController();
+		this.controller = controller;
+		let capture = null;
+		let renewal;
 		try {
-			await this.deps.processRecordingJob?.();
-			const capture = [...listDiscussionCaptures({
-				status: "sealing",
-				limit: 1
-			}).items, ...listDiscussionCaptures({
-				status: "stopping",
-				limit: 1
-			}).items][0];
+			capture = claimSealingCapture(this.owner, now);
 			if (!capture) return;
-			await this.sealWhenReady(capture, now);
+			const id = capture.id;
+			renewal = setInterval(() => {
+				if (!renewSealingLease(id, this.owner)) controller.abort(/* @__PURE__ */ new Error("Transcription lease lost"));
+			}, 15e3);
+			renewal.unref();
+			await this.sealWhenReady(capture, now, controller.signal);
 		} finally {
+			if (renewal) clearInterval(renewal);
+			if (capture) releaseSealingLease(capture.id, this.owner);
+			this.controller = void 0;
 			this.running = false;
 		}
 	}
-	async sealWhenReady(capture, now) {
+	async sealWhenReady(capture, now, signal) {
 		const ageMs = now - (capture.recordingStoppedAt ?? now);
 		if (!capture.audioAttachmentId) {
 			const job = getRecordingJob(capture.id);
 			if (job && (job.state === "queued" || job.state === "running")) return;
-			if (ageMs >= UPLOAD_GRACE_MS) this.fail(capture, "audio_upload", "recording_missing", "Original recording was not uploaded");
+			if (ageMs >= UPLOAD_GRACE_MS) {
+				const updated = updateDiscussionCapture(capture.id, {
+					status: "needs_attention",
+					failureStage: "audio_upload",
+					failureCode: "recording_missing",
+					failureMessage: "Original recording was not uploaded"
+				}, ["stopping", "sealing"]);
+				if (updated) this.deps.onUpdated?.(updated);
+			}
+			if (ageMs < UPLOAD_GRACE_MS) updateDiscussionCapture(capture.id, { updatedAt: Date.now() }, [capture.status]);
 			return;
 		}
 		const segments = listDiscussionTranscriptSegments(capture.id);
 		const expected = capture.expectedLastSequence ?? -1;
-		const bySequence = new Map(segments.map((segment) => [segment.sequence, segment]));
-		const missing = Array.from({ length: expected + 1 }, (_, sequence) => sequence).filter((sequence) => !bySequence.has(sequence));
+		const missing = expected >= 0 && Array.from({ length: expected + 1 }, (_, sequence) => sequence).some((sequence) => !segments.some((segment) => segment.sequence === sequence));
 		const pending = segments.some((segment) => segment.status === "uploaded" || segment.status === "transcribing");
-		if ((missing.length > 0 || pending) && ageMs < UPLOAD_GRACE_MS) return;
+		const run = ensureProcessingRun(capture);
+		if (!run.force_audio && (missing || pending) && ageMs < UPLOAD_GRACE_MS) {
+			updateDiscussionCapture(capture.id, { updatedAt: Date.now() }, [capture.status]);
+			return;
+		}
 		const sealing = capture.status === "sealing" ? capture : updateDiscussionCapture(capture.id, { status: "sealing" }, ["stopping"]);
 		if (!sealing) return;
 		try {
 			const confirmed = segments.filter((segment) => segment.status === "confirmed");
-			const result = expected >= 0 && missing.length === 0 && !pending && confirmed.length === expected + 1 ? { text: assembleDiscussionTranscript(confirmed) } : await this.transcribeFullRecording(sealing);
+			const result = !run.force_audio && expected >= 0 && !missing && !pending && confirmed.length === expected + 1 ? { text: assembleDiscussionTranscript(confirmed) } : await withModelUsageOrigin("interactive", () => this.transcribeFullRecording(sealing, run, signal));
 			const text = result.text.trim();
-			saveTranscriptRevision(capture.id);
 			if (!text) throw new Error("Discussion transcription produced no text");
-			const updated = updateDiscussionCapture(capture.id, {
-				status: "organizing",
-				canonicalTranscript: text,
-				canonicalTranscriptSha256: createHash("sha256").update(text).digest("hex"),
-				transcriptLanguage: result.language,
-				failureStage: void 0,
-				failureCode: void 0,
-				failureMessage: void 0
-			}, ["sealing"]);
-			if (!updated) throw new Error("Discussion changed while sealing transcript");
-			this.deps.onUpdated?.(updated);
+			const updated = runSqliteWriteTransaction(() => {
+				assertProcessingRun(run, this.owner, signal);
+				if (result.segments) replaceTranscriptSegments(capture.id, result.segments);
+				saveTranscriptRevision(capture.id);
+				resetProcessingRetry(capture.id);
+				return updateDiscussionCapture(capture.id, {
+					status: "organizing",
+					canonicalTranscript: text,
+					canonicalTranscriptSha256: createHash("sha256").update(text).digest("hex"),
+					transcriptLanguage: result.language,
+					failureStage: void 0,
+					failureCode: void 0,
+					failureMessage: void 0
+				}, ["sealing"]);
+			});
+			if (updated) this.deps.onUpdated?.(updated);
 		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error);
-			this.fail(sealing, "transcript_sealing", "transcript_sealing_failed", message);
+			if (signal.aborted) return;
+			if (getProcessingRun(capture.id)?.run_id !== run.run_id || !renewSealingLease(capture.id, this.owner)) return;
+			const updated = failOrRetryProcessing(sealing, "transcript_sealing", error);
+			if (updated) this.deps.onUpdated?.(updated);
+			log.warn({
+				err: error,
+				discussionId: capture.id,
+				phase: "transcript_sealing"
+			}, "Discussion transcription failed; saved original retained");
 		}
 	}
-	async transcribeFullRecording(capture) {
+	async transcribeFullRecording(capture, run, signal) {
 		const attachment = await this.deps.notes.getAttachmentPath(capture.noteId, capture.audioAttachmentId);
 		if (!attachment) throw new Error("Discussion audio file is missing");
+		const assertCurrent = () => assertProcessingRun(run, this.owner, signal);
+		assertCurrent();
+		if (capture.audioSha256) {
+			const hash = createHash("sha256");
+			for await (const chunk of createReadStream(attachment.filePath)) {
+				signal.throwIfAborted();
+				hash.update(chunk);
+			}
+			if (hash.digest("hex") !== capture.audioSha256) throw new Error("Saved original audio checksum mismatch");
+		}
+		assertCurrent();
 		if (this.deps.transcribeRecording) {
-			const result = await this.deps.transcribeRecording(attachment.filePath, capture);
-			replaceTranscriptSegments(capture.id, [{
-				text: result.text,
-				startedAtMs: 0,
-				endedAtMs: capture.durationMs ?? 1e3
-			}]);
-			return result;
+			if (listDiscussionTranscriptSegments(capture.id).some((segment) => segment.correctedByUser)) throw new Error("Segment transcription is required to preserve manual corrections");
+			const cached = readCheckpoint(run.run_id, 0, capture.durationMs ?? 1e3);
+			const result = cached ?? await withProcessingDeadline(async (requestSignal) => {
+				const response = await this.deps.transcribeRecording(attachment.filePath, capture, requestSignal);
+				return {
+					segments: [{
+						text: response.text,
+						startedAtMs: 0,
+						endedAtMs: capture.durationMs ?? 1e3
+					}],
+					language: response.language
+				};
+			}, signal, this.deps.requestTimeoutMs ?? 12e4);
+			assertCurrent();
+			if (!cached) saveCheckpoint(run.run_id, 0, capture.durationMs ?? 1e3, result);
+			return {
+				text: result.segments.map((segment) => segment.text).join("\n"),
+				language: result.language,
+				segments: result.segments
+			};
 		}
 		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");
-		let offset = 0;
-		const confirmed = listDiscussionTranscriptSegments(capture.id).filter((segment) => segment.status === "confirmed");
-		const segments = confirmed.map((segment) => ({
+		if (!this.deps.transcribeSegment && !isSTTAvailable(sttConfig)) throw new Error("STT is not configured");
+		const confirmed = listDiscussionTranscriptSegments(capture.id).filter((segment) => segment.status === "confirmed" && (!run.force_audio || segment.correctedByUser));
+		const output = confirmed.map((segment) => ({
 			text: segment.displayText ?? segment.rawText ?? "",
 			rawText: segment.rawText,
 			startedAtMs: segment.startedAtMs,
@@ -115,61 +191,61 @@ var DiscussionSealer = class {
 			speakerLabel: segment.speakerLabel,
 			correctedByUser: segment.correctedByUser
 		}));
+		let offset = 0;
 		let language;
 		await forEachNormalizedAudioSegment({
 			filePath: attachment.filePath,
-			maxDurationSeconds: 7200
+			maxDurationSeconds: DISCUSSION_MAX_SAVED_DURATION_MS / 1e3,
+			signal
 		}, async (buffer, index) => {
+			assertCurrent();
 			const decoded = decodeWavToMonoFloat32(buffer);
 			const durationMs = decoded.durationSeconds * 1e3;
 			const gaps = missingAudioRanges(offset, offset + durationMs, confirmed);
 			for (const [gapIndex, gap] of gaps.entries()) {
-				const audio = gaps.length === 1 && gap.startedAtMs === offset && gap.endedAtMs === offset + durationMs ? buffer : slicePcmWav(decoded, gap.startedAtMs - offset, gap.endedAtMs - offset);
-				if (audio.length <= 44) continue;
-				const result = await transcribe(audio, sttConfig, {
-					mime: "audio/wav",
-					fileName: `discussion-recovery-${index}-${gapIndex}.wav`
-				});
-				if (result.segments?.length) for (const part of result.segments) {
-					if (!Number.isFinite(part.startMs) || !Number.isFinite(part.endMs) || part.startMs < 0 || part.endMs <= part.startMs || part.endMs > gap.endedAtMs - gap.startedAtMs + 100) throw new Error("Provider returned an invalid transcript time range");
-					segments.push({
-						text: part.text,
-						startedAtMs: gap.startedAtMs + part.startMs,
-						endedAtMs: Math.min(gap.endedAtMs, gap.startedAtMs + part.endMs),
-						...part.speaker ? { speakerLabel: `${index + 1}:${gapIndex + 1}:${part.speaker}` } : {}
+				assertCurrent();
+				let checkpoint = readCheckpoint(run.run_id, gap.startedAtMs, gap.endedAtMs);
+				if (!checkpoint) {
+					const audio = gaps.length === 1 && gap.startedAtMs === offset && gap.endedAtMs === offset + durationMs ? buffer : slicePcmWav(decoded, gap.startedAtMs - offset, gap.endedAtMs - offset);
+					if (audio.length <= 44) continue;
+					const result = await withProcessingDeadline((requestSignal) => this.deps.transcribeSegment ? this.deps.transcribeSegment(audio, requestSignal) : transcribe(audio, sttConfig, {
+						mime: "audio/wav",
+						fileName: `discussion-recovery-${index}-${gapIndex}.wav`,
+						signal: requestSignal
+					}), signal, this.deps.requestTimeoutMs ?? 12e4);
+					const recovered = [];
+					if (result.segments?.length) for (const part of result.segments) {
+						if (!Number.isFinite(part.startMs) || !Number.isFinite(part.endMs) || part.startMs < 0 || part.endMs <= part.startMs || part.endMs > gap.endedAtMs - gap.startedAtMs + 100) throw new Error("Provider returned an invalid transcript time range");
+						recovered.push({
+							text: part.text,
+							startedAtMs: gap.startedAtMs + part.startMs,
+							endedAtMs: Math.min(gap.endedAtMs, gap.startedAtMs + part.endMs),
+							...part.speaker ? { speakerLabel: `${index + 1}:${gapIndex + 1}:${part.speaker}` } : {}
+						});
+					}
+					else if (result.text.trim()) recovered.push({
+						text: result.text,
+						...gap
 					});
+					checkpoint = {
+						segments: recovered,
+						language: result.language
+					};
+					assertCurrent();
+					saveCheckpoint(run.run_id, gap.startedAtMs, gap.endedAtMs, checkpoint);
 				}
-				else if (result.text.trim()) segments.push({
-					text: result.text,
-					...gap
-				});
-				language ??= result.language;
+				output.push(...checkpoint.segments);
+				language ??= checkpoint.language;
 			}
 			offset += durationMs;
 		});
-		segments.sort((a, b) => a.startedAtMs - b.startedAtMs);
-		replaceTranscriptSegments(capture.id, segments);
+		output.sort((a, b) => a.startedAtMs - b.startedAtMs);
 		return {
-			text: assembleDiscussionTranscript(listDiscussionTranscriptSegments(capture.id)),
-			...language ? { language } : {}
+			text: output.reduce((text, segment) => appendTranscriptWithoutOverlap(text, segment.text), ""),
+			language,
+			segments: output
 		};
 	}
-	fail(capture, stage, code, message) {
-		const current = getDiscussionCapture(capture.id);
-		if (!current || current.status !== "stopping" && current.status !== "sealing") return;
-		const updated = updateDiscussionCapture(capture.id, {
-			status: "needs_attention",
-			failureStage: stage,
-			failureCode: code,
-			failureMessage: message.slice(0, 1e3)
-		}, [current.status]);
-		if (updated) this.deps.onUpdated?.(updated);
-		log.warn({
-			discussionId: capture.id,
-			stage,
-			code
-		}, `Discussion sealing failed: ${message}`);
-	}
 };
 //#endregion
 export { DiscussionSealer };

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

@@ -1,3 +1,4 @@
+import { longRecordingReview } from './long-review.js';
 import { type DiscussionRecordingManifest } from '@xopcai/gateway-contract';
 import type { NotesService } from '../notes/service.js';
 import type { ProjectService } from '../projects/project-service.js';
@@ -15,6 +16,10 @@ export declare class DiscussionService {
     private readonly recordingOwner;
     private readonly recordingControllers;
     constructor(notes: NotesService, projects: ProjectService, emit?: (type: string, payload: unknown) => void);
+    audioClip(id: string, start: number, end: number, signal: AbortSignal): Promise<Buffer<ArrayBufferLike>>;
+    annotations(id: string): Promise<import("@xopcai/gateway-contract").DiscussionResolvedAnnotation[]>;
+    saveAnnotation(id: string, input: import('@xopcai/gateway-contract').DiscussionAnnotationInput): import("@xopcai/gateway-contract").DiscussionAnnotation;
+    evidence(id: string, revision: number, ids: number[]): Promise<import("@xopcai/gateway-contract").DiscussionEvidence>;
     settings(): DiscussionCaptureSettings;
     acknowledgeConsent(policyVersion: number): DiscussionCaptureSettings;
     create(input: CreateDiscussionInput): Promise<DiscussionDetail>;
@@ -44,10 +49,11 @@ export declare class DiscussionService {
     sealRecording(id: string, input: DiscussionRecordingManifest): Promise<import("@xopcai/gateway-contract").DiscussionRecordingJob>;
     /** Runs inside the existing sealer lifecycle; unfinished leases survive process restart. */
     processRecordingJob(): Promise<void>;
-    retry(id: string): Promise<DiscussionDetail | null>;
+    retry(id: string, mode?: import('./types.js').DiscussionRetryMode): Promise<DiscussionDetail | null>;
     cancel(id: string): Promise<DiscussionDetail | null>;
     deleteAudio(id: string): Promise<DiscussionDetail | null>;
     unlinkInferredProject(id: string): Promise<DiscussionDetail | null>;
+    review(id: string, options?: Parameters<typeof longRecordingReview>[2]): Promise<import("@xopcai/gateway-contract").DiscussionReview>;
     private detail;
     private enqueueMutation;
 }

package/dist/src/discussions/service.js

@@ -8,6 +8,10 @@ import { DiscussionServiceError } from "./errors.js";
 import { acknowledgeDiscussionCaptureConsent, correctDiscussionTranscriptSegment, createDiscussionCapture, createDiscussionTranscriptSegment, deleteDiscussionSegmentAudio, getDiscussionCapture, getDiscussionCaptureByClientRequestId, getDiscussionCaptureByNoteId, getDiscussionCaptureSettings, getDiscussionMetrics, getDiscussionTranscriptSegment, getLatestDiscussionOrganization, listDiscussionCaptures, listDiscussionTranscriptSegments, updateDiscussionCapture } from "./repository.js";
 import { assembleDiscussionTranscript } from "./transcript.js";
 import { readTranscriptRevision, refreshCanonicalTranscript, saveTranscriptRevision } from "./revisions.js";
+import { createProcessingRun, processingProgress, resetProcessingRetry } from "./processing.js";
+import { evidenceFor, putAnnotation, resolvedAnnotations } from "./review.js";
+import { longRecordingReview } from "./long-review.js";
+import { discussionAudioClip } from "./audio-clip.js";
 import { editMeeting } from "./edits.js";
 import { completeRecording, listRecordingChunks, removeRecordingChunks, saveRecordingChunk, validateRecordingManifest } from "./recording.js";
 import { cancelRecordingJob, claimRecordingJob, finishRecordingJob, getRecordingJob, getRecordingJobInput, renewRecordingJob, submitRecordingJob } from "./recordingJobs.js";
@@ -31,6 +35,18 @@ var DiscussionService = class {
 		this.projects = projects;
 		this.emit = emit;
 	}
+	audioClip(id, start, end, signal) {
+		return discussionAudioClip(id, start, end, this.notes, signal);
+	}
+	annotations(id) {
+		return resolvedAnnotations(id, this.notes);
+	}
+	saveAnnotation(id, input) {
+		return putAnnotation(id, input);
+	}
+	evidence(id, revision, ids) {
+		return evidenceFor(id, revision, ids, this.notes);
+	}
 	settings() {
 		return getDiscussionCaptureSettings();
 	}
@@ -238,6 +254,7 @@ var DiscussionService = class {
 			const capture = getDiscussionCapture(id);
 			if (!capture) throw new DiscussionServiceError("not_found", "Discussion not found");
 			if (!["completed", "needs_attention"].includes(capture.status) || !capture.canonicalTranscript) throw new DiscussionServiceError("conflict", "Transcript is not ready");
+			resetProcessingRetry(id);
 			const updated = updateDiscussionCapture(id, {
 				status: "organizing",
 				template,
@@ -338,24 +355,37 @@ var DiscussionService = class {
 			}
 		});
 	}
-	async retry(id) {
-		const capture = getDiscussionCapture(id);
-		if (!capture) return null;
-		if (capture.status !== "needs_attention") throw new DiscussionServiceError("conflict", "Only discussions needing attention can be retried");
-		if (getRecordingJob(id)?.state === "failed") {
+	async retry(id, mode = "resume") {
+		if (mode !== "resume" && mode !== "from_audio") throw new DiscussionServiceError("invalid_input", "Invalid retry mode");
+		if (mode === "resume" && getRecordingJob(id)?.state === "failed") {
 			await this.sealRecording(id, getRecordingJobInput(id));
 			return this.get(id);
 		}
-		const updated = updateDiscussionCapture(id, {
-			status: capture.canonicalTranscript ? "organizing" : "stopping",
-			...!capture.canonicalTranscript ? { recordingStoppedAt: Date.now() } : {},
-			failureStage: void 0,
-			failureCode: void 0,
-			failureMessage: void 0
-		}, ["needs_attention"]);
-		if (!updated) throw new DiscussionServiceError("conflict", "Discussion changed while retrying");
-		this.emit?.("discussion.updated", updated);
-		return this.detail(updated);
+		return this.enqueueMutation(id, async () => {
+			const capture = getDiscussionCapture(id);
+			if (!capture) return null;
+			if (mode === "from_audio") {
+				if (!["completed", "needs_attention"].includes(capture.status)) throw new DiscussionServiceError("conflict", "Wait for current processing to finish");
+				if (!capture.audioAttachmentId || capture.audioDeletedAt || !await this.notes.getAttachmentPath(capture.noteId, capture.audioAttachmentId)) throw new DiscussionServiceError("conflict", "Saved original audio is unavailable");
+			} else if (capture.status !== "needs_attention") throw new DiscussionServiceError("conflict", "Only discussions needing attention can be retried");
+			const updated = runSqliteWriteTransaction(() => {
+				if (mode === "from_audio") {
+					saveTranscriptRevision(id);
+					createProcessingRun(capture, true);
+				} else resetProcessingRetry(id);
+				const status = mode === "from_audio" || capture.failureStage === "transcript_sealing" ? "sealing" : capture.canonicalTranscript ? "organizing" : "stopping";
+				return updateDiscussionCapture(id, {
+					status,
+					...status === "stopping" ? { recordingStoppedAt: Date.now() } : {},
+					failureStage: void 0,
+					failureCode: void 0,
+					failureMessage: void 0
+				}, [capture.status]);
+			});
+			if (!updated) throw new DiscussionServiceError("conflict", "Discussion changed while retrying");
+			this.emit?.("discussion.updated", updated);
+			return this.detail(updated);
+		});
 	}
 	async cancel(id) {
 		const active = getDiscussionCapture(id);
@@ -389,6 +419,8 @@ var DiscussionService = class {
 			await removeRecordingChunks(capture);
 			cancelRecordingJob(id);
 			if (capture.audioAttachmentId) await this.notes.removeAttachment(capture.noteId, capture.audioAttachmentId);
+			const sourceNote = await this.notes.getNote(capture.noteId);
+			for (const attachment of sourceNote?.attachments ?? []) if (attachment.retainWithoutReference && (attachment.fileName.startsWith(`recording-part-${capture.id}-`) || attachment.fileName === `recording-sources-${capture.id}.json` || attachment.fileName === `recording-events-${capture.id}.json`)) await this.notes.removeAttachment(capture.noteId, attachment.id);
 			deleteDiscussionSegmentAudio(id);
 			const updated = updateDiscussionCapture(id, {
 				audioAttachmentId: void 0,
@@ -413,12 +445,16 @@ var DiscussionService = class {
 		this.emit?.("discussion.updated", updated);
 		return this.detail(updated);
 	}
+	review(id, options = {}) {
+		return longRecordingReview(id, this.notes, options);
+	}
 	async detail(capture) {
 		const note = await this.notes.getNote(capture.noteId);
 		if (!note) throw new DiscussionServiceError("not_found", "Discussion note not found");
 		const recordingJob = getRecordingJob(capture.id);
 		return {
 			discussion: capture,
+			processing: processingProgress(capture.id),
 			note,
 			transcript: this.transcript(capture.id),
 			...recordingJob ? { recordingJob } : {},

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

@@ -1,10 +1,11 @@
 export { DISCUSSION_STATUSES } from '@xopcai/gateway-contract';
-export type { DiscussionStatus, DiscussionSource, DiscussionProjectInferenceSource, DiscussionFailureStage, DiscussionFact, DiscussionChapter, DiscussionTemplate, DiscussionActionItem, DiscussionOrganization, DiscussionCapture, DiscussionTranscriptSegmentStatus, DiscussionTranscriptSegment, DiscussionTranscriptStats, DiscussionTranscript, DiscussionOrganizationRecord, DiscussionCaptureSettings, CreateDiscussionInput, ListDiscussionsQuery, DiscussionListResult, DiscussionMetrics, } from '@xopcai/gateway-contract';
+export type { DiscussionStatus, DiscussionSource, DiscussionProjectInferenceSource, DiscussionFailureStage, DiscussionFact, DiscussionChapter, DiscussionTemplate, DiscussionActionItem, DiscussionOrganization, DiscussionCapture, DiscussionTranscriptSegmentStatus, DiscussionTranscriptSegment, DiscussionTranscriptStats, DiscussionTranscript, DiscussionOrganizationRecord, DiscussionCaptureSettings, CreateDiscussionInput, ListDiscussionsQuery, DiscussionListResult, DiscussionMetrics, DiscussionProcessingProgress, DiscussionRetryMode, } from '@xopcai/gateway-contract';
 import type { DiscussionCapture, DiscussionTranscript, DiscussionOrganizationRecord } from '@xopcai/gateway-contract';
 export interface DiscussionDetail {
     discussion: DiscussionCapture;
     note: import('../notes/types.js').Note;
     transcript: DiscussionTranscript;
     organization?: DiscussionOrganizationRecord;
+    processing?: import('@xopcai/gateway-contract').DiscussionProcessingProgress;
     recordingJob?: import('@xopcai/gateway-contract').DiscussionRecordingJob;
 }

package/dist/src/extensions/sdk/index.js

@@ -7,8 +7,8 @@ import { DEFAULT_SECURITY_CONFIG, checkExtensionDirSafety, checkExtensionPathSaf
 import { SlotRegistry, getSlotRegistry, registerSlotType } from "../slots.js";
 import { ExtensionDiagnostics, ExtensionLoaderCacheImpl, getExtensionCache, getExtensionDiagnostics } from "../diagnostics.js";
 import { ExtensionHookRunner, createHookContext, isHookEvent } from "../hooks.js";
-import { defineChannelPluginEntry } from "./channel-entry.js";
 import { registerExtensionCliProgram } from "./channel-helpers.js";
+import { defineChannelPluginEntry } from "./channel-entry.js";
 import { lazyFunction, lazyModule } from "./lazy.js";
 import { createMockExtensionApi, createTestGateway } from "./testing.js";
 //#region src/extensions/sdk/index.ts

package/dist/src/gateway/agent-builtin-tools.d.ts

@@ -277,4 +277,4 @@ export declare const GATEWAY_BUILTIN_TOOLS: readonly [{
         readonly zh: "使用已验证的参数执行选定的外部工具。";
     };
 }];
-export declare const GATEWAY_BUILTIN_TOOL_IDS: ("automation" | "workflow" | "find" | "image" | "knowledge_search" | "knowledge_get" | "knowledge_write" | "user_context_search" | "user_context_get" | "user_context_update" | "web_search" | "web_fetch" | "browser_use" | "grep" | "session_search" | "read_file" | "list_dir" | "write_file" | "apply_patch" | "exec_command" | "update_plan" | "todo" | "clarify" | "xopc_tool_execute" | "web_extract" | "tool_manual" | "session_status" | "read_media" | "xopc_tool_search" | "xopc_tool_describe" | "image_generate" | "skills_list" | "skill_view" | "skill_manage" | "skills_marketplace_search" | "computer_use" | "send_message" | "text_to_speech" | "execute_code" | "send_media" | "create_share" | "memory_maintenance" | "delegate_task" | "skill_install" | "create_desktop_pet")[];
+export declare const GATEWAY_BUILTIN_TOOL_IDS: ("automation" | "workflow" | "find" | "image" | "knowledge_search" | "knowledge_get" | "knowledge_write" | "user_context_search" | "user_context_get" | "user_context_update" | "web_search" | "web_fetch" | "browser_use" | "grep" | "session_search" | "read_file" | "list_dir" | "write_file" | "apply_patch" | "exec_command" | "update_plan" | "todo" | "web_extract" | "clarify" | "xopc_tool_execute" | "tool_manual" | "session_status" | "read_media" | "xopc_tool_search" | "xopc_tool_describe" | "image_generate" | "skills_list" | "skill_view" | "skill_manage" | "skills_marketplace_search" | "computer_use" | "send_message" | "text_to_speech" | "execute_code" | "send_media" | "create_share" | "memory_maintenance" | "delegate_task" | "skill_install" | "create_desktop_pet")[];

package/dist/src/gateway/global-defaults-admin.d.ts

@@ -6,6 +6,8 @@ export type GlobalDefaultsPayload = {
 };
 export type UpdateGlobalDefaultsBody = {
     defaults: AgentDefaults;
+    scope?: 'models' | 'agent';
+    expectedModels?: AgentDefaults['models'];
 };
 export type GlobalDefaultsAdminResult<T> = {
     ok: true;
@@ -13,7 +15,7 @@ export type GlobalDefaultsAdminResult<T> = {
 } | {
     ok: false;
     error: string;
-    status?: 400 | 404 | 500;
+    status?: 400 | 404 | 409 | 500;
 };
 export declare function listGlobalDefaults(): GlobalDefaultsPayload;
 export declare function prepareUpdateGlobalDefaults(body: UpdateGlobalDefaultsBody): GlobalDefaultsAdminResult<{

package/dist/src/gateway/global-defaults-admin.js

@@ -18,13 +18,25 @@ function listGlobalDefaults() {
 	};
 }
 function prepareUpdateGlobalDefaults(body) {
-	const parsed = AgentDefaultsSchema.safeParse(body.defaults);
+	const current = new AgentCatalogRepository().getSettings().defaults;
+	if (body.expectedModels && !isDeepStrictEqual(current.models, body.expectedModels)) return {
+		ok: false,
+		error: "Model settings changed. Refresh before retrying.",
+		status: 409
+	};
+	const requested = body.scope === "models" ? {
+		...current,
+		models: body.defaults.models
+	} : body.scope === "agent" ? {
+		...body.defaults,
+		models: current.models
+	} : body.defaults;
+	const parsed = AgentDefaultsSchema.safeParse(requested);
 	if (!parsed.success) return {
 		ok: false,
 		error: `defaults ${parsed.error.issues[0]?.message ?? "is invalid"}`,
 		status: 400
 	};
-	const current = new AgentCatalogRepository().getSettings().defaults;
 	try {
 		validateComputerModelChange(parsed.data.models.computerUse, current.models.computerUse);
 	} catch (error) {

package/dist/src/gateway/hono/lib/config-payload.d.ts

@@ -27,7 +27,11 @@ export declare function buildSafeWebConfigPayload(service: GatewayService, optio
                     primary: string;
                     fallbacks: string[];
                 };
-                intents?: Partial<Record<"review" | "coding" | "fast" | "reasoning" | "vision" | "understanding", {
+                background?: {
+                    primary: string;
+                    fallbacks: string[];
+                };
+                intents?: Partial<Record<"review" | "coding" | "vision" | "fast" | "reasoning" | "understanding", {
                     primary: string;
                     fallbacks: string[];
                 }>>;
@@ -71,10 +75,14 @@ export declare function buildSafeWebConfigPayload(service: GatewayService, optio
                     primary: string;
                     fallbacks: string[];
                 };
-                intents: Partial<Record<"review" | "coding" | "fast" | "reasoning" | "vision" | "understanding", {
+                intents: Partial<Record<"review" | "coding" | "vision" | "fast" | "reasoning" | "understanding", {
                     primary: string;
                     fallbacks: string[];
                 }>>;
+                background?: {
+                    primary: string;
+                    fallbacks: string[];
+                };
                 imageUnderstanding?: {
                     primary: string;
                     fallbacks: string[];
@@ -320,6 +328,7 @@ export declare function buildSafeWebConfigPayload(service: GatewayService, optio
             betaCheckIntervalHours: number;
         };
     };
+    voiceSettingsRevisions: Record<"conversation" | "transcription" | "speech", string>;
     stt: unknown;
     tts: unknown;
     voice: unknown;