@xopcai/xopc 0.0.389 → 0.0.391

package/dist/src/discussions/audio-clip.js

@@ -0,0 +1,72 @@
+import { spawnProcess } from "../process/run-process.js";
+import { DiscussionServiceError } from "./errors.js";
+import { getDiscussionCapture } from "./repository.js";
+//#region src/discussions/audio-clip.ts
+let active = 0;
+/** A bounded playback derivative for native clients that require per-request device proofs. */
+async function discussionAudioClip(id, startMs, endMs, notes, signal) {
+	if (!Number.isFinite(startMs) || !Number.isFinite(endMs) || startMs < 0 || endMs <= startMs || endMs - startMs > 12e4) throw new DiscussionServiceError("invalid_input", "Audio clip must be at most 120 seconds");
+	const capture = getDiscussionCapture(id);
+	if (!capture || !capture.audioAttachmentId || capture.audioDeletedAt) throw new DiscussionServiceError("not_found", "Original audio unavailable");
+	const source = await notes.getAttachmentPath(capture.noteId, capture.audioAttachmentId);
+	if (!source) throw new DiscussionServiceError("not_found", "Original audio unavailable");
+	if (active >= 2) throw new DiscussionServiceError("conflict", "Audio playback is busy; retry shortly");
+	active++;
+	try {
+		return await new Promise((resolve, reject) => {
+			signal.throwIfAborted();
+			const handle = spawnProcess({
+				program: process.env.XOPC_FFMPEG_PATH || "ffmpeg",
+				args: [
+					"-v",
+					"error",
+					"-protocol_whitelist",
+					"file,pipe",
+					"-ss",
+					String(startMs / 1e3),
+					"-i",
+					source.filePath,
+					"-t",
+					String((endMs - startMs) / 1e3),
+					"-map",
+					"0:a:0",
+					"-vn",
+					"-ar",
+					"16000",
+					"-ac",
+					"1",
+					"-f",
+					"wav",
+					"pipe:1"
+				],
+				maxOutputBytes: 0
+			});
+			const child = handle.child;
+			const chunks = [];
+			let bytes = 0;
+			const abort = () => {
+				handle.terminate();
+				reject(/* @__PURE__ */ new Error("Audio clip interrupted"));
+			};
+			const timer = setTimeout(abort, 3e4);
+			timer.unref();
+			signal.addEventListener("abort", abort, { once: true });
+			child.stdout?.on("data", (chunk) => {
+				bytes += chunk.length;
+				if (bytes > 4 * 1024 * 1024) abort();
+				else chunks.push(chunk);
+			});
+			child.once("error", reject);
+			child.once("close", (code) => {
+				clearTimeout(timer);
+				signal.removeEventListener("abort", abort);
+				if (code || bytes <= 44) reject(/* @__PURE__ */ new Error("Audio clip unavailable"));
+				else resolve(Buffer.concat(chunks));
+			});
+		});
+	} finally {
+		active--;
+	}
+}
+//#endregion
+export { discussionAudioClip };

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

@@ -1,6 +1,7 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { ObjectLinkService } from "../activity/service.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";
@@ -11,6 +12,7 @@ import { enrichLiveDiscussion } from "./analyzer.js";
 import { acceptRankedProject, findExactProjectMention } from "./project-inference.js";
 import { randomUUID } from "node:crypto";
 //#region src/discussions/live-worker.ts
+init_model_usage();
 init_logger();
 const log = createLogger("DiscussionLiveWorker");
 const MAX_ATTEMPTS = 3;
