@xopcai/xopc 0.0.172 → 0.0.174

package/dist/src/proactive/calendar-signals.d.ts

@@ -1,4 +0,0 @@
-import type { KnowledgeSourceItem } from '../knowledge/types.js';
-import type { FocusCalendarSignal, FocusView } from './types.js';
-export declare function buildFocusCalendarSignals(items: KnowledgeSourceItem[], focuses: FocusView[], nowMs?: number): FocusCalendarSignal[];
-export declare function listFocusCalendarSignals(focuses: FocusView[], nowMs?: number): FocusCalendarSignal[];

package/dist/src/proactive/calendar-signals.js

@@ -1,120 +0,0 @@
-import { listKnowledgeSourceItems } from "../storage/sqlite/knowledge-repository.js";
-//#region src/proactive/calendar-signals.ts
-const LOOKAHEAD_MS = 7 * 864e5;
-const FIELD_LIMIT = 8;
-const TITLE_KEYS = new Set([
-	"summary",
-	"title",
-	"name",
-	"subject"
-]);
-const DESCRIPTION_KEYS = new Set([
-	"description",
-	"notes",
-	"body",
-	"agenda"
-]);
-const START_KEYS = new Set([
-	"start",
-	"starttime",
-	"start_time",
-	"startat",
-	"start_at",
-	"datetime"
-]);
-const END_KEYS = new Set([
-	"end",
-	"endtime",
-	"end_time",
-	"endat",
-	"end_at"
-]);
-const STOP_WORDS = new Set([
-	"about",
-	"after",
-	"before",
-	"from",
-	"have",
-	"meeting",
-	"project",
-	"review",
-	"the",
-	"this",
-	"with"
-]);
-function parsePayload(item) {
-	if (!item.normalizedText) return null;
-	try {
-		return JSON.parse(item.normalizedText);
-	} catch {
-		return null;
-	}
-}
-function findStrings(value, keys, depth = 0) {
-	if (depth > 6 || value == null) return [];
-	if (Array.isArray(value)) return value.flatMap((item) => findStrings(item, keys, depth + 1)).slice(0, FIELD_LIMIT);
-	if (typeof value !== "object") return [];
-	const record = value;
-	const direct = Object.entries(record).flatMap(([key, nested]) => {
-		if (!keys.has(key.toLowerCase().replaceAll("-", "_"))) return [];
-		if (typeof nested === "string") return [nested];
-		return findStrings(nested, new Set([
-			"datetime",
-			"date",
-			"value"
-		]), depth + 1);
-	});
-	if (direct.length > 0) return direct.slice(0, FIELD_LIMIT);
-	return Object.values(record).flatMap((nested) => findStrings(nested, keys, depth + 1)).slice(0, FIELD_LIMIT);
-}
-function firstDate(payload, keys) {
-	for (const value of findStrings(payload, keys)) {
-		const parsed = Date.parse(value);
-		if (Number.isFinite(parsed)) return parsed;
-	}
-}
-function terms(value) {
-	const normalized = value.toLocaleLowerCase();
-	const result = new Set(normalized.match(/[a-z0-9][a-z0-9_-]{2,}/g)?.filter((word) => !STOP_WORDS.has(word)) ?? []);
-	for (const sequence of normalized.match(/[\p{Script=Han}]{2,}/gu) ?? []) for (let index = 0; index < sequence.length - 1; index += 1) result.add(sequence.slice(index, index + 2));
-	return result;
-}
-function relatedFocus(focuses, text) {
-	const eventTerms = terms(text);
-	if (eventTerms.size === 0) return void 0;
-	return focuses.map((focus) => ({
-		focus,
-		score: [...terms(`${focus.title} ${focus.summary}`)].filter((term) => eventTerms.has(term)).length
-	})).filter((candidate) => candidate.score >= 2).toSorted((left, right) => right.score - left.score || right.focus.focusScore - left.focus.focusScore)[0]?.focus;
-}
-function buildFocusCalendarSignals(items, focuses, nowMs = Date.now()) {
-	const end = nowMs + LOOKAHEAD_MS;
-	const signals = items.flatMap((item) => {
-		if (item.itemType !== "calendar_event") return [];
-		const payload = parsePayload(item);
-		const title = findStrings(payload, TITLE_KEYS)[0]?.trim();
-		const startsAt = firstDate(payload, START_KEYS);
-		if (!title || startsAt == null || startsAt < nowMs || startsAt > end) return [];
-		const focus = relatedFocus(focuses, `${title} ${findStrings(payload, DESCRIPTION_KEYS).join(" ")}`);
-		if (!focus) return [];
-		const endsAt = firstDate(payload, END_KEYS);
-		return [{
-			id: item.id,
-			focusId: focus.id,
-			focusTitle: focus.title,
-			title,
-			startsAt,
-			...endsAt != null ? { endsAt } : {},
-			sourceInstanceId: item.sourceInstanceId
-		}];
-	}).toSorted((left, right) => left.startsAt - right.startsAt);
-	return signals.filter((signal, index) => signals.findIndex((candidate) => candidate.focusId === signal.focusId && candidate.startsAt === signal.startsAt && candidate.title.toLocaleLowerCase() === signal.title.toLocaleLowerCase()) === index).slice(0, 20);
-}
-function listFocusCalendarSignals(focuses, nowMs = Date.now()) {
-	return buildFocusCalendarSignals(listKnowledgeSourceItems({
-		itemType: "calendar_event",
-		limit: 500
-	}), focuses, nowMs);
-}
-//#endregion
-export { buildFocusCalendarSignals, listFocusCalendarSignals };

