@xopcai/xopc 0.0.178 → 0.0.180

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

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import type { Config } from '../config/schema.js';
+import type { DiscussionAnalysis } from './types.js';
+declare const LiveEnrichmentSchema: z.ZodObject<{
+    title: z.ZodString;
+    projectCandidateId: z.ZodOptional<z.ZodString>;
+    projectConfidence: z.ZodOptional<z.ZodNumber>;
+    projectAlternativeConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare function normalizeDiscussionAnalysis(value: unknown): DiscussionAnalysis;
+export declare function analyzeDiscussion(input: {
+    config: Config;
+    transcript: string;
+    languageHint?: string;
+    projects?: Array<{
+        id: string;
+        name: string;
+    }>;
+    signal?: AbortSignal;
+}): Promise<{
+    analysis: DiscussionAnalysis;
+    modelRef: string;
+}>;
+export declare function enrichLiveDiscussion(input: {
+    config: Config;
+    transcript: string;
+    projects: Array<{
+        id: string;
+        name: string;
+    }>;
+    signal?: AbortSignal;
+}): Promise<z.infer<typeof LiveEnrichmentSchema> & {
+    modelRef: string;
+}>;
+export {};

package/dist/src/discussions/analyzer.js

@@ -0,0 +1,127 @@
+import { getAgentDefaultModelRef, init_schema } from "../config/schema.js";
+import { init_providers, resolveModel } from "../providers/index.js";
+import { completeWithResolvedCredentials } from "../providers/model-call.js";
+import { createHash } from "node:crypto";
+import { z } from "zod";
+//#region src/discussions/analyzer.ts
+init_schema();
+init_providers();
+const MAX_TRANSCRIPT_CHARS = 12e4;
+const AnalysisSchema = z.object({
+	title: z.string().trim().min(1).max(200),
+	summary: z.string().trim().min(1).max(4e3),
+	keyPoints: z.array(z.string().trim().min(1).max(1e3)).max(12).default([]),
+	decisions: z.array(z.string().trim().min(1).max(1e3)).max(12).default([]),
+	actionItems: z.array(z.object({
+		id: z.string().trim().min(1).max(100).optional(),
+		title: z.string().trim().min(1).max(500),
+		owner: z.string().trim().min(1).max(200).optional(),
+		dueDate: z.string().trim().min(1).max(100).optional()
+	})).max(20).default([]),
+	risks: z.array(z.string().trim().min(1).max(1e3)).max(12).default([]),
+	openQuestions: z.array(z.string().trim().min(1).max(1e3)).max(12).default([]),
+	projectCandidateId: z.string().trim().min(1).max(200).optional(),
+	projectConfidence: z.number().min(0).max(1).optional(),
+	projectAlternativeConfidence: z.number().min(0).max(1).optional()
+});
+const LiveEnrichmentSchema = z.object({
+	title: z.string().trim().min(1).max(200),
+	projectCandidateId: z.string().trim().min(1).max(200).optional(),
+	projectConfidence: z.number().min(0).max(1).optional(),
+	projectAlternativeConfidence: z.number().min(0).max(1).optional()
+});
+function extractText(content) {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	return content.map((part) => {
+		if (!part || typeof part !== "object") return "";
+		const value = part;
+		return value.type === "text" && typeof value.text === "string" ? value.text : "";
+	}).join("");
+}
+function parseJsonObject(raw) {
+	const stripped = raw.trim().replace(/^```json\s*/i, "").replace(/```$/i, "").trim();
+	try {
+		return JSON.parse(stripped);
+	} catch {
+		const start = stripped.indexOf("{");
+		const end = stripped.lastIndexOf("}");
+		if (start < 0 || end <= start) throw new Error("Discussion analysis did not return valid JSON");
+		return JSON.parse(stripped.slice(start, end + 1));
+	}
+}
+function actionId(title, index) {
+	return createHash("sha256").update(`${index}:${title}`).digest("hex").slice(0, 16);
+}
+function normalizeDiscussionAnalysis(value) {
+	const parsed = AnalysisSchema.safeParse(value);
+	if (!parsed.success) throw new Error(`Invalid discussion analysis: ${parsed.error.issues[0]?.message ?? "schema mismatch"}`);
+	return {
+		...parsed.data,
+		actionItems: parsed.data.actionItems.map((item, index) => ({
+			id: item.id ?? actionId(item.title, index),
+			title: item.title,
+			...item.owner ? { owner: item.owner } : {},
+			...item.dueDate ? { dueDate: item.dueDate } : {}
+		}))
+	};
+}
+async function analyzeDiscussion(input) {
+	const modelRef = getAgentDefaultModelRef(input.config);
+	if (!modelRef) throw new Error("No default model configured for discussion analysis");
+	const transcript = input.transcript.trim().slice(0, MAX_TRANSCRIPT_CHARS);
+	if (!transcript) throw new Error("Discussion transcript is empty");
+	const message = {
+		role: "user",
+		content: [
+			"Analyze the supplied workplace discussion transcript.",
+			"Use only facts explicitly present in the transcript. Do not invent owners, dates, decisions, or commitments.",
+			"Return exactly one JSON object with: title, summary, keyPoints, decisions, actionItems, risks, openQuestions, and optional projectCandidateId, projectConfidence, and projectAlternativeConfidence.",
+			"title is a short concrete note title derived from the discussion.",
+			"actionItems contains title and optional owner and dueDate. Omit owner or dueDate when not explicit.",
+			"Keep unresolved possibilities in openQuestions, not decisions.",
+			input.projects?.length ? `Choose projectCandidateId only from this catalog when the discussion clearly belongs to it; otherwise omit it. projectConfidence is the top probability and projectAlternativeConfidence is the runner-up probability: ${JSON.stringify(input.projects.slice(0, 100))}` : "Omit projectCandidateId and projectConfidence.",
+			`Use ${input.languageHint === "en" ? "English" : input.languageHint === "zh" ? "Simplified Chinese" : "the main language of the transcript"} for every user-facing string.`,
+			"",
+			transcript
+		].join("\n"),
+		timestamp: Date.now()
+	};
+	return {
+		modelRef,
+		analysis: normalizeDiscussionAnalysis(parseJsonObject(extractText((await completeWithResolvedCredentials(resolveModel(modelRef), { messages: [message] }, {
+			maxTokens: 3e3,
+			temperature: .1,
+			signal: input.signal
+		})).content)))
+	};
+}
+async function enrichLiveDiscussion(input) {
+	const modelRef = getAgentDefaultModelRef(input.config);
+	if (!modelRef) throw new Error("No default model configured for discussion enrichment");
+	const transcript = input.transcript.trim().slice(0, 12e3);
+	if (!transcript) throw new Error("Discussion transcript is empty");
+	const message = {
+		role: "user",
+		content: [
+			"Create a short concrete note title for this partial workplace discussion transcript.",
+			"Return exactly one JSON object with title and optional projectCandidateId, projectConfidence, and projectAlternativeConfidence.",
+			"Choose a project only when the transcript clearly belongs to it. Never invent a project id.",
+			`Project catalog: ${JSON.stringify(input.projects.slice(0, 100))}`,
+			"",
+			transcript
+		].join("\n"),
+		timestamp: Date.now()
+	};
+	const response = await completeWithResolvedCredentials(resolveModel(modelRef), { messages: [message] }, {
+		maxTokens: 400,
+		temperature: .1,
+		signal: input.signal
+	});
+	return {
+		modelRef,
+		...LiveEnrichmentSchema.parse(parseJsonObject(extractText(response.content)))
+	};
+}
+//#endregion
+export { analyzeDiscussion, enrichLiveDiscussion, normalizeDiscussionAnalysis };

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

@@ -0,0 +1,7 @@
+export { DISCUSSION_AUDIO_MAX_BYTES, DISCUSSION_MAX_DURATION_MS, DiscussionService, DiscussionServiceError, } from './service.js';
+export { analyzeDiscussion } from './analyzer.js';
+export { DiscussionPipeline, mergeDiscussionAnalysisIntoMarkdown } from './pipeline.js';
+export { DiscussionLiveWorker } from './live-worker.js';
+export { DiscussionWorker } from './worker.js';
+export { DISCUSSION_STATUSES } from './types.js';
+export type * from './types.js';

package/dist/src/discussions/index.js

@@ -0,0 +1,7 @@
+import { analyzeDiscussion } from "./analyzer.js";
+import { DISCUSSION_AUDIO_MAX_BYTES, DISCUSSION_MAX_DURATION_MS, DiscussionService, DiscussionServiceError } from "./service.js";
+import { DiscussionPipeline, mergeDiscussionAnalysisIntoMarkdown } from "./pipeline.js";
+import { DiscussionLiveWorker } from "./live-worker.js";
+import { DiscussionWorker } from "./worker.js";
+import { DISCUSSION_STATUSES } from "./types.js";
+export { DISCUSSION_AUDIO_MAX_BYTES, DISCUSSION_MAX_DURATION_MS, DISCUSSION_STATUSES, DiscussionLiveWorker, DiscussionPipeline, DiscussionService, DiscussionServiceError, DiscussionWorker, analyzeDiscussion, mergeDiscussionAnalysisIntoMarkdown };

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

@@ -0,0 +1,33 @@
+import type { Config } from '../config/schema.js';
+import type { NotesService } from '../notes/service.js';
+import type { ProjectService } from '../projects/project-service.js';
+import { enrichLiveDiscussion } from './analyzer.js';
+import type { DiscussionCapture } from './types.js';
+export interface DiscussionLiveWorkerDeps {
+    notes: NotesService;
+    projects: ProjectService;
+    getConfig: () => Config;
+    transcribeSegment?: (buffer: Buffer, signal?: AbortSignal) => Promise<{
+        text: string;
+        provider: string;
+    }>;
+    enrichTranscript?: typeof enrichLiveDiscussion;
+    onTranscriptUpdated?: (discussionId: string, sequence: number) => void;
+    onDiscussionUpdated?: (capture: DiscussionCapture) => void;
+}
+export declare class DiscussionLiveWorker {
+    private readonly deps;
+    private readonly intervalMs;
+    private readonly owner;
+    private readonly objectLinks;
+    private timer?;
+    private running;
+    private stoppedWaiters;
+    constructor(deps: DiscussionLiveWorkerDeps, intervalMs?: number);
+    start(): void;
+    stop(): Promise<void>;
+    tick(): Promise<void>;
+    private transcribeSegment;
+    private enrichOnce;
+    private linkProject;
+}

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

@@ -0,0 +1,148 @@
+import { createLogger } from "../utils/logger/index.js";
+import { init_logger } from "../utils/logger.js";
+import { ObjectLinkService } from "../activity/service.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 { enrichLiveDiscussion } from "./analyzer.js";
+import { claimNextDiscussionTranscriptSegment, completeDiscussionTranscriptSegment, getDiscussionCapture, listDiscussionTranscriptSegments, retryOrFailDiscussionTranscriptSegment, updateDiscussionCapture } from "./repository.js";
+import { assembleDiscussionTranscript } from "./transcript.js";
+import { acceptRankedProject, findExactProjectMention } from "./project-inference.js";
+import { randomUUID } from "node:crypto";
+//#region src/discussions/live-worker.ts
+init_logger();
+const log = createLogger("DiscussionLiveWorker");
+const MAX_ATTEMPTS = 3;
+const MIN_ENRICHMENT_CHARS = 80;
+var DiscussionLiveWorker = class {
+	owner = randomUUID();
+	objectLinks = new ObjectLinkService();
+	timer;
+	running = false;
+	stoppedWaiters = [];
+	constructor(deps, intervalMs = 1e3) {
+		this.deps = deps;
+		this.intervalMs = intervalMs;
+	}
+	start() {
+		if (this.timer) return;
+		this.timer = setInterval(() => void this.tick(), this.intervalMs);
+		this.timer.unref();
+		this.tick();
+	}
+	async stop() {
+		if (this.timer) clearInterval(this.timer);
+		this.timer = void 0;
+		if (!this.running) return;
+		await new Promise((resolve) => this.stoppedWaiters.push(resolve));
+	}
+	async tick() {
+		if (this.running) return;
+		this.running = true;
+		try {
+			const segment = claimNextDiscussionTranscriptSegment(this.owner);
+			if (!segment) return;
+			try {
+				const result = this.deps.transcribeSegment ? await this.deps.transcribeSegment(segment.audioBuffer) : await this.transcribeSegment(segment.audioBuffer);
+				if (!completeDiscussionTranscriptSegment(segment.discussionId, segment.sequence, this.owner, result.text.trim(), result.provider)) return;
+				this.deps.onTranscriptUpdated?.(segment.discussionId, segment.sequence);
+				await this.enrichOnce(segment.discussionId).catch((error) => {
+					log.warn({
+						err: error,
+						discussionId: segment.discussionId
+					}, "Live discussion enrichment failed");
+				});
+			} catch (error) {
+				const exhausted = segment.attemptCount >= MAX_ATTEMPTS;
+				const message = error instanceof Error ? error.message : String(error);
+				retryOrFailDiscussionTranscriptSegment(segment.discussionId, segment.sequence, this.owner, message, exhausted);
+				this.deps.onTranscriptUpdated?.(segment.discussionId, segment.sequence);
+				log.warn({
+					err: error,
+					discussionId: segment.discussionId,
+					sequence: segment.sequence,
+					exhausted
+				}, `Live discussion transcription failed: ${message}`);
+			}
+		} finally {
+			this.running = false;
+			const waiters = this.stoppedWaiters.splice(0);
+			for (const resolve of waiters) resolve();
+		}
+	}
+	async transcribeSegment(buffer, signal) {
+		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: "audio/wav",
+			fileName: "discussion-segment.wav",
+			signal
+		});
+	}
+	async enrichOnce(discussionId) {
+		const capture = getDiscussionCapture(discussionId);
+		if (!capture || capture.generatedTitle || capture.status === "cancelled" || capture.status === "completed") return;
+		const transcript = assembleDiscussionTranscript(listDiscussionTranscriptSegments(discussionId));
+		if (transcript.length < MIN_ENRICHMENT_CHARS) return;
+		const projects = this.deps.projects.list({
+			status: "active",
+			limit: 100
+		}).items;
+		const enrichment = await (this.deps.enrichTranscript ?? enrichLiveDiscussion)({
+			config: this.deps.getConfig(),
+			transcript,
+			projects: projects.map(({ id, name }) => ({
+				id,
+				name
+			}))
+		});
+		const exact = capture.projectId ? void 0 : findExactProjectMention(transcript, projects);
+		const ranked = capture.projectId ? void 0 : acceptRankedProject(enrichment, projects);
+		const inferred = exact ? {
+			id: exact.id,
+			score: 1,
+			source: "exact_name"
+		} : ranked ? {
+			...ranked,
+			source: "model"
+		} : void 0;
+		const note = await this.deps.notes.getNote(capture.noteId);
+		if (!note) throw new Error("Discussion note is missing");
+		if (note.title !== enrichment.title) {
+			if (!await this.deps.notes.updateNote(capture.noteId, { title: enrichment.title }, "ai_edit")) throw new Error("Discussion note disappeared while applying the live title");
+		}
+		const updated = updateDiscussionCapture(discussionId, {
+			generatedTitle: enrichment.title,
+			...inferred ? {
+				projectId: inferred.id,
+				projectInferenceScore: inferred.score,
+				projectInferenceSource: inferred.source
+			} : {}
+		}, [capture.status]);
+		if (!updated) return;
+		if (inferred) this.linkProject(updated, inferred.id);
+		this.deps.onDiscussionUpdated?.(updated);
+	}
+	linkProject(capture, projectId) {
+		const project = this.deps.projects.get(projectId);
+		if (!project) return;
+		this.objectLinks.create({
+			id: `discussion:${capture.id}:project`,
+			from: {
+				kind: "note",
+				id: capture.noteId
+			},
+			to: {
+				kind: "project",
+				id: project.id,
+				title: project.name
+			},
+			relation: "belongs_to",
+			source: "agent"
+		});
+	}
+};
+//#endregion
+export { DiscussionLiveWorker };

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