@@ -58,7 +60,7 @@ var DiscussionLiveWorker = class {
 		if (!segment) return;
 		try {
 			try {
-				const result = this.deps.transcribeSegment ? await this.deps.transcribeSegment(segment.audioBuffer) : await this.transcribeSegment(segment.audioBuffer);
+				const result = await withModelUsageOrigin("interactive", () => this.deps.transcribeSegment ? this.deps.transcribeSegment(segment.audioBuffer) : this.transcribeSegment(segment.audioBuffer));
 				const completed = completeDiscussionTranscriptSegment(segment.discussionId, segment.sequence, this.owner, result.text.trim(), result.provider);
 				if (!completed) return;
 				this.deps.onTranscriptUpdated?.(completed);

package/dist/src/discussions/long-review.d.ts

@@ -0,0 +1,17 @@
+import type { DiscussionOrganization, DiscussionReview, DiscussionPlaybackRange } from '@xopcai/gateway-contract';
+import type { NotesService } from '../notes/service.js';
+export type ChapterScope = {
+    source: string;
+    revision: number;
+    transcript: string;
+};
+export declare function chapterScope(id: string): ChapterScope;
+export declare function saveReviewChapter(id: string, hash: string, position: number, chapter: DiscussionOrganization, scope: ChapterScope): void;
+/** Union, rather than the latest timestamp or sum, describes verified coverage. */
+export declare function unionReviewRanges(ranges: DiscussionPlaybackRange[], duration: number): DiscussionPlaybackRange[];
+export declare function longRecordingReview(id: string, notes: NotesService, options?: {
+    query?: string;
+    offset?: number;
+    limit?: number;
+    version?: string;
+}): Promise<DiscussionReview>;

package/dist/src/discussions/long-review.js

@@ -0,0 +1,278 @@
+import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { DiscussionServiceError } from "./errors.js";
+import { getDiscussionCapture, getLatestDiscussionOrganization, listDiscussionTranscriptSegments } from "./repository.js";
+import { readTranscriptRevision } from "./revisions.js";
+import { getProcessingRun } from "./processing.js";
+import { playbackRanges, pointToPcm } from "./media-timeline.js";
+import { listAnnotations, recordingTimeline } from "./review.js";
+import { createHash } from "node:crypto";
+//#region src/discussions/long-review.ts
+init_transaction();
+function chapterScope(id) {
+	const capture = getDiscussionCapture(id);
+	return {
+		source: capture.audioSha256 ?? "",
+		revision: capture.transcriptRevision,
+		transcript: capture.canonicalTranscriptSha256 ?? ""
+	};
+}
+function saveReviewChapter(id, hash, position, chapter, scope) {
+	runSqliteWriteTransaction((db) => {
+		if (JSON.stringify(chapterScope(id)) !== JSON.stringify(scope)) return;
+		db.prepare(`DELETE FROM discussion_chapter_progress WHERE discussion_id=? AND source_sha256=? AND transcript_revision=? AND transcript_sha256=? AND position=?`).run(id, scope.source, scope.revision, scope.transcript, position);
+		db.prepare("INSERT OR REPLACE INTO discussion_chapter_progress VALUES (?,?,?,?,?,?,?)").run(id, scope.source, scope.revision, scope.transcript, hash, position, JSON.stringify(chapter));
+	});
+}
+/** Union, rather than the latest timestamp or sum, describes verified coverage. */
+function unionReviewRanges(ranges, duration) {
+	const sorted = ranges.filter((r) => Number.isFinite(r.startedAtMs) && Number.isFinite(r.endedAtMs) && r.endedAtMs > r.startedAtMs).map((r) => ({
+		startedAtMs: Math.max(0, r.startedAtMs),
+		endedAtMs: Math.min(duration, r.endedAtMs)
+	})).filter((r) => r.endedAtMs > r.startedAtMs).sort((a, b) => a.startedAtMs - b.startedAtMs);
+	const output = [];
+	for (const range of sorted) {
+		const last = output.at(-1);
+		if (last && range.startedAtMs <= last.endedAtMs) last.endedAtMs = Math.max(last.endedAtMs, range.endedAtMs);
+		else output.push({ ...range });
+	}
+	return output;
+}
+const fold = (value) => value.normalize("NFKC").toLocaleLowerCase();
+function excerpt(text, query) {
+	if (text.length <= 700) return text;
+	const at = query ? Math.max(0, fold(text).indexOf(query) - 180) : 0;
+	return `${at ? "…" : ""}${text.slice(at, at + 700)}${at + 700 < text.length ? "…" : ""}`;
+}
+async function longRecordingReview(id, notes, options = {}) {
+	const capture = getDiscussionCapture(id);
+	if (!capture) throw new DiscussionServiceError("not_found", "Discussion not found");
+	const query = (options.query ?? "").trim();
+	const offset = options.offset ?? 0;
+	const limit = options.limit ?? 20;
+	if (query.length > 200 || !Number.isSafeInteger(offset) || offset < 0 || offset > 1e5 || !Number.isSafeInteger(limit) || limit < 1 || limit > 50) throw new DiscussionServiceError("invalid_input", "Invalid review query or pagination");
+	const sourceSegments = listDiscussionTranscriptSegments(id).filter((s) => s.status === "confirmed");
+	const record = getLatestDiscussionOrganization(id);
+	const organization = record?.organization;
+	const duration = capture.durationMs ?? Math.max(0, ...sourceSegments.map((s) => s.endedAtMs));
+	const run = getProcessingRun(id);
+	const checkpoints = run && run.audio_sha256 === (capture.audioSha256 ?? null) ? getSqliteDatabase().prepare("SELECT started_at_ms,ended_at_ms,result_json FROM discussion_transcription_checkpoints WHERE run_id=? ORDER BY started_at_ms").all(run.run_id) : [];
+	const scope = chapterScope(id);
+	const partialChapters = getSqliteDatabase().prepare(`SELECT chapter_json FROM discussion_chapter_progress WHERE discussion_id=? AND source_sha256=? AND transcript_revision=? AND transcript_sha256=? ORDER BY position`).all(id, scope.source, scope.revision, scope.transcript).map((row) => JSON.parse(row.chapter_json));
+	const timeline = await recordingTimeline(id, notes);
+	const attachment = capture.audioAttachmentId && !capture.audioDeletedAt ? await notes.getAttachmentPath(capture.noteId, capture.audioAttachmentId) : null;
+	const playable = (start, end) => attachment && timeline ? playbackRanges(timeline, start, end) : [];
+	const segment = (s) => ({
+		sequence: s.sequence,
+		startedAtMs: s.startedAtMs,
+		endedAtMs: s.endedAtMs,
+		text: s.displayText ?? s.rawText ?? "",
+		speakerLabel: s.speakerLabel,
+		playback: playable(s.startedAtMs, s.endedAtMs)
+	});
+	const entries = sourceSegments.map((s, index) => ({
+		id: `transcript:${capture.transcriptRevision}:${s.sequence}`,
+		kind: "transcript",
+		title: s.speakerLabel ?? "",
+		text: s.displayText ?? s.rawText ?? "",
+		transcriptRevision: capture.transcriptRevision,
+		provisional: false,
+		stale: false,
+		startedAtMs: s.startedAtMs,
+		endedAtMs: s.endedAtMs,
+		segments: sourceSegments.slice(Math.max(0, index - 1), index + 2).map(segment),
+		playback: playable(Math.max(0, s.startedAtMs - 3e3), Math.min(duration, s.endedAtMs + 5e3))
+	}));
+	if (capture.status === "sealing" || capture.status === "needs_attention" && capture.failureStage === "transcript_sealing") for (const row of checkpoints) {
+		const checkpoint = JSON.parse(row.result_json);
+		for (const [index, s] of checkpoint.segments.entries()) entries.push({
+			id: `checkpoint:${run.run_id}:${row.started_at_ms}:${index}`,
+			kind: "transcript",
+			title: "",
+			text: s.text,
+			provisional: true,
+			stale: false,
+			startedAtMs: s.startedAtMs,
+			endedAtMs: s.endedAtMs,
+			segments: [{
+				sequence: index,
+				startedAtMs: s.startedAtMs,
+				endedAtMs: s.endedAtMs,
+				text: s.text,
+				playback: playable(s.startedAtMs, s.endedAtMs)
+			}],
+			playback: playable(Math.max(0, s.startedAtMs - 3e3), Math.min(duration, s.endedAtMs + 5e3))
+		});
+	}
+	const revisions = new Map([[capture.transcriptRevision, sourceSegments]]);
+	const revisionSegments = (revision) => {
+		if (!revisions.has(revision)) revisions.set(revision, (readTranscriptRevision(id, revision) ?? []).filter((s) => s.status === "confirmed"));
+		return revisions.get(revision);
+	};
+	const annotations = listAnnotations(id).map((annotation) => {
+		const anchor = annotation.anchor;
+		const epoch = timeline?.epochs[anchor.epoch ?? 0];
+		const position = anchor.positionMs ?? (epoch && anchor.offsetMs !== void 0 ? anchor.coordinate === "pcm" ? anchor.offsetMs < epoch.durationMs ? epoch.baseMs + anchor.offsetMs : void 0 : pointToPcm(epoch, anchor.offsetMs) : void 0);
+		const durable = !!attachment && position !== void 0 && position >= 0 && position < duration;
+		const revision = anchor.transcriptRevision ?? capture.transcriptRevision;
+		const refs = anchor.type === "transcript" ? revisionSegments(revision).filter((s) => anchor.segmentIds?.includes(s.sequence)) : durable ? sourceSegments.filter((s) => s.startedAtMs <= position && s.endedAtMs > position) : [];
+		const valid = anchor.type === "transcript" ? refs.length === anchor.segmentIds?.length : durable;
+		const evidence = refs.length && valid ? {
+			transcriptRevision: revision,
+			stale: revision !== capture.transcriptRevision,
+			segments: refs.map(segment)
+		} : void 0;
+		return {
+			annotation,
+			positionMs: durable ? position : void 0,
+			evidence,
+			state: valid ? "located" : !capture.audioAttachmentId && !capture.audioDeletedAt ? "pending" : "unavailable",
+			playback: anchor.type === "transcript" ? evidence?.segments.flatMap((s) => s.playback) ?? [] : durable ? playable(Math.max(0, position - 2e3), Math.min(duration, position + 8e3)) : []
+		};
+	});
+	const chapters = [];
+	const appendChapters = (org, revision, provisional, prefix) => {
+		const historical = revisionSegments(revision);
+		org.chapters.forEach((c, index) => {
+			if (!Number.isFinite(c.startedAtMs) || !Number.isFinite(c.endedAtMs) || c.startedAtMs < 0 || c.endedAtMs <= c.startedAtMs || c.endedAtMs > duration) return;
+			const within = historical.filter((s) => s.status === "confirmed" && s.endedAtMs > c.startedAtMs && s.startedAtMs < c.endedAtMs);
+			chapters.push({
+				id: `${prefix}:${index}`,
+				kind: "chapter",
+				title: c.title,
+				text: c.summary,
+				transcriptRevision: revision,
+				provisional,
+				stale: revision !== capture.transcriptRevision,
+				startedAtMs: c.startedAtMs,
+				endedAtMs: c.endedAtMs,
+				segments: within.slice(0, 3).map(segment),
+				playback: playable(c.startedAtMs, Math.min(c.endedAtMs, c.startedAtMs + 12e4)),
+				highlightCount: annotations.filter((a) => !a.annotation.deleted && (a.positionMs ?? a.evidence?.segments[0]?.startedAtMs ?? -1) >= c.startedAtMs && (a.positionMs ?? a.evidence?.segments[0]?.startedAtMs ?? -1) < c.endedAtMs).length,
+				actionCount: org.actionItems.filter((a) => !a.ignored && a.evidenceSegmentIds.some((seq) => within.some((s) => s.sequence === seq))).length
+			});
+		});
+	};
+	if (organization) appendChapters(organization, record.transcriptRevision, false, `chapter:${record.revision}`);
+	if (capture.status !== "completed") partialChapters.forEach((org, index) => appendChapters(org, capture.transcriptRevision, true, `partial:${index}`));
+	entries.push(...chapters);
+	if (organization) {
+		const revision = record.transcriptRevision;
+		const historical = revisionSegments(revision);
+		const facts = [
+			{
+				id: "summary",
+				text: organization.summary,
+				evidenceSegmentIds: organization.summaryEvidenceSegmentIds ?? []
+			},
+			...organization.keyPointEvidence ?? [],
+			...organization.decisions,
+			...organization.risks,
+			...organization.openQuestions,
+			...organization.actionItems.map((a) => ({
+				...a,
+				text: a.title
+			}))
+		];
+		for (const fact of facts) {
+			if ("ignored" in fact && fact.ignored) continue;
+			const rev = "evidenceRevision" in fact ? fact.evidenceRevision ?? revision : revision;
+			const referenced = (rev === revision ? historical : revisionSegments(rev)).filter((s) => s.status === "confirmed" && fact.evidenceSegmentIds.includes(s.sequence));
+			entries.push({
+				id: `analysis:${record.revision}:${fact.id}`,
+				kind: "analysis",
+				title: "",
+				text: fact.text,
+				transcriptRevision: rev,
+				provisional: false,
+				stale: rev !== capture.transcriptRevision,
+				startedAtMs: referenced[0]?.startedAtMs,
+				endedAtMs: referenced.at(-1)?.endedAtMs,
+				segments: referenced.slice(0, 3).map(segment),
+				playback: referenced.slice(0, 3).flatMap((s) => playable(s.startedAtMs, s.endedAtMs))
+			});
+		}
+		if (!organization.keyPointEvidence?.length) organization.keyPoints.forEach((text, index) => entries.push({
+			id: `keypoint:${index}`,
+			kind: "analysis",
+			title: "",
+			text,
+			provisional: false,
+			stale: revision !== capture.transcriptRevision,
+			transcriptRevision: revision,
+			segments: [],
+			playback: []
+		}));
+	}
+	for (const a of annotations.filter((a) => !a.annotation.deleted)) entries.push({
+		id: `annotation:${a.annotation.id}`,
+		kind: "annotation",
+		title: a.annotation.kind,
+		text: a.annotation.text,
+		transcriptRevision: a.evidence?.transcriptRevision,
+		provisional: a.state === "pending",
+		stale: a.evidence?.stale ?? false,
+		startedAtMs: a.positionMs ?? a.evidence?.segments[0]?.startedAtMs,
+		segments: a.evidence?.segments.slice(0, 3) ?? [],
+		playback: a.playback
+	});
+	const processedRanges = unionReviewRanges((capture.status === "organizing" || capture.status === "completed") && capture.canonicalTranscript && duration > 0 ? [{
+		startedAtMs: 0,
+		endedAtMs: duration
+	}] : [...run?.force_audio ? [] : sourceSegments, ...checkpoints.map((r) => ({
+		startedAtMs: r.started_at_ms,
+		endedAtMs: r.ended_at_ms
+	}))], duration);
+	const analysisRanges = unionReviewRanges(chapters.filter((c) => c.provisional || !c.stale).map((c) => ({
+		startedAtMs: c.startedAtMs,
+		endedAtMs: c.endedAtMs
+	})), duration);
+	const needle = fold(query);
+	const matches = entries.filter((e) => needle ? fold(`${e.title}\n${e.text}\n${e.kind === "annotation" ? e.segments.map((s) => s.text).join("\n") : ""}`).includes(needle) : e.provisional && e.kind === "transcript");
+	const version = createHash("sha256").update(JSON.stringify([
+		capture.audioSha256,
+		capture.audioDeletedAt,
+		capture.status,
+		capture.transcriptRevision,
+		record?.revision,
+		processedRanges,
+		analysisRanges,
+		entries.map((e) => [
+			e.id,
+			e.title,
+			e.text,
+			e.startedAtMs,
+			e.endedAtMs,
+			e.stale,
+			e.provisional
+		])
+	])).digest("hex").slice(0, 24);
+	if (options.version && options.version !== version) throw new DiscussionServiceError("conflict", "Review updated; restart search");
+	const fresh = getDiscussionCapture(id);
+	if (fresh?.audioSha256 !== capture.audioSha256 || fresh?.transcriptRevision !== capture.transcriptRevision || fresh?.audioDeletedAt !== capture.audioDeletedAt) throw new DiscussionServiceError("conflict", "Review updated; retry");
+	return {
+		version,
+		query,
+		offset,
+		total: matches.length,
+		hasMore: offset + limit < matches.length,
+		hits: matches.slice(offset, offset + limit).map((e) => ({
+			...e,
+			text: excerpt(e.text, needle)
+		})),
+		chapters,
+		coverage: {
+			durationMs: duration,
+			audioAvailable: !!attachment,
+			transcriptRanges: unionReviewRanges(sourceSegments, duration),
+			processedRanges,
+			processedMs: processedRanges.reduce((sum, r) => sum + r.endedAtMs - r.startedAtMs, 0),
+			continuousThroughMs: processedRanges[0]?.startedAtMs === 0 ? processedRanges[0].endedAtMs : 0,
+			analysisRanges,
+			analysisRevision: record?.transcriptRevision,
+			analysisStale: !!record && record.transcriptRevision !== capture.transcriptRevision,
+			complete: capture.status === "completed"
+		}
+	};
+}
+//#endregion
+export { chapterScope, longRecordingReview, saveReviewChapter, unionReviewRanges };

package/dist/src/discussions/media-timeline.d.ts

@@ -0,0 +1,21 @@
+import type { DiscussionPlaybackRange } from '@xopcai/gateway-contract';
+export interface MediaSpan {
+    sourceMs: number;
+    pcmMs: number;
+    durationMs: number;
+}
+export interface MediaEpoch {
+    baseMs: number;
+    durationMs: number;
+    spans: MediaSpan[];
+    verified: boolean;
+}
+export interface RecordingTimeline {
+    primary: 'encoded' | 'pcm';
+    epochs: MediaEpoch[];
+}
+export declare const pcmEpoch: (durationMs: number, baseMs?: number) => MediaEpoch;
+/** Packet timestamps expose pauses without decoding the recording into memory. */
+export declare function probeMediaEpoch(path: string, durationMs: number, baseMs: number, signal: AbortSignal): Promise<MediaEpoch>;
+export declare function pointToPcm(epoch: MediaEpoch, sourceMs: number): number | undefined;
+export declare function playbackRanges(timeline: RecordingTimeline, start: number, end: number): DiscussionPlaybackRange[];

package/dist/src/discussions/media-timeline.js

@@ -0,0 +1,134 @@
+import { spawnProcess } from "../process/run-process.js";
+//#region src/discussions/media-timeline.ts
+const pcmEpoch = (durationMs, baseMs = 0) => ({
+	baseMs,
+	durationMs,
+	verified: true,
+	spans: [{
+		sourceMs: 0,
+		pcmMs: 0,
+		durationMs
+	}]
+});
+/** Packet timestamps expose pauses without decoding the recording into memory. */
+async function probeMediaEpoch(path, durationMs, baseMs, signal) {
+	const result = {
+		baseMs,
+		durationMs,
+		spans: [],
+		verified: false
+	};
+	try {
+		await new Promise((resolve, reject) => {
+			signal.throwIfAborted();
+			const handle = spawnProcess({
+				program: process.env.XOPC_FFPROBE_PATH || "ffprobe",
+				args: [
+					"-v",
+					"error",
+					"-select_streams",
+					"a:0",
+					"-show_packets",
+					"-show_entries",
+					"packet=pts_time,duration_time:packet_side_data=skip_samples,discard_padding",
+					"-of",
+					"compact=p=0",
+					path
+				],
+				maxOutputBytes: 0
+			});
+			const child = handle.child;
+			let pending = "";
+			let pcm = 0;
+			let packets = 0;
+			let lastStart = -Infinity;
+			const abort = () => {
+				handle.terminate();
+				reject(/* @__PURE__ */ new Error("Timing inspection cancelled"));
+			};
+			const timer = setTimeout(abort, 3e4);
+			timer.unref();
+			signal.addEventListener("abort", abort, { once: true });
+			child.stdout?.setEncoding("utf8");
+			child.stdout?.on("data", (text) => {
+				pending += text;
+				const lines = pending.split("\n");
+				pending = lines.pop();
+				if (pending.length > 8192) {
+					abort();
+					return;
+				}
+				for (const line of lines) {
+					if (!line.trim()) continue;
+					const fields = Object.fromEntries(line.split("|").map((part) => part.split("=")));
+					const pts = Number(fields.pts_time) * 1e3;
+					const duration = Number(fields.duration_time) * 1e3;
+					if (++packets > 1e6 || !Number.isFinite(pts) || !Number.isFinite(duration) || duration <= 0 || Number(fields.skip_samples ?? 0) !== 0 || Number(fields.discard_padding ?? 0) !== 0) {
+						abort();
+						return;
+					}
+					const start = Math.max(0, pts);
+					const length = duration - (start - pts);
+					if (length <= 0) continue;
+					const previous = result.spans.at(-1);
+					if (start <= lastStart) {
+						abort();
+						return;
+					}
+					lastStart = start;
+					if (previous && Math.abs(start - previous.sourceMs - previous.durationMs) <= 2) previous.durationMs += length;
+					else result.spans.push({
+						sourceMs: start,
+						pcmMs: pcm,
+						durationMs: length
+					});
+					pcm += length;
+					if (result.spans.length > 1e4) {
+						abort();
+						return;
+					}
+				}
+			});
+			child.once("error", reject);
+			child.once("close", (code) => {
+				clearTimeout(timer);
+				signal.removeEventListener("abort", abort);
+				if (code !== 0 || !result.spans.length || Math.abs(pcm - durationMs) > 100) {
+					reject(/* @__PURE__ */ new Error("Unverified media timing"));
+					return;
+				}
+				result.spans.at(-1).durationMs += durationMs - pcm;
+				result.verified = result.spans.at(-1).durationMs > 0;
+				resolve();
+			});
+		});
+	} catch {
+		result.verified = false;
+	}
+	return result;
+}
+function pointToPcm(epoch, sourceMs) {
+	if (!epoch.verified || !Number.isFinite(sourceMs)) return;
+	const matches = epoch.spans.filter((span) => sourceMs >= span.sourceMs && sourceMs < span.sourceMs + span.durationMs);
+	const span = matches.length === 1 ? matches[0] : void 0;
+	return span ? epoch.baseMs + span.pcmMs + sourceMs - span.sourceMs : void 0;
+}
+function playbackRanges(timeline, start, end) {
+	const total = timeline.epochs.reduce((sum, epoch) => sum + epoch.durationMs, 0);
+	if (!Number.isFinite(start) || !Number.isFinite(end) || start < 0 || end <= start || end > total + 1) return [];
+	if (timeline.primary === "pcm") return [{
+		startedAtMs: start,
+		endedAtMs: end
+	}];
+	if (!timeline.epochs.every((epoch) => epoch.verified)) return [];
+	return timeline.epochs[0].spans.flatMap((span) => {
+		const left = Math.max(start, span.pcmMs);
+		const right = Math.min(end, span.pcmMs + span.durationMs);
+		return right > left ? [{
+			startedAtMs: span.sourceMs + left - span.pcmMs,
+			endedAtMs: span.sourceMs + right - span.pcmMs
+		}] : [];
+	});
+}
+//#endregion
+export { pcmEpoch, playbackRanges, pointToPcm, probeMediaEpoch };

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

@@ -6,10 +6,13 @@ export declare class DiscussionOrganizerWorker {
     private readonly processor;
     private readonly onUpdated?;
     private readonly intervalMs;
+    private readonly requestTimeoutMs;
     private readonly owner;
     private timer?;
     private running;
-    constructor(processor: DiscussionOrganizerProcessor, onUpdated?: (capture: DiscussionCapture) => void, intervalMs?: number);
+    private stopping;
+    private controller?;
+    constructor(processor: DiscussionOrganizerProcessor, onUpdated?: (capture: DiscussionCapture) => void, intervalMs?: number, requestTimeoutMs?: number);
     start(): void;
     stop(): Promise<void>;
     tick(): Promise<void>;

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

@@ -1,6 +1,7 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
-import { claimNextDiscussionCapture, getDiscussionCapture, releaseDiscussionWorkLease, renewDiscussionWorkLease, updateDiscussionCapture } from "./repository.js";
+import { claimNextDiscussionCapture, getDiscussionCapture, releaseDiscussionWorkLease, renewDiscussionWorkLease } from "./repository.js";
+import { failOrRetryProcessing, resetProcessingRetry, withProcessingDeadline } from "./processing.js";
 import { randomUUID } from "node:crypto";
 //#region src/discussions/organizer-worker.ts
 init_logger();
@@ -9,47 +10,50 @@ var DiscussionOrganizerWorker = class {
 	owner = randomUUID();
 	timer;
 	running = false;
-	constructor(processor, onUpdated, intervalMs = 1e3) {
+	stopping = false;
+	controller;
+	constructor(processor, onUpdated, intervalMs = 1e3, requestTimeoutMs = 10 * 6e4) {
 		this.processor = processor;
 		this.onUpdated = onUpdated;
 		this.intervalMs = intervalMs;
+		this.requestTimeoutMs = requestTimeoutMs;
 	}
 	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 organizer tick failed")), this.intervalMs);
 		this.timer.unref();
-		this.tick();
+		this.tick().catch((error) => log.error({ err: error }, "Discussion organizer tick failed"));
 	}
 	async stop() {
+		this.stopping = true;
+		this.controller?.abort(/* @__PURE__ */ new Error("Discussion processing stopped"));
 		if (this.timer) clearInterval(this.timer);
 		this.timer = void 0;
 		while (this.running) await new Promise((resolve) => setTimeout(resolve, 10));
 	}
 	async tick() {
-		if (this.running) return;
+		if (this.running || this.stopping) return;
 		this.running = true;
 		try {
 			const capture = claimNextDiscussionCapture(this.owner);
 			if (!capture) return;
 			const controller = new AbortController();
+			this.controller = controller;
 			const renewal = setInterval(() => {
 				if (!renewDiscussionWorkLease(capture.id, this.owner)) controller.abort();
 			}, 3e4);
 			renewal.unref();
 			try {
-				await this.processor.process(capture, this.owner, controller.signal);
+				await withProcessingDeadline((signal) => this.processor.process(capture, this.owner, signal), controller.signal, this.requestTimeoutMs);
+				resetProcessingRetry(capture.id);
 				releaseDiscussionWorkLease(capture.id, this.owner);
 			} catch (error) {
 				const message = error instanceof Error ? error.message : String(error);
 				const ownsLease = renewDiscussionWorkLease(capture.id, this.owner);
 				releaseDiscussionWorkLease(capture.id, this.owner);
 				const current = getDiscussionCapture(capture.id);
-				const updated = ownsLease && current && updateDiscussionCapture(capture.id, {
-					status: "needs_attention",
-					failureStage: "organization",
-					failureCode: "organization_failed",
-					failureMessage: message.slice(0, 1e3)
-				}, ["organizing"]);
+				const updated = ownsLease && !controller.signal.aborted && current ? failOrRetryProcessing(current, "organization", error) : null;
 				if (updated) this.onUpdated?.(updated);
 				log.warn({
 					err: error,
@@ -57,6 +61,7 @@ var DiscussionOrganizerWorker = class {
 				}, `Discussion organization failed: ${message}`);
 			} finally {
 				clearInterval(renewal);
+				this.controller = void 0;
 			}
 		} finally {
 			this.running = false;

package/dist/src/discussions/organizer.js

@@ -2,6 +2,7 @@ import { init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/t
 import { ObjectLinkService } from "../activity/service.js";
 import { completeDiscussionOrganization, createDiscussionOrganization, getDiscussionCapture, getLatestDiscussionOrganization, listDiscussionTranscriptSegments, renewDiscussionWorkLease, updateDiscussionCapture } from "./repository.js";
 import { saveTranscriptRevision } from "./revisions.js";
+import { chapterScope } from "./long-review.js";
 import { analyzeDiscussion } from "./analyzer.js";
 import { applyMeetingEdits } from "./edits.js";
 import { acceptRankedProject, findExactProjectMention } from "./project-inference.js";
@@ -27,6 +28,7 @@ var DiscussionOrganizer = class {
 			transcript,
 			segments: listDiscussionTranscriptSegments(capture.id),
 			discussionId: capture.id,
+			reviewScope: chapterScope(capture.id),
 			template: capture.template,
 			projects: projects.map(({ id, name }) => ({
 				id,