package/dist/src/proactive/focus-service.d.ts

@@ -1,62 +0,0 @@
-import type { Automation, AutomationRun } from '../automations/index.js';
-import type { FocusView, FocusWatch, FocusWatchKind } from './types.js';
-interface AutomationPort {
-    create(input: {
-        name: string;
-        description: string;
-        projectId?: string;
-        trigger: {
-            kind: 'schedule';
-            schedule: {
-                kind: 'interval';
-                everyMs: number;
-            };
-        };
-        action: {
-            kind: 'agent';
-            instruction: string;
-            timeoutSeconds: number;
-        };
-        safety: {
-            mode: 'suggest_only';
-        };
-        afterRun: {
-            kind: 'none';
-        };
-        reliability: {
-            timeoutSeconds: number;
-            disableAfterConsecutiveFailures: number;
-        };
-    }): Promise<Automation>;
-    pause(id: string): Promise<Automation | null>;
-    resume(id: string): Promise<Automation | null>;
-    update(id: string, patch: {
-        action: {
-            kind: 'agent';
-            instruction: string;
-            timeoutSeconds: number;
-        };
-    }): Promise<Automation | null>;
-    runNow(id: string): Promise<AutomationRun>;
-}
-export declare class FocusService {
-    private readonly automations;
-    private readonly goals;
-    constructor(automations: AutomationPort);
-    list(options?: {
-        includeUnreviewed?: boolean;
-    }): FocusView[];
-    confirm(id: string): FocusView | null;
-    activateTrial(input: {
-        threadId: string;
-        kind?: FocusWatchKind;
-        eventContext?: string;
-    }): Promise<{
-        focus: FocusView;
-        watch: FocusWatch;
-    }>;
-    pauseWatch(id: string): Promise<FocusWatch | null>;
-    reconcileExpiredTrials(nowMs?: number): Promise<number>;
-    recordInsightFeedback(watchId: string, useful: boolean): Promise<FocusWatch | null>;
-}
-export {};

package/dist/src/proactive/focus-service.js