@@ -0,0 +1,33 @@
+import type { Config } from '../config/schema.js';
+import type { NotesService } from '../notes/service.js';
+import type { ProjectService } from '../projects/project-service.js';
+import type { DiscussionAnalysis, DiscussionCapture } from './types.js';
+export interface DiscussionTranscriptionResult {
+    text: string;
+    provider: string;
+    language?: string;
+}
+export interface DiscussionPipelineDeps {
+    notes: NotesService;
+    projects: ProjectService;
+    getConfig: () => Config;
+    transcribeAudio?: (buffer: Buffer, capture: DiscussionCapture, signal?: AbortSignal) => Promise<DiscussionTranscriptionResult>;
+    analyzeTranscript?: (transcript: string, capture: DiscussionCapture, signal?: AbortSignal) => Promise<{
+        analysis: DiscussionAnalysis;
+        modelRef: string;
+    }>;
+    onUpdated?: (capture: DiscussionCapture) => void;
+    onCompleted?: (capture: DiscussionCapture, analysis: DiscussionAnalysis) => void;
+}
+export declare function mergeDiscussionAnalysisIntoMarkdown(markdown: string, transcript: string, analysis: DiscussionAnalysis, audioRef?: string): string;
+export declare class DiscussionPipeline {
+    private readonly deps;
+    private readonly objectLinks;
+    constructor(deps: DiscussionPipelineDeps);
+    process(capture: DiscussionCapture, owner: string, signal?: AbortSignal): Promise<DiscussionCapture>;
+    private transcribe;
+    private analyze;
+    private writeNote;
+    private linkProject;
+    private defaultTranscribe;
+}

