@xopcai/xopc 0.0.180 → 0.0.187

package/dist/src/connectors/connected-source-normalizers.js

@@ -149,14 +149,14 @@ function normalizeGitHub(result, actionId) {
 		}];
 	});
 }
-function normalizeWorkItems(result, toolkit) {
+function normalizeExternalTasks(result, toolkit) {
 	return rows(payload(result), "issues", "items", "results").flatMap((item) => {
 		const externalId = text(item, "id", "identifier", "key");
 		if (!externalId) return [];
 		const occurredAt = time(item.createdAt ?? item.created_at);
 		return [{
 			externalId,
-			itemType: "work_item",
+			itemType: "external_task",
 			occurredAt,
 			sourceUpdatedAt: time(item.updatedAt ?? item.updated_at) ?? occurredAt,
 			value: compact({
@@ -168,8 +168,8 @@ function normalizeWorkItems(result, toolkit) {
 				state: item.state ?? item.status
 			}),
 			metadata: {
-				observationKind: "work_item",
-				logicalEventKey: `${toolkit}:work-item:${externalId}`
+				observationKind: "external_task",
+				logicalEventKey: `${toolkit}:task:${externalId}`
 			},
 			synthesisStatus: "pending"
 		}];
@@ -179,7 +179,7 @@ function normalizeConnectedSourceResult(input) {
 	if (input.toolkit === "gmail") return normalizeGmail(input.result);
 	if (input.toolkit === "googlecalendar") return normalizeCalendar(input.result);
 	if (input.toolkit === "github") return normalizeGitHub(input.result, input.actionId);
-	if (input.toolkit === "linear" || input.toolkit === "jira") return normalizeWorkItems(input.result, input.toolkit);
+	if (input.toolkit === "linear" || input.toolkit === "jira") return normalizeExternalTasks(input.result, input.toolkit);
 	return [];
 }
 //#endregion

package/dist/src/connectors/connector-identity.d.ts

@@ -1,2 +1,4 @@
 import type { ConnectorConnection } from './types.js';
 export declare function normalizeConnectorIdentity(toolkit: string, result: unknown): ConnectorConnection['identity'];
+export declare function connectorIdentityKey(toolkit: string, identity: Record<string, unknown>): string | undefined;
+export declare function mergeConnectorIdentity(toolkit: string, current: Record<string, unknown>, incoming: Record<string, unknown>): Record<string, unknown>;

package/dist/src/connectors/connector-identity.js

@@ -23,7 +23,70 @@ function normalizeConnectorIdentity(toolkit, result) {
 		profileUrl: text(row, ["html_url"])
 	};
 	if (toolkit === "gmail") return { email: text(row, ["emailAddress", "email"]) };
+	if (toolkit === "slack") return {
+		enterpriseId: text(row, ["enterprise_id", "enterpriseId"]),
+		workspaceId: text(row, ["team_id", "teamId"]),
+		workspace: text(row, [
+			"team",
+			"team_name",
+			"workspace"
+		]),
+		userId: text(row, ["user_id", "userId"]),
+		username: text(row, [
+			"user",
+			"username",
+			"user_name"
+		]),
+		botUserId: text(row, [
+			"bot_id",
+			"botId",
+			"bot_user_id"
+		])
+	};
 	throw new Error(`Identity normalization is not defined for ${toolkit}.`);
 }
+function connectorIdentityKey(toolkit, identity) {
+	const normalizedToolkit = toolkit.trim().toLowerCase();
+	if (normalizedToolkit === "slack") {
+		const workspaceId = text(identity, [
+			"workspaceId",
+			"teamId",
+			"team_id"
+		]);
+		const subjectId = text(identity, [
+			"userId",
+			"user_id",
+			"botUserId",
+			"bot_user_id"
+		]);
+		if (!workspaceId || !subjectId) return void 0;
+		return `slack:${text(identity, ["enterpriseId", "enterprise_id"]) ?? "-"}:${workspaceId}:${subjectId}`;
+	}
+	if (normalizedToolkit === "gmail") {
+		const email = text(identity, ["email"]);
+		return email ? `gmail:${email.toLowerCase()}` : void 0;
+	}
+	if (normalizedToolkit === "github") {
+		const username = text(identity, ["username"]);
+		return username ? `github:${username.toLowerCase()}` : void 0;
+	}
+}
+function mergeConnectorIdentity(toolkit, current, incoming) {
+	const normalizedToolkit = toolkit.trim().toLowerCase();
+	if (![
+		"gmail",
+		"github",
+		"slack"
+	].includes(normalizedToolkit)) return {
+		...current,
+		...incoming
+	};
+	const normalized = Object.fromEntries(Object.entries(normalizeConnectorIdentity(normalizedToolkit, incoming)).filter(([, value]) => value !== void 0 && value !== null && value !== ""));
+	return {
+		...current,
+		...incoming,
+		...normalized
+	};
+}
 //#endregion
-export { normalizeConnectorIdentity };
+export { connectorIdentityKey, mergeConnectorIdentity, normalizeConnectorIdentity };

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

@@ -3,15 +3,16 @@ import { init_logger } from "../utils/logger.js";
 import { claimNextConnectorLearningJob, enqueueConnectorLearningJob, listConnectorLearningJobs, recoverStaleConnectorLearningJobs, setConnectorLearningPaused, updateConnectorLearningJob } from "../storage/sqlite/connector-learning-repository.js";
 import { pruneBoundedKnowledgeSourceItems } from "../storage/sqlite/knowledge-repository.js";
 import { getConnectorInstallation, listConnectorConnections, upsertConnectorConnection } from "../storage/sqlite/connector-repository.js";
-import { getConnectorSyncPolicy } from "../storage/sqlite/connector-sync-policy-repository.js";
+import { getConnectorAccount, reconcileConnectorAccount } from "../storage/sqlite/connector-account-repository.js";
+import { getConnectorSyncPolicyForConnection } from "../storage/sqlite/connector-sync-policy-repository.js";
 import "../storage/sqlite/index.js";
+import { connectorIdentityKey, normalizeConnectorIdentity } from "./connector-identity.js";
 import { ComposioSessionsAdapter } from "./composio-sessions.js";
+import { buildConnectorLearningArguments, getConnectorLearningPlan } from "./learning-recipes.js";
 import { getConnectorDefinition } from "./catalog.js";
 import { ConnectedUnderstandingPipeline } from "../knowledge/connected-understanding-pipeline.js";
 import "../knowledge/index.js";
 import { ingestComposioConnectedSource } from "./connected-source-ingestion.js";
-import { normalizeConnectorIdentity } from "./connector-identity.js";
-import { buildConnectorLearningArguments, getConnectorLearningPlan } from "./learning-recipes.js";
 //#region src/connectors/learning-coordinator.ts
 init_logger();
 const log = createLogger("ConnectorLearning");
@@ -31,29 +32,32 @@ function startConnectorLearningCoordinator(options) {
 	let stopped = false;
 	const composioAdapter = options.composioAdapter ?? new ComposioSessionsAdapter();
 	const publish = (job) => options.emit?.("connector.learning.updated", job);
+	const activeAccountConnections = () => listConnectorConnections().filter((connection) => connection.status === "active" && connection.accountId).filter((connection) => getConnectorAccount(connection.accountId)?.currentConnectionId === connection.id);
 	function enqueueConnection(connectionId, request = {}) {
 		if (!learningEnabled(options.getConfig())) return null;
 		const connection = listConnectorConnections().find((item) => item.id === connectionId && item.status === "active");
 		if (!connection) return null;
-		const syncPolicy = getConnectorSyncPolicy(connection.id);
+		if (!connection.accountId) throw new Error(`Connector account is missing for connection ${connection.id}.`);
+		const syncPolicy = getConnectorSyncPolicyForConnection(connection.id);
 		if (request.reason !== "manual" && syncPolicy?.scanEnabled === false) return null;
 		const definition = getConnectorDefinition(connection.connectorId);
 		if (definition?.runtime.type !== "composio" || definition.runtime.role !== "toolkit") return null;
 		if (!getConnectorLearningPlan(definition.runtime.toolkit)) return null;
-		const sourceInstanceId = `composio:${connection.connectorId}:${connection.id}`;
+		const sourceInstanceId = `composio:${connection.connectorId}:${connection.accountId}`;
 		const existing = listConnectorLearningJobs({
-			connectionId: connection.id,
+			accountId: connection.accountId,
 			limit: 1
 		});
 		const mode = request.mode ?? (existing.length === 0 ? "bootstrap" : "incremental");
 		const bucket = Math.floor(Date.now() / 6e4);
 		const job = enqueueConnectorLearningJob({
 			connectorId: connection.connectorId,
+			accountId: connection.accountId,
 			connectionId: connection.id,
 			sourceInstanceId,
 			agentId: options.resolveAgentId(),
 			mode,
-			idempotencyKey: request.idempotencyKey ?? (mode === "bootstrap" ? `bootstrap:${connection.id}:v1` : `incremental:${connection.id}:${request.reason ?? "manual"}:${bucket}`),
+			idempotencyKey: request.idempotencyKey ?? (mode === "bootstrap" ? `bootstrap:${connection.accountId}:v1` : `incremental:${connection.accountId}:${request.reason ?? "manual"}:${bucket}`),
 			nextRunAt: request.nextRunAt
 		});
 		publish(job);
@@ -62,7 +66,7 @@ function startConnectorLearningCoordinator(options) {
 	}
 	function enqueueToolkit(toolkit) {
 		const normalized = toolkit.trim().toLowerCase();
-		return listConnectorConnections().filter((connection) => connection.status === "active").filter((connection) => {
+		return activeAccountConnections().filter((connection) => {
 			const definition = getConnectorDefinition(connection.connectorId);
 			return definition?.runtime.type === "composio" && definition.runtime.role === "toolkit" && definition.runtime.toolkit === normalized;
 		}).map((connection) => enqueueConnection(connection.id, { reason: "event" })).filter((job) => Boolean(job));
@@ -107,6 +111,19 @@ function startConnectorLearningCoordinator(options) {
 				...connection,
 				identity: normalizeConnectorIdentity(plan.toolkit, execution.result)
 			});
+			const identityKey = connectorIdentityKey(plan.toolkit, connection.identity);
+			if (identityKey) {
+				const account = reconcileConnectorAccount({
+					connectionId: connection.id,
+					identityKey,
+					identity: connection.identity
+				});
+				connection = listConnectorConnections().find((candidate) => candidate.id === connection.id);
+				job = updateConnectorLearningJob(job.id, {
+					accountId: account.id,
+					sourceInstanceId: `composio:${connection.connectorId}:${account.id}`
+				});
+			}
 		}
 		let itemsSeen = 0;
 		let itemsIndexed = 0;
@@ -126,7 +143,7 @@ function startConnectorLearningCoordinator(options) {
 			itemsIndexed += synced.itemsIndexed;
 		}
 		if (listConnectorLearningJobs({
-			connectionId: job.connectionId,
+			accountId: job.accountId,
 			limit: 100
 		}).find((candidate) => candidate.id === job.id)?.status === "paused") return;
 		publish(updateConnectorLearningJob(job.id, {
@@ -144,15 +161,15 @@ function startConnectorLearningCoordinator(options) {
 			finished: true
 		}));
 		pruneBoundedKnowledgeSourceItems(job.sourceInstanceId, Date.now() - plan.bootstrapWindowDays * 24 * 60 * 6e4);
-		const syncPolicy = getConnectorSyncPolicy(job.connectionId);
+		const syncPolicy = getConnectorSyncPolicyForConnection(job.connectionId);
 		if (syncPolicy?.scanEnabled === false) return;
 		const intervalMinutes = syncPolicy?.intervalMinutes ?? plan.intervalMinutes;
 		const nextRunAt = Date.now() + intervalMinutes * 6e4;
-		enqueueConnection(job.connectionId, {
+		enqueueConnection(getConnectorAccount(job.accountId)?.currentConnectionId ?? job.connectionId, {
 			mode: "incremental",
 			reason: "schedule",
 			nextRunAt,
-			idempotencyKey: `scheduled:${job.connectionId}:${nextRunAt}`
+			idempotencyKey: `scheduled:${job.accountId}:${nextRunAt}`
 		});
 	}
 	async function runNow() {
@@ -186,8 +203,8 @@ function startConnectorLearningCoordinator(options) {
 	}
 	recoverStaleConnectorLearningJobs(Date.now());
 	if (learningEnabled(options.getConfig())) {
-		for (const connection of listConnectorConnections().filter((item) => item.status === "active")) if (listConnectorLearningJobs({
-			connectionId: connection.id,
+		for (const connection of activeAccountConnections()) if (listConnectorLearningJobs({
+			accountId: connection.accountId,
 			limit: 1
 		}).length === 0) enqueueConnection(connection.id, { reason: "schedule" });
 	}
@@ -201,7 +218,9 @@ function startConnectorLearningCoordinator(options) {
 		enqueueConnection,
 		enqueueToolkit,
 		setPaused(connectionId, paused) {
-			const changed = setConnectorLearningPaused(connectionId, paused);
+			const accountId = listConnectorConnections().find((connection) => connection.id === connectionId)?.accountId;
+			if (!accountId) return 0;
+			const changed = setConnectorLearningPaused(accountId, paused);
 			if (!paused && changed > 0) queueMicrotask(() => void runNow());
 			return changed;
 		},

package/dist/src/connectors/learning-recipes.d.ts

@@ -1,3 +1,4 @@
+import type { ConnectorDefinition } from './types.js';
 export type ConnectorIdentityProbe = {
     actionId: string;
 };
@@ -19,4 +20,5 @@ export declare function buildConnectorLearningArguments(plan: ConnectorLearningP
     windowStart?: string;
 }, identity: Record<string, unknown>): Record<string, unknown>;
 export declare function getConnectorLearningPlan(toolkit: string): ConnectorLearningPlan | undefined;
+export declare function connectorUnderstandingCapability(toolkit: string): ConnectorDefinition['understanding'] | undefined;
 export declare function listConnectorLearningPlans(): ConnectorLearningPlan[];

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

@@ -73,6 +73,7 @@ const PLANS = {
 	},
 	slack: {
 		toolkit: "slack",
+		identityProbe: { actionId: "SLACK_TEST_AUTH" },
 		streams: [{
 			scope: "channels",
 			actionId: "SLACK_LIST_CHANNELS",
@@ -114,8 +115,17 @@ const PLANS = {
 function getConnectorLearningPlan(toolkit) {
 	return PLANS[toolkit.trim().toLowerCase()];
 }
+function connectorUnderstandingCapability(toolkit) {
+	const plan = getConnectorLearningPlan(toolkit);
+	if (!plan) return void 0;
+	return {
+		mode: plan.streams.some((stream) => stream.kind === "activity") ? "activity" : "inventory",
+		bootstrapWindowDays: plan.bootstrapWindowDays,
+		readOnly: true
+	};
+}
 function listConnectorLearningPlans() {
 	return Object.values(PLANS);
 }
 //#endregion
-export { buildConnectorLearningArguments, getConnectorLearningPlan, listConnectorLearningPlans };
+export { buildConnectorLearningArguments, connectorUnderstandingCapability, getConnectorLearningPlan, listConnectorLearningPlans };

package/dist/src/connectors/source-change-publisher.js

@@ -2,7 +2,8 @@ import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { getKnowledgeConsumerWatermark, getKnowledgeSourceItem, listKnowledgeSourceChanges, setKnowledgeConsumerWatermark } from "../storage/sqlite/knowledge-repository.js";
 import { listConnectorConnections } from "../storage/sqlite/connector-repository.js";
-import { getConnectorSyncPolicy } from "../storage/sqlite/connector-sync-policy-repository.js";
+import { getConnectorAccount } from "../storage/sqlite/connector-account-repository.js";
+import { getConnectorSyncPolicyForConnection } from "../storage/sqlite/connector-sync-policy-repository.js";
 //#region src/connectors/source-change-publisher.ts
 init_logger();
 const log = createLogger("Connector:SourceChanges");
@@ -46,9 +47,9 @@ var ConnectedSourceChangePublisher = class {
 			sources: 0
 		};
 		try {
-			const connections = listConnectorConnections({ principalId: "local-owner" }).filter((connection) => connection.status === "active");
+			const connections = listConnectorConnections({ principalId: "local-owner" }).filter((connection) => connection.status === "active" && connection.accountId && getConnectorAccount(connection.accountId)?.currentConnectionId === connection.id);
 			for (const connection of connections) {
-				const sourceInstanceId = `composio:${connection.connectorId}:${connection.id}`;
+				const sourceInstanceId = `composio:${connection.connectorId}:${connection.accountId}`;
 				try {
 					const result = this.publishSource(sourceInstanceId, connection.id);
 					total.published += result.published;
@@ -69,7 +70,7 @@ var ConnectedSourceChangePublisher = class {
 		}
 	}
 	publishSource(sourceInstanceId, connectionId) {
-		const policy = getConnectorSyncPolicy(connectionId);
+		const policy = getConnectorSyncPolicyForConnection(connectionId);
 		let watermark = getKnowledgeConsumerWatermark(CONSUMER_ID, sourceInstanceId);
 		const changes = listKnowledgeSourceChanges({
 			sourceInstanceId,

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

@@ -90,6 +90,11 @@ export type ConnectorDefinition = {
     source: 'builtin' | 'extension' | 'custom' | 'registry' | 'store';
     capabilities: ConnectorCapability[];
     benefits?: ConnectorBenefit[];
+    understanding?: {
+        mode: 'activity' | 'inventory';
+        bootstrapWindowDays: number;
+        readOnly: true;
+    };
     tags?: string[];
     branding?: ConnectorBranding;
     verificationLevel?: ConnectorVerificationLevel;
@@ -121,6 +126,7 @@ export type ConnectorInstallationPolicy = {
 export type ConnectorConnectionStatus = 'pending' | 'active' | 'expired' | 'failed' | 'revoked' | 'disabled' | 'unknown';
 export type ConnectorConnection = {
     id: string;
+    accountId?: string;
     installationId?: string;
     connectorId: string;
     provider: string;
@@ -137,6 +143,16 @@ export type ConnectorConnection = {
     createdAt: string;
     updatedAt: string;
 };
+export type ConnectorAccount = {
+    id: string;
+    connectorId: string;
+    principalId: string;
+    identityKey?: string;
+    identity: Record<string, unknown>;
+    currentConnectionId?: string;
+    createdAt: string;
+    updatedAt: string;
+};
 export type ConnectorActionMetadata = {
     connectorId: string;
     actionId: string;

package/dist/src/daemon/launchd.js

@@ -232,7 +232,7 @@ const launchdService = {
 			serviceTarget
 		])).exitCode === 0) {
 			log.info("LaunchAgent restarted via kickstart");
-			return { outcome: "restarted" };
+			return { task: "restarted" };
 		}
 		const plistPath = resolveLaunchAgentPlistPath(args.env);
 		const domain = resolveGuiDomain();
@@ -246,7 +246,7 @@ const launchdService = {
 		]);
 		if (bootstrapResult.exitCode === 0 || bootstrapResult.exitCode === 37) {
 			log.info("LaunchAgent restarted via bootout+bootstrap");
-			return { outcome: "restarted" };
+			return { task: "restarted" };
 		}
 		throw new Error(`Failed to restart LaunchAgent: ${bootstrapResult.stderr.trim() || "unknown error"}`);
 	},

package/dist/src/daemon/schtasks.js

@@ -331,7 +331,7 @@ const schtasksService = {
 			taskName
 		]);
 		log.info("Scheduled task restarted");
-		return { outcome: "restarted" };
+		return { task: "restarted" };
 	},
 	async isLoaded(args) {
 		return (await schtasks([

package/dist/src/daemon/service.js

@@ -61,19 +61,19 @@ async function startGatewayService(params) {
 	const serviceEnv = env || process.env;
 	const initialState = await gatherServiceState(service, serviceEnv);
 	if (!initialState.installed) return {
-		outcome: "missing-install",
+		task: "missing-install",
 		state: initialState
 	};
 	const issues = detectStartRepairIssues(initialState.command);
 	if (issues.length > 0) return {
-		outcome: "repair-required",
+		task: "repair-required",
 		state: initialState,
 		issues
 	};
 	const restartResult = await service.restart({ env: serviceEnv });
 	const state = await gatherServiceState(service, serviceEnv);
 	return {
-		outcome: restartResult.outcome === "restarted" ? "started" : "scheduled",
+		task: restartResult.task === "restarted" ? "started" : "scheduled",
 		state
 	};
 }

package/dist/src/daemon/systemd.js

@@ -210,7 +210,7 @@ const systemdService = {
 	async restart(args) {
 		await systemctlExec(["restart", resolveServiceName(args.env)]);
 		log.info("Systemd service restarted");
-		return { outcome: "restarted" };
+		return { task: "restarted" };
 	},
 	async isLoaded(args) {
 		return (await systemctl(["is-enabled", resolveServiceName(args.env)])).exitCode === 0;

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

@@ -41,18 +41,18 @@ export interface GatewayServiceState {
     command: GatewayServiceCommandConfig | null;
     runtime?: GatewayServiceRuntime;
 }
-export type GatewayServiceRestartOutcome = 'restarted' | 'scheduled';
+export type GatewayServiceRestartTask = 'restarted' | 'scheduled';
 export interface GatewayServiceRestartResult {
-    outcome: GatewayServiceRestartOutcome;
+    task: GatewayServiceRestartTask;
 }
 export type StartRepairIssueCode = 'version-mismatch' | 'temporary-program' | 'missing-program';
 export interface GatewayServiceStartRepairIssue {
     code: StartRepairIssueCode;
     message: string;
 }
-export type GatewayServiceStartOutcome = 'started' | 'scheduled' | 'missing-install' | 'repair-required';
+export type GatewayServiceStartTask = 'started' | 'scheduled' | 'missing-install' | 'repair-required';
 export interface GatewayServiceStartResult {
-    outcome: GatewayServiceStartOutcome;
+    task: GatewayServiceStartTask;
     state: GatewayServiceState;
     issues?: GatewayServiceStartRepairIssue[];
 }
@@ -97,7 +97,7 @@ export interface GatewayService {
     uninstall: (args: GatewayServiceControlArgs) => Promise<void>;
     /** Stop service */
     stop: (args: GatewayServiceControlArgs) => Promise<void>;
-    /** Restart service (returns outcome for restart health checks) */
+    /** Restart service (returns task for restart health checks) */
     restart: (args: GatewayServiceControlArgs) => Promise<GatewayServiceRestartResult>;
     /** Check if service is loaded/installed */
     isLoaded: (args: GatewayServiceEnvArgs) => Promise<boolean>;

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

@@ -1,13 +1,13 @@
 import { z } from 'zod';
 import type { Config } from '../config/schema.js';
-import type { DiscussionAnalysis } from './types.js';
+import type { DiscussionOrganization } 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>;
+    projectCandidateId: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
+    projectConfidence: z.ZodPreprocess<z.ZodOptional<z.ZodNumber>>;
+    projectAlternativeConfidence: z.ZodPreprocess<z.ZodOptional<z.ZodNumber>>;
 }, z.core.$strip>;
-export declare function normalizeDiscussionAnalysis(value: unknown): DiscussionAnalysis;
+export declare function normalizeDiscussionOrganization(value: unknown): DiscussionOrganization;
 export declare function analyzeDiscussion(input: {
     config: Config;
     transcript: string;
@@ -18,7 +18,7 @@ export declare function analyzeDiscussion(input: {
     }>;
     signal?: AbortSignal;
 }): Promise<{
-    analysis: DiscussionAnalysis;
+    organization: DiscussionOrganization;
     modelRef: string;
 }>;
 export declare function enrichLiveDiscussion(input: {

package/dist/src/discussions/analyzer.js

@@ -7,28 +7,30 @@ import { z } from "zod";
 init_schema();
 init_providers();
 const MAX_TRANSCRIPT_CHARS = 12e4;
-const AnalysisSchema = z.object({
+const optionalString = (maxLength) => z.preprocess((value) => value === null ? void 0 : value, z.string().trim().min(1).max(maxLength).optional());
+const optionalConfidence = z.preprocess((value) => value === null ? void 0 : value, z.number().min(0).max(1).optional());
+const OrganizationSchema = 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(),
+		id: optionalString(100),
 		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()
+		owner: optionalString(200),
+		dueDate: optionalString(100)
 	})).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()
+	projectCandidateId: optionalString(200),
+	projectConfidence: optionalConfidence,
+	projectAlternativeConfidence: optionalConfidence
 });
 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()
+	projectCandidateId: optionalString(200),
+	projectConfidence: optionalConfidence,
+	projectAlternativeConfidence: optionalConfidence
 });
 function extractText(content) {
 	if (typeof content === "string") return content;
@@ -46,39 +48,47 @@ function parseJsonObject(raw) {
 	} catch {
 		const start = stripped.indexOf("{");
 		const end = stripped.lastIndexOf("}");
-		if (start < 0 || end <= start) throw new Error("Discussion analysis did not return valid JSON");
+		if (start < 0 || end <= start) throw new Error("Discussion organizer 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"}`);
+function normalizeDiscussionOrganization(value) {
+	const parsed = OrganizationSchema.safeParse(value);
+	if (!parsed.success) {
+		const issue = parsed.error.issues[0];
+		const path = issue?.path.length ? `${issue.path.join(".")}: ` : "";
+		throw new Error(`Invalid discussion organization: ${path}${issue?.message ?? "schema mismatch"}`);
+	}
+	const { actionItems, projectCandidateId, projectConfidence, projectAlternativeConfidence, ...organization } = parsed.data;
 	return {
-		...parsed.data,
-		actionItems: parsed.data.actionItems.map((item, index) => ({
+		...organization,
+		actionItems: actionItems.map((item, index) => ({
 			id: item.id ?? actionId(item.title, index),
 			title: item.title,
 			...item.owner ? { owner: item.owner } : {},
 			...item.dueDate ? { dueDate: item.dueDate } : {}
-		}))
+		})),
+		...projectCandidateId ? { projectCandidateId } : {},
+		...projectConfidence !== void 0 ? { projectConfidence } : {},
+		...projectAlternativeConfidence !== void 0 ? { projectAlternativeConfidence } : {}
 	};
 }
 async function analyzeDiscussion(input) {
 	const modelRef = getAgentDefaultModelRef(input.config);
-	if (!modelRef) throw new Error("No default model configured for discussion analysis");
+	if (!modelRef) throw new Error("No default model configured for discussion organization");
 	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.",
+			"Organize 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.",
+			"actionItems contains title and optional owner and dueDate. Omit optional fields rather than returning null 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.`,
@@ -89,7 +99,7 @@ async function analyzeDiscussion(input) {
 	};
 	return {
 		modelRef,
-		analysis: normalizeDiscussionAnalysis(parseJsonObject(extractText((await completeWithResolvedCredentials(resolveModel(modelRef), { messages: [message] }, {
+		organization: normalizeDiscussionOrganization(parseJsonObject(extractText((await completeWithResolvedCredentials(resolveModel(modelRef), { messages: [message] }, {
 			maxTokens: 3e3,
 			temperature: .1,
 			signal: input.signal
@@ -124,4 +134,4 @@ async function enrichLiveDiscussion(input) {
 	};
 }
 //#endregion
-export { analyzeDiscussion, enrichLiveDiscussion, normalizeDiscussionAnalysis };
+export { analyzeDiscussion, enrichLiveDiscussion, normalizeDiscussionOrganization };

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

@@ -1,7 +1,8 @@
 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 { DiscussionOrganizer } from './organizer.js';
 export { DiscussionLiveWorker } from './live-worker.js';
-export { DiscussionWorker } from './worker.js';
+export { DiscussionOrganizerWorker } from './organizer-worker.js';
+export { DiscussionSealer } from './sealer.js';
 export { DISCUSSION_STATUSES } from './types.js';
 export type * from './types.js';

package/dist/src/discussions/index.js

@@ -1,7 +1,8 @@
 import { analyzeDiscussion } from "./analyzer.js";
+import { DISCUSSION_STATUSES } from "./types.js";
 import { DISCUSSION_AUDIO_MAX_BYTES, DISCUSSION_MAX_DURATION_MS, DiscussionService, DiscussionServiceError } from "./service.js";
-import { DiscussionPipeline, mergeDiscussionAnalysisIntoMarkdown } from "./pipeline.js";
+import { DiscussionOrganizer } from "./organizer.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 };
+import { DiscussionOrganizerWorker } from "./organizer-worker.js";
+import { DiscussionSealer } from "./sealer.js";
+export { DISCUSSION_AUDIO_MAX_BYTES, DISCUSSION_MAX_DURATION_MS, DISCUSSION_STATUSES, DiscussionLiveWorker, DiscussionOrganizer, DiscussionOrganizerWorker, DiscussionSealer, DiscussionService, DiscussionServiceError, analyzeDiscussion };