@@ -1,173 +0,0 @@
-import { createLogger } from "../utils/logger/index.js";
-import { init_logger } from "../utils/logger.js";
-import { GoalService } from "../goals/goal-service.js";
-import "../goals/index.js";
-import { addWorkUnderstandingThreadFeedback, getWorkUnderstandingThread, listWorkUnderstandingThreads } from "../work-discovery/thread-repository.js";
-import { createFocusWatch, getFocusWatchByThreadAndKind, listFocusWatches, recordFocusWatchFeedback, restartFocusWatchTrial, setFocusWatchStatus } from "./watch-repository.js";
-//#region src/proactive/focus-service.ts
-init_logger();
-const TRIAL_DURATION_MS = 7 * 864e5;
-const DAILY_INTERVAL_MS = 1440 * 60 * 1e3;
-const log = createLogger("FocusService");
-function instructionForFocus(title, summary, kind, eventContext) {
-	const intent = kind === "progress" ? "Look for meaningful progress, blockers, and the most useful next step." : kind === "staleness" ? "Check whether this focus has stalled and identify the smallest credible unblock." : kind === "deadline" ? "Check upcoming deadlines or meetings and prepare only the material that is needed next." : "Search for external changes published since the previous daily check. Use primary sources when possible, include the publication date and canonical URL, reject generic background news, and explain the concrete impact on this focus.";
-	return [
-		"Maintain this user-confirmed focus in suggest-only mode.",
-		`Focus: ${title}`,
-		`Context: ${summary}`,
-		...eventContext ? [`Upcoming event selected by the user: ${eventContext}`] : [],
-		intent,
-		"Inspect only evidence that changed since the previous daily check; use timestamps, history, status, or source revisions to establish the delta.",
-		"Use evidence available to the agent. Do not modify files, send messages, publish content, or claim progress without evidence.",
-		"Return JSON only, with no markdown.",
-		"If nothing materially changed: {\"meaningful\":false}.",
-		"Otherwise return {\"meaningful\":true,\"title\":\"short title\",\"summary\":\"what changed\",\"whyItMatters\":\"concrete impact\",\"nextAction\":\"one next action\",\"evidence\":[{\"label\":\"specific observed evidence\",\"source\":\"file, event, or canonical URL\",\"publishedAt\":\"ISO date when this is external news\"}]}.",
-		"A meaningful result requires at least one specific evidence item. Never invent evidence. Keep the entire JSON response under 2,000 characters."
-	].join("\n");
-}
-var FocusService = class {
-	goals = new GoalService();
-	constructor(automations) {
-		this.automations = automations;
-	}
-	list(options = {}) {
-		const threads = listWorkUnderstandingThreads({ limit: 200 }).filter((thread) => options.includeUnreviewed || thread.userStatus === "confirmed" || thread.userStatus === "corrected");
-		const watches = listFocusWatches();
-		const goals = this.goals.list({
-			status: [
-				"active",
-				"blocked",
-				"needs_input",
-				"paused"
-			],
-			limit: 200
-		});
-		return threads.map((thread) => {
-			const goal = goals.find((candidate) => candidate.projectId && thread.projectIds.includes(candidate.projectId));
-			return {
-				id: thread.id,
-				title: thread.title,
-				summary: thread.summary,
-				status: thread.status,
-				horizon: thread.horizon,
-				confidence: thread.confidence,
-				focusScore: thread.focusScore,
-				userStatus: thread.userStatus,
-				projectIds: thread.projectIds,
-				...goal ? {
-					goalId: goal.id,
-					nextAction: goal.nextAction,
-					blockedReason: goal.blockedReason
-				} : {},
-				watches: watches.filter((watch) => watch.threadId === thread.id),
-				lastObservedAt: thread.lastObservedAt
-			};
-		});
-	}
-	confirm(id) {
-		const thread = addWorkUnderstandingThreadFeedback({
-			threadId: id,
-			decision: "confirmed"
-		});
-		return thread ? this.list({ includeUnreviewed: true }).find((focus) => focus.id === thread.id) ?? null : null;
-	}
-	async activateTrial(input) {
-		const kind = input.kind ?? "progress";
-		let thread = getWorkUnderstandingThread(input.threadId);
-		if (!thread || thread.userStatus === "rejected") throw new Error("Focus not found");
-		if (thread.userStatus === "unreviewed") thread = addWorkUnderstandingThreadFeedback({
-			threadId: thread.id,
-			decision: "confirmed"
-		});
-		if (!thread) throw new Error("Focus not found");
-		const existing = getFocusWatchByThreadAndKind(thread.id, kind);
-		if (existing) {
-			if (input.eventContext) await this.automations.update(existing.automationId, { action: {
-				kind: "agent",
-				instruction: instructionForFocus(thread.title, thread.summary, kind, input.eventContext),
-				timeoutSeconds: 300
-			} });
-			if (existing.status === "paused") {
-				await this.automations.resume(existing.automationId);
-				restartFocusWatchTrial(existing.id, Date.now() + TRIAL_DURATION_MS);
-			}
-			if (input.eventContext) this.automations.runNow(existing.automationId).catch((err) => {
-				log.warn({
-					err,
-					automationId: existing.automationId,
-					watchId: existing.id
-				}, "Focus event preparation run failed");
-			});
-			return {
-				focus: this.list({ includeUnreviewed: true }).find((item) => item.id === thread.id),
-				watch: getFocusWatchByThreadAndKind(thread.id, kind)
-			};
-		}
-		const automation = await this.automations.create({
-			name: `Keep moving: ${thread.title}`.slice(0, 200),
-			description: `Seven-day ${kind} watch for a user-confirmed focus.`,
-			...thread.projectIds[0] ? { projectId: thread.projectIds[0] } : {},
-			trigger: {
-				kind: "schedule",
-				schedule: {
-					kind: "interval",
-					everyMs: DAILY_INTERVAL_MS
-				}
-			},
-			action: {
-				kind: "agent",
-				instruction: instructionForFocus(thread.title, thread.summary, kind, input.eventContext),
-				timeoutSeconds: 300
-			},
-			safety: { mode: "suggest_only" },
-			afterRun: { kind: "none" },
-			reliability: {
-				timeoutSeconds: 300,
-				disableAfterConsecutiveFailures: 3
-			}
-		});
-		const watch = createFocusWatch({
-			threadId: thread.id,
-			automationId: automation.id,
-			kind,
-			config: {
-				cadence: "daily",
-				notifyOnlyWhenMeaningful: true
-			},
-			trialEndsAt: Date.now() + TRIAL_DURATION_MS
-		});
-		this.automations.runNow(automation.id).catch((err) => {
-			log.warn({
-				err,
-				automationId: automation.id,
-				watchId: watch.id
-			}, "Initial focus watch run failed");
-		});
-		return {
-			focus: this.list({ includeUnreviewed: true }).find((item) => item.id === thread.id),
-			watch
-		};
-	}
-	async pauseWatch(id) {
-		const watch = listFocusWatches().find((item) => item.id === id);
-		if (!watch) return null;
-		await this.automations.pause(watch.automationId);
-		return setFocusWatchStatus(id, "paused");
-	}
-	async reconcileExpiredTrials(nowMs = Date.now()) {
-		const expired = listFocusWatches({ status: "active" }).filter((watch) => watch.trialEndsAt != null && watch.trialEndsAt <= nowMs);
-		for (const watch of expired) {
-			await this.automations.pause(watch.automationId);
-			setFocusWatchStatus(watch.id, "paused", nowMs);
-		}
-		return expired.length;
-	}
-	async recordInsightFeedback(watchId, useful) {
-		const result = recordFocusWatchFeedback(watchId, useful);
-		if (!result) return null;
-		if (!useful && result.consecutiveDismissed >= 3) return this.pauseWatch(watchId);
-		return result.watch;
-	}
-};
-//#endregion
-export { FocusService };

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