package/dist/src/discussions/pipeline.js

@@ -0,0 +1,205 @@
+import { buildNoteAttachmentRef } from "../notes/attachment-ref.js";
+import { ObjectLinkService } from "../activity/service.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 { analyzeDiscussion } from "./analyzer.js";
+import { deleteDiscussionSegmentAudio, updateDiscussionCapture } from "./repository.js";
+import { acceptRankedProject, findExactProjectMention } from "./project-inference.js";
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+//#region src/discussions/pipeline.ts
+const MANAGED_START = "<!-- xopc:discussion-analysis:start -->";
+const MANAGED_END = "<!-- xopc:discussion-analysis:end -->";
+function list(values) {
+	return values.length > 0 ? values.map((value) => `- ${value}`).join("\n") : "- None identified";
+}
+function renderManagedSection(transcript, analysis) {
+	const actions = analysis.actionItems.length > 0 ? analysis.actionItems.map((item) => {
+		const metadata = [item.owner ? `Owner: ${item.owner}` : "", item.dueDate ? `Due: ${item.dueDate}` : ""].filter(Boolean).join(" · ");
+		return `- [ ] ${item.title}${metadata ? ` — ${metadata}` : ""}`;
+	}).join("\n") : "- None identified";
+	return [
+		MANAGED_START,
+		"## Summary",
+		analysis.summary,
+		"",
+		"## Key points",
+		list(analysis.keyPoints),
+		"",
+		"## Decisions",
+		list(analysis.decisions),
+		"",
+		"## Action items",
+		actions,
+		"",
+		"## Risks",
+		list(analysis.risks),
+		"",
+		"## Open questions",
+		list(analysis.openQuestions),
+		"",
+		"## Transcript",
+		transcript.trim(),
+		MANAGED_END
+	].join("\n");
+}
+function mergeDiscussionAnalysisIntoMarkdown(markdown, transcript, analysis, audioRef) {
+	const managed = renderManagedSection(transcript, analysis);
+	const withoutPlaceholder = markdown.replace(/^> Recording in progress\. Live transcript will appear here\.\s*$/gm, "").replace(/^> Finalizing recording\.\.\.\s*$/gm, "").replace(/\n{3,}/g, "\n\n").trim();
+	const start = withoutPlaceholder.indexOf(MANAGED_START);
+	const end = withoutPlaceholder.indexOf(MANAGED_END);
+	const base = start >= 0 && end >= start ? `${withoutPlaceholder.slice(0, start).trimEnd()}\n\n${managed}${withoutPlaceholder.slice(end + 37)}`.trim() : `${withoutPlaceholder}\n\n${managed}`.trim();
+	return audioRef && !base.includes(`](${audioRef})`) ? `${base}\n\n[Discussion audio](${audioRef})` : base;
+}
+var DiscussionPipeline = class {
+	objectLinks = new ObjectLinkService();
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async process(capture, owner, signal) {
+		let current = capture;
+		if (!current.transcriptRaw) current = await this.transcribe(current, owner, signal);
+		if (!current.analysis) current = await this.analyze(current, owner, signal);
+		return this.writeNote(current);
+	}
+	async transcribe(capture, owner, signal) {
+		if (!capture.audioAttachmentId) throw new Error("Discussion audio attachment is missing");
+		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);
+		const result = this.deps.transcribeAudio ? await this.deps.transcribeAudio(buffer, capture, signal) : await this.defaultTranscribe(buffer, capture, attachment, signal);
+		const transcript = result.text.trim();
+		if (!transcript) throw new Error("Discussion transcription produced no text");
+		const updated = updateDiscussionCapture(capture.id, {
+			processingStage: "analysis",
+			transcriptRaw: transcript,
+			transcriptSha256: createHash("sha256").update(transcript).digest("hex"),
+			transcriptLanguage: result.language,
+			sttProvider: result.provider,
+			lastErrorCode: void 0,
+			lastErrorMessage: void 0,
+			leaseOwner: owner,
+			leaseExpiresAt: Date.now() + 5 * 6e4
+		}, ["finalizing"]);
+		if (!updated) throw new Error("Discussion changed while transcribing");
+		this.deps.onUpdated?.(updated);
+		return updated;
+	}
+	async analyze(capture, owner, signal) {
+		if (!capture.transcriptRaw) throw new Error("Discussion transcript is missing");
+		const projects = this.deps.projects.list({
+			status: "active",
+			limit: 100
+		}).items;
+		const result = this.deps.analyzeTranscript ? await this.deps.analyzeTranscript(capture.transcriptRaw, capture, signal) : await analyzeDiscussion({
+			config: this.deps.getConfig(),
+			transcript: capture.transcriptRaw,
+			projects: projects.map(({ id, name }) => ({
+				id,
+				name
+			})),
+			signal
+		});
+		const analysis = result.analysis;
+		let inferredProject;
+		if (!capture.projectId) {
+			const exact = findExactProjectMention(capture.transcriptRaw, projects);
+			const ranked = acceptRankedProject(analysis, projects);
+			if (exact) inferredProject = {
+				id: exact.id,
+				score: 1,
+				source: "exact_name"
+			};
+			else if (ranked) inferredProject = {
+				...ranked,
+				source: "model"
+			};
+		}
+		const updated = updateDiscussionCapture(capture.id, {
+			processingStage: "note_write",
+			analysis,
+			analysisInputHash: capture.transcriptSha256,
+			analyzerModelRef: result.modelRef,
+			generatedTitle: analysis.title,
+			...inferredProject ? {
+				projectId: inferredProject.id,
+				projectInferenceScore: inferredProject.score,
+				projectInferenceSource: inferredProject.source
+			} : {},
+			leaseOwner: owner,
+			leaseExpiresAt: Date.now() + 5 * 6e4
+		}, ["finalizing"]);
+		if (!updated) throw new Error("Discussion changed while analyzing");
+		if (inferredProject) this.linkProject(updated, inferredProject.id);
+		this.deps.onUpdated?.(updated);
+		return updated;
+	}
+	async writeNote(capture) {
+		if (!capture.transcriptRaw || !capture.analysis || !capture.audioAttachmentId) throw new Error("Discussion finalization data is incomplete");
+		const note = await this.deps.notes.getNote(capture.noteId);
+		if (!note) throw new Error("Discussion note is missing");
+		const title = capture.analysis.title.trim().slice(0, 200);
+		const audioRef = buildNoteAttachmentRef(capture.noteId, capture.audioAttachmentId);
+		const markdown = mergeDiscussionAnalysisIntoMarkdown(note.markdown, capture.transcriptRaw, capture.analysis, audioRef);
+		const attachments = (note.attachments ?? []).map((attachment) => attachment.id === capture.audioAttachmentId ? {
+			...attachment,
+			transcript: capture.transcriptRaw
+		} : attachment);
+		if (capture.projectId && capture.projectInferenceSource !== "context") this.linkProject(capture, capture.projectId);
+		if (note.title !== title || note.markdown !== markdown || note.status !== "processed") await this.deps.notes.updateNote(capture.noteId, {
+			title,
+			markdown,
+			attachments,
+			status: "processed"
+		}, "ai_edit");
+		const now = Date.now();
+		const updated = updateDiscussionCapture(capture.id, {
+			status: "completed",
+			processingStage: void 0,
+			finalizationRevision: capture.finalizationRevision + 1,
+			completedAt: now,
+			leaseOwner: void 0,
+			leaseExpiresAt: void 0,
+			nextAttemptAt: void 0,
+			lastErrorCode: void 0,
+			lastErrorMessage: void 0
+		}, ["finalizing"]);
+		if (!updated || updated.leaseOwner) throw new Error("Discussion changed while writing the note");
+		deleteDiscussionSegmentAudio(capture.id);
+		this.deps.onUpdated?.(updated);
+		this.deps.onCompleted?.(updated, capture.analysis);
+		return updated;
+	}
+	linkProject(capture, projectId) {
+		const project = this.deps.projects.get(projectId);
+		if (!project) return;
+		this.objectLinks.create({
+			id: `discussion:${capture.id}:project`,
+			from: {
+				kind: "note",
+				id: capture.noteId
+			},
+			to: {
+				kind: "project",
+				id: project.id,
+				title: project.name
+			},
+			relation: "belongs_to",
+			source: "agent"
+		});
+	}
+	async defaultTranscribe(buffer, capture, attachment, signal) {
+		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,
+			signal
+		});
+	}
+};
+//#endregion
+export { DiscussionPipeline, mergeDiscussionAnalysisIntoMarkdown };

