@xopcai/xopc 0.0.159 → 0.0.161

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

@@ -0,0 +1,173 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,19 @@
+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[];
+    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

@@ -0,0 +1,106 @@
+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,
+		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, 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, 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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,125 @@
+import { createLogger } from "../utils/logger/index.js";
+import { init_logger } from "../utils/logger.js";
+import { getFocusWatchByAutomationId, recordFocusWatchRun } from "./watch-repository.js";
+import { createProactiveInsight } from "./insight-repository.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 };
+	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,
+		nowMs: run.endedAtMs
+	});
+	return insight ? {
+		handled: true,
+		insight
+	} : { handled: true };
+}
+//#endregion
+export { hasValidIntelligenceEvidence, parseFocusRunResult, processFocusAutomationRun };

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

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

package/dist/src/proactive/trial-expiry-reconciler.js

@@ -0,0 +1,30 @@
+import { createLogger } from "../utils/logger/index.js";
+import { init_logger } from "../utils/logger.js";
+//#region src/proactive/trial-expiry-reconciler.ts
+init_logger();
+const DEFAULT_RECONCILE_INTERVAL_MS = 6e4;
+const log = createLogger("FocusTrialExpiry");
+function startTrialExpiryReconciler(service, intervalMs = DEFAULT_RECONCILE_INTERVAL_MS) {
+	let stopped = false;
+	let pending = null;
+	const reconcile = () => {
+		if (stopped || pending) return;
+		pending = service.reconcileExpiredTrials().then((pausedCount) => {
+			if (pausedCount > 0) log.info({ pausedCount }, "Expired focus watch trials paused");
+		}).catch((err) => {
+			log.warn({ err }, "Focus watch trial expiry reconciliation failed");
+		}).finally(() => {
+			pending = null;
+		});
+	};
+	reconcile();
+	const timer = setInterval(reconcile, intervalMs);
+	timer.unref();
+	return async () => {
+		stopped = true;
+		clearInterval(timer);
+		await pending;
+	};
+}
+//#endregion
+export { startTrialExpiryReconciler };

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

@@ -0,0 +1,64 @@
+import type { WorkUnderstandingThread } from '../work-discovery/types.js';
+export type FocusWatchKind = 'progress' | 'staleness' | 'deadline' | 'intelligence';
+export type FocusWatchStatus = 'active' | 'paused';
+export interface FocusWatch {
+    id: string;
+    threadId: string;
+    goalId?: string;
+    automationId: string;
+    kind: FocusWatchKind;
+    status: FocusWatchStatus;
+    config: Record<string, unknown>;
+    trialEndsAt?: number;
+    lastCursor?: string;
+    lastRunAt?: number;
+    lastUsefulResultAt?: number;
+    consecutiveEmptyRuns: number;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface FocusView {
+    id: string;
+    title: string;
+    summary: string;
+    status: WorkUnderstandingThread['status'];
+    horizon: WorkUnderstandingThread['horizon'];
+    confidence: number;
+    focusScore: number;
+    userStatus: WorkUnderstandingThread['userStatus'];
+    projectIds: string[];
+    goalId?: string;
+    nextAction?: string;
+    blockedReason?: string;
+    watches: FocusWatch[];
+    lastObservedAt: number;
+}
+export type ProactiveInsightStatus = 'unread' | 'read' | 'approved' | 'dismissed';
+export interface ProactiveEvidence {
+    label: string;
+    source?: string;
+    publishedAt?: string;
+}
+export interface ProactiveInsight {
+    id: string;
+    watchId: string;
+    runId: string;
+    kind: FocusWatchKind;
+    title: string;
+    summary: string;
+    whyItMatters: string;
+    nextAction: string;
+    evidence: ProactiveEvidence[];
+    status: ProactiveInsightStatus;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface FocusCalendarSignal {
+    id: string;
+    focusId: string;
+    focusTitle: string;
+    title: string;
+    startsAt: number;
+    endsAt?: number;
+    sourceInstanceId: string;
+}

package/dist/src/proactive/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,28 @@
+import type { FocusWatch, FocusWatchKind, FocusWatchStatus } from './types.js';
+export declare function listFocusWatches(options?: {
+    threadId?: string;
+    status?: FocusWatchStatus;
+}): FocusWatch[];
+export declare function getFocusWatchByThreadAndKind(threadId: string, kind: FocusWatchKind): FocusWatch | null;
+export declare function getFocusWatchByAutomationId(automationId: string): FocusWatch | null;
+export declare function createFocusWatch(input: {
+    threadId: string;
+    goalId?: string;
+    automationId: string;
+    kind: FocusWatchKind;
+    config?: Record<string, unknown>;
+    trialEndsAt?: number;
+    nowMs?: number;
+}): FocusWatch;
+export declare function setFocusWatchStatus(id: string, status: FocusWatchStatus, nowMs?: number): FocusWatch | null;
+export declare function restartFocusWatchTrial(id: string, trialEndsAt: number, nowMs?: number): FocusWatch | null;
+export declare function recordFocusWatchRun(input: {
+    id: string;
+    runId: string;
+    outcome: 'meaningful' | 'empty' | 'failed';
+    nowMs?: number;
+}): FocusWatch | null;
+export declare function recordFocusWatchFeedback(id: string, useful: boolean, nowMs?: number): {
+    watch: FocusWatch;
+    consecutiveDismissed: number;
+} | null;