@@ -1,7 +0,0 @@
-export * from './types.js';
-export * from './calendar-signals.js';
-export * from './focus-service.js';
-export * from './insight-repository.js';
-export * from './run-processor.js';
-export * from './trial-expiry-reconciler.js';
-export * from './watch-repository.js';

package/dist/src/proactive/index.js

@@ -1,7 +0,0 @@
-import { buildFocusCalendarSignals, listFocusCalendarSignals } from "./calendar-signals.js";
-import { createFocusWatch, getFocusWatchByAutomationId, getFocusWatchByThreadAndKind, listFocusWatches, recordFocusWatchFeedback, recordFocusWatchRun, restartFocusWatchTrial, setFocusWatchStatus } from "./watch-repository.js";
-import { FocusService } from "./focus-service.js";
-import { claimProactiveInsightApproval, createProactiveInsight, getProactiveInsight, listProactiveInsights, setProactiveInsightStatus } from "./insight-repository.js";
-import { hasValidIntelligenceEvidence, parseFocusRunResult, processFocusAutomationRun } from "./run-processor.js";
-import { startTrialExpiryReconciler } from "./trial-expiry-reconciler.js";
-export { FocusService, buildFocusCalendarSignals, claimProactiveInsightApproval, createFocusWatch, createProactiveInsight, getFocusWatchByAutomationId, getFocusWatchByThreadAndKind, getProactiveInsight, hasValidIntelligenceEvidence, listFocusCalendarSignals, listFocusWatches, listProactiveInsights, parseFocusRunResult, processFocusAutomationRun, recordFocusWatchFeedback, recordFocusWatchRun, restartFocusWatchTrial, setFocusWatchStatus, setProactiveInsightStatus, startTrialExpiryReconciler };

package/dist/src/proactive/insight-repository.d.ts