package/dist/src/discussions/project-inference.d.ts

@@ -0,0 +1,13 @@
+export interface DiscussionProjectCandidate {
+    id: string;
+    name: string;
+}
+export declare function findExactProjectMention(transcript: string, projects: DiscussionProjectCandidate[]): DiscussionProjectCandidate | undefined;
+export declare function acceptRankedProject(input: {
+    projectCandidateId?: string;
+    projectConfidence?: number;
+    projectAlternativeConfidence?: number;
+}, projects: DiscussionProjectCandidate[]): {
+    id: string;
+    score: number;
+} | undefined;

package/dist/src/discussions/project-inference.js

@@ -0,0 +1,19 @@
+//#region src/discussions/project-inference.ts
+function findExactProjectMention(transcript, projects) {
+	const normalizedTranscript = normalize(transcript);
+	const matches = projects.filter((project) => normalizedTranscript.includes(normalize(project.name)));
+	return matches.length === 1 ? matches[0] : void 0;
+}
+function acceptRankedProject(input, projects) {
+	const score = input.projectConfidence ?? 0;
+	if (!input.projectCandidateId || !projects.some((project) => project.id === input.projectCandidateId) || score < .85 || score - (input.projectAlternativeConfidence ?? 0) < .15) return void 0;
+	return {
+		id: input.projectCandidateId,
+		score
+	};
+}
+function normalize(value) {
+	return value.normalize("NFKC").toLocaleLowerCase().replace(/\s+/g, " ").trim();
+}
+//#endregion
+export { acceptRankedProject, findExactProjectMention };

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