@@ -1,21 +0,0 @@
-import type { FocusWatchKind, ProactiveEvidence, ProactiveInsight, ProactiveInsightStatus } from './types.js';
-export declare function getProactiveInsight(id: string): ProactiveInsight | null;
-export declare function listProactiveInsights(options?: {
-    status?: ProactiveInsightStatus[];
-    limit?: number;
-}): ProactiveInsight[];
-export declare function createProactiveInsight(input: {
-    watchId: string;
-    runId: string;
-    kind: FocusWatchKind;
-    title: string;
-    summary: string;
-    whyItMatters: string;
-    nextAction: string;
-    evidence: ProactiveEvidence[];
-    valueScore: number;
-    valueReasons: string[];
-    nowMs?: number;
-}): ProactiveInsight | null;
-export declare function setProactiveInsightStatus(id: string, status: ProactiveInsightStatus, nowMs?: number, expectedStatus?: ProactiveInsightStatus): ProactiveInsight | null;
-export declare function claimProactiveInsightApproval(id: string, nowMs?: number): ProactiveInsight | null;

package/dist/src/proactive/insight-repository.js

@@ -1,109 +0,0 @@
-import { requireXopcDatabase } from "../storage/sqlite/connection.js";
-import { runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
-import { createHash, randomUUID } from "node:crypto";
-//#region src/proactive/insight-repository.ts
-function insightFromRow(row) {
-	return {
-		id: row.insight_id,
-		watchId: row.watch_id,
-		runId: row.run_id,
-		kind: row.kind,
-		title: row.title,
-		summary: row.summary,
-		whyItMatters: row.why_it_matters,
-		nextAction: row.next_action,
-		evidence: JSON.parse(row.evidence_json),
-		status: row.status,
-		valueScore: row.value_score,
-		valueReasons: JSON.parse(row.value_reasons_json),
-		createdAt: row.created_at,
-		updatedAt: row.updated_at
-	};
-}
-function getProactiveInsight(id) {
-	const { db } = requireXopcDatabase();
-	const row = db.prepare("SELECT * FROM proactive_insights WHERE insight_id = ?").get(id);
-	return row ? insightFromRow(row) : null;
-}
-function listProactiveInsights(options = {}) {
-	const statuses = options.status ?? ["unread", "read"];
-	if (statuses.length === 0) return [];
-	const limit = Math.max(1, Math.min(100, options.limit ?? 20));
-	const { db } = requireXopcDatabase();
-	return db.prepare(`SELECT * FROM proactive_insights
-     WHERE status IN (${statuses.map(() => "?").join(", ")})
-     ORDER BY created_at DESC LIMIT ?`).all(...statuses, limit).map(insightFromRow);
-}
-function createProactiveInsight(input) {
-	const id = randomUUID();
-	const now = input.nowMs ?? Date.now();
-	const intelligenceUpdates = input.evidence.map((item) => [
-		canonicalSource(item.source),
-		canonicalPublishedAt(item.publishedAt),
-		normalizeIdentityText(item.label)
-	]).filter(([source]) => Boolean(source)).toSorted((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right)));
-	const fingerprint = input.kind === "intelligence" && intelligenceUpdates.length > 0 ? JSON.stringify({
-		kind: input.kind,
-		updates: intelligenceUpdates
-	}) : JSON.stringify({
-		kind: input.kind,
-		title: input.title.toLocaleLowerCase().trim(),
-		summary: input.summary.toLocaleLowerCase().trim(),
-		evidence: input.evidence.map((item) => [
-			item.label.toLocaleLowerCase().trim(),
-			canonicalSource(item.source),
-			item.publishedAt ?? ""
-		])
-	});
-	const contentHash = createHash("sha256").update(fingerprint).digest("hex");
-	let created = false;
-	runSqliteWriteTransaction((db) => {
-		created = db.prepare(`INSERT OR IGNORE INTO proactive_insights (
-        insight_id, watch_id, run_id, kind, title, summary, why_it_matters,
-        next_action, evidence_json, content_hash, status, value_score,
-        value_reasons_json, created_at, updated_at
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'unread', ?, ?, ?, ?)`).run(id, input.watchId, input.runId, input.kind, input.title, input.summary, input.whyItMatters, input.nextAction, JSON.stringify(input.evidence), contentHash, input.valueScore, JSON.stringify(input.valueReasons), now, now).changes > 0;
-	});
-	return created ? listProactiveInsights({ limit: 100 }).find((item) => item.id === id) ?? null : null;
-}
-function canonicalPublishedAt(value) {
-	if (!value) return "";
-	const timestamp = Date.parse(value);
-	return Number.isFinite(timestamp) ? new Date(timestamp).toISOString() : value.trim();
-}
-function normalizeIdentityText(value) {
-	return value.trim().toLocaleLowerCase().replace(/\s+/g, " ");
-}
-function canonicalSource(source) {
-	const value = source?.trim();
-	if (!value) return "";
-	try {
-		const url = new URL(value);
-		url.hash = "";
-		for (const key of [...url.searchParams.keys()]) if (key.toLowerCase().startsWith("utm_") || key === "ref" || key === "source") url.searchParams.delete(key);
-		url.pathname = url.pathname.replace(/\/$/, "");
-		return url.toString().toLocaleLowerCase();
-	} catch {
-		return value.toLocaleLowerCase();
-	}
-}
-function setProactiveInsightStatus(id, status, nowMs = Date.now(), expectedStatus) {
-	let changed = false;
-	runSqliteWriteTransaction((db) => {
-		changed = db.prepare(`UPDATE proactive_insights SET status = ?, updated_at = ? WHERE insight_id = ?
-       ${expectedStatus ? "AND status = ?" : ""}`).run(status, nowMs, id, ...expectedStatus ? [expectedStatus] : []).changes > 0;
-	});
-	if (!changed) return null;
-	const { db } = requireXopcDatabase();
-	return insightFromRow(db.prepare("SELECT * FROM proactive_insights WHERE insight_id = ?").get(id));
-}
-function claimProactiveInsightApproval(id, nowMs = Date.now()) {
-	let claimed = false;
-	runSqliteWriteTransaction((db) => {
-		claimed = db.prepare(`UPDATE proactive_insights SET status = 'approved', updated_at = ?
-       WHERE insight_id = ? AND status = 'unread'`).run(nowMs, id).changes > 0;
-	});
-	return claimed ? getProactiveInsight(id) : null;
-}
-//#endregion
-export { claimProactiveInsightApproval, createProactiveInsight, getProactiveInsight, listProactiveInsights, setProactiveInsightStatus };

package/dist/src/proactive/run-processor.d.ts

@@ -1,19 +0,0 @@
-import type { AutomationRun } from '../automations/index.js';
-import type { ProactiveEvidence, ProactiveInsight } from './types.js';
-interface MeaningfulResult {
-    meaningful: true;
-    title: string;
-    summary: string;
-    whyItMatters: string;
-    nextAction: string;
-    evidence: ProactiveEvidence[];
-}
-export declare function parseFocusRunResult(summary: string): MeaningfulResult | {
-    meaningful: false;
-} | null;
-export declare function hasValidIntelligenceEvidence(evidence: ProactiveEvidence[]): boolean;
-export declare function processFocusAutomationRun(run: AutomationRun): {
-    handled: boolean;
-    insight?: ProactiveInsight;
-};
-export {};

package/dist/src/proactive/run-processor.js

@@ -1,146 +0,0 @@
-import { createLogger } from "../utils/logger/index.js";
-import { init_logger } from "../utils/logger.js";
-import { getRelationshipSettings, isProactiveSupportAllowed } from "../storage/sqlite/relationship-settings-repository.js";
-import "../storage/sqlite/index.js";
-import { getFocusWatchByAutomationId, recordFocusWatchRun } from "./watch-repository.js";
-import { createProactiveInsight, listProactiveInsights } from "./insight-repository.js";
-import { scoreProactiveValue } from "./value-score.js";
-//#region src/proactive/run-processor.ts
-init_logger();
-const log = createLogger("ProactiveRunProcessor");
-function nonEmptyString(value) {
-	return typeof value === "string" && value.trim() ? value.trim() : null;
-}
-function parseFocusRunResult(summary) {
-	const start = summary.indexOf("{");
-	const end = summary.lastIndexOf("}");
-	if (start < 0 || end <= start) return null;
-	let value;
-	try {
-		value = JSON.parse(summary.slice(start, end + 1));
-	} catch {
-		return null;
-	}
-	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-	const result = value;
-	if (result.meaningful === false) return { meaningful: false };
-	if (result.meaningful !== true) return null;
-	const title = nonEmptyString(result.title);
-	const resultSummary = nonEmptyString(result.summary);
-	const whyItMatters = nonEmptyString(result.whyItMatters);
-	const nextAction = nonEmptyString(result.nextAction);
-	const evidence = Array.isArray(result.evidence) ? result.evidence.flatMap((item) => {
-		if (!item || typeof item !== "object" || Array.isArray(item)) return [];
-		const label = nonEmptyString(item.label);
-		const source = nonEmptyString(item.source);
-		const publishedAtValue = nonEmptyString(item.publishedAt);
-		const publishedAt = publishedAtValue && Number.isFinite(Date.parse(publishedAtValue)) ? new Date(publishedAtValue).toISOString() : null;
-		return label ? [{
-			label,
-			...source ? { source } : {},
-			...publishedAt ? { publishedAt } : {}
-		}] : [];
-	}).slice(0, 8) : [];
-	if (!title || !resultSummary || !whyItMatters || !nextAction || evidence.length === 0) return null;
-	return {
-		meaningful: true,
-		title,
-		summary: resultSummary,
-		whyItMatters,
-		nextAction,
-		evidence
-	};
-}
-function hasValidIntelligenceEvidence(evidence) {
-	return evidence.some((item) => {
-		if (!item.source || !item.publishedAt) return false;
-		try {
-			const url = new URL(item.source);
-			return (url.protocol === "https:" || url.protocol === "http:") && Number.isFinite(Date.parse(item.publishedAt));
-		} catch {
-			return false;
-		}
-	});
-}
-function processFocusAutomationRun(run) {
-	const watch = getFocusWatchByAutomationId(run.automationId);
-	if (!watch) return { handled: false };
-	if (run.status !== "succeeded" || !run.summary) {
-		recordFocusWatchRun({
-			id: watch.id,
-			runId: run.id,
-			outcome: "failed",
-			nowMs: run.endedAtMs
-		});
-		return { handled: true };
-	}
-	const result = parseFocusRunResult(run.summary);
-	if (!result) {
-		recordFocusWatchRun({
-			id: watch.id,
-			runId: run.id,
-			outcome: "failed",
-			nowMs: run.endedAtMs
-		});
-		log.warn({
-			automationId: run.automationId,
-			runId: run.id
-		}, "Focus watch returned an invalid result");
-		return { handled: true };
-	}
-	if (result.meaningful && watch.kind === "intelligence" && !hasValidIntelligenceEvidence(result.evidence)) {
-		recordFocusWatchRun({
-			id: watch.id,
-			runId: run.id,
-			outcome: "failed",
-			nowMs: run.endedAtMs
-		});
-		log.warn({
-			automationId: run.automationId,
-			runId: run.id
-		}, "Intelligence watch result lacked dated web evidence");
-		return { handled: true };
-	}
-	if (!recordFocusWatchRun({
-		id: watch.id,
-		runId: run.id,
-		outcome: result.meaningful ? "meaningful" : "empty",
-		nowMs: run.endedAtMs
-	})) return { handled: true };
-	if (!result.meaningful) return { handled: true };
-	if (!isProactiveSupportAllowed(getRelationshipSettings(), {
-		now: new Date(run.endedAtMs),
-		topic: watch.kind
-	})) return { handled: true };
-	const history = listProactiveInsights({
-		status: ["approved", "dismissed"],
-		limit: 50
-	});
-	const value = scoreProactiveValue({
-		kind: watch.kind,
-		evidenceCount: result.evidence.length,
-		hasNextAction: Boolean(result.nextAction),
-		approvedCount: history.filter((item) => item.status === "approved").length,
-		dismissedCount: history.filter((item) => item.status === "dismissed").length
-	});
-	if (!value.shouldDeliver) return { handled: true };
-	const insight = createProactiveInsight({
-		watchId: watch.id,
-		runId: run.id,
-		kind: watch.kind,
-		title: result.title,
-		summary: result.summary,
-		whyItMatters: result.whyItMatters,
-		nextAction: result.nextAction,
-		evidence: result.evidence,
-		valueScore: value.score,
-		valueReasons: value.reasons,
-		nowMs: run.endedAtMs
-	});
-	return insight ? {
-		handled: true,
-		insight
-	} : { handled: true };
-}
-//#endregion
-export { hasValidIntelligenceEvidence, parseFocusRunResult, processFocusAutomationRun };

package/dist/src/proactive/trial-expiry-reconciler.d.ts

@@ -1,5 +0,0 @@
-interface TrialExpiryService {
-    reconcileExpiredTrials(): Promise<number>;
-}
-export declare function startTrialExpiryReconciler(service: TrialExpiryService, intervalMs?: number): () => Promise<void>;
-export {};