@@ -0,0 +1,29 @@
+import type { DiscussionCapture, DiscussionCaptureSettings, DiscussionListResult, DiscussionMetrics, DiscussionStatus, DiscussionTranscriptSegment, ListDiscussionsQuery } from './types.js';
+export interface ClaimedDiscussionTranscriptSegment extends DiscussionTranscriptSegment {
+    audioBuffer: Buffer;
+}
+export declare function createDiscussionCapture(capture: DiscussionCapture): DiscussionCapture;
+export declare function getDiscussionCapture(id: string): DiscussionCapture | null;
+export declare function getDiscussionCaptureByClientRequestId(clientRequestId: string): DiscussionCapture | null;
+export declare function getDiscussionCaptureByNoteId(noteId: string): DiscussionCapture | null;
+export declare function listDiscussionCaptures(query?: ListDiscussionsQuery): DiscussionListResult;
+export declare function getDiscussionMetrics(): DiscussionMetrics;
+export declare function updateDiscussionCapture(id: string, patch: Partial<Omit<DiscussionCapture, 'id' | 'clientRequestId' | 'noteId' | 'createdAt'>>, expectedStatuses?: DiscussionStatus[]): DiscussionCapture | null;
+export declare function claimNextDiscussionCapture(owner: string, now?: number, leaseMs?: number): DiscussionCapture | null;
+export declare function createDiscussionTranscriptSegment(input: {
+    discussionId: string;
+    sequence: number;
+    audioSha256: string;
+    audioBuffer: Buffer;
+    startedAtMs: number;
+    endedAtMs: number;
+    now?: number;
+}): DiscussionTranscriptSegment;
+export declare function getDiscussionTranscriptSegment(discussionId: string, sequence: number): DiscussionTranscriptSegment | null;
+export declare function listDiscussionTranscriptSegments(discussionId: string): DiscussionTranscriptSegment[];
+export declare function claimNextDiscussionTranscriptSegment(owner: string, now?: number, leaseMs?: number): ClaimedDiscussionTranscriptSegment | null;
+export declare function completeDiscussionTranscriptSegment(discussionId: string, sequence: number, owner: string, transcript: string, provider: string): DiscussionTranscriptSegment | null;
+export declare function retryOrFailDiscussionTranscriptSegment(discussionId: string, sequence: number, owner: string, error: string, exhausted: boolean): DiscussionTranscriptSegment | null;
+export declare function deleteDiscussionSegmentAudio(discussionId: string): void;
+export declare function getDiscussionCaptureSettings(): DiscussionCaptureSettings;
+export declare function acknowledgeDiscussionCaptureConsent(policyVersion: number): DiscussionCaptureSettings;