@xopcai/xopc 0.0.159 → 0.0.160

package/dist/src/pets/factory.js

@@ -75,23 +75,26 @@ function esc(value) {
 	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
 function desktopPetActionFrameCount(action) {
-	if (action === "idle") return 6;
-	if (action === "success" || action === "error") return 8;
+	if (action === "idle" || action === "sleep") return 6;
+	if (action === "success" || action === "concern") return 8;
 	return 10;
 }
 function desktopPetActionFps(action) {
-	if (action === "idle") return 6;
-	if (action === "success" || action === "error") return 12;
+	if (action === "idle" || action === "sleep") return 6;
+	if (action === "success" || action === "concern") return 12;
 	return 10;
 }
 function desktopPetActionLoops(action) {
-	return action !== "success" && action !== "error";
+	return action === "idle" || action === "sleep" || action === "research" || action === "read" || action === "create" || action === "execute" || action === "wait";
 }
 function renderAccessory(action, frame, style) {
 	const t = frame / Math.max(1, desktopPetActionFrameCount(action) - 1);
 	const bob = Math.sin(t * Math.PI * 2) * 2;
 	const { palette } = style;
-	if (action === "typing") {
+	if (action === "sleep") return `<g fill="${palette.screen}" font-family="Arial, sans-serif" font-weight="800"><text x="70" y="28" font-size="13" opacity="${frame % 2 ? .45 : .9}">z</text><text x="80" y="17" font-size="10" opacity="${frame % 2 ? .9 : .45}">z</text></g>`;
+	if (action === "greet" || action === "wake" || action === "pet") return `<path d="M76 23c-7-9-19 1-7 13l7 7 7-7c12-12 0-22-7-13z" fill="${palette.cheek}" stroke="#101827" stroke-width="2"/>`;
+	if (action === "wait") return `<g fill="${palette.screen}" transform="translate(62 18)"><circle cx="0" cy="0" r="3" opacity="${frame % 3 === 0 ? 1 : .35}"/><circle cx="10" cy="0" r="3" opacity="${frame % 3 === 1 ? 1 : .35}"/><circle cx="20" cy="0" r="3" opacity="${frame % 3 === 2 ? 1 : .35}"/></g>`;
+	if (action === "create") {
 		const glow = frame % 2 === 0 ? 1 : .45;
 		return `
       <g transform="translate(55 ${59 + bob})">
@@ -103,7 +106,7 @@ function renderAccessory(action, frame, style) {
         <rect x="29" y="28" width="5" height="2" rx="1" fill="#e0f2fe" opacity="${glow}"/>
       </g>`;
 	}
-	if (action === "toolbox") {
+	if (action === "prepare") {
 		const open = frame % 2 === 0 ? -11 : -3;
 		return `
       <g transform="translate(6 ${61 + bob})">
@@ -114,38 +117,30 @@ function renderAccessory(action, frame, style) {
         <rect x="29" y="${8 + open / 2}" width="5" height="17" rx="2" fill="#e5e7eb" stroke="#101827" stroke-width="2" transform="rotate(25 31 24)"/>
       </g>`;
 	}
-	if (action === "search") return `
+	if (action === "research") return `
       <g transform="translate(58 ${58 + bob}) rotate(${frame % 2 === 0 ? -7 : 4} 18 18)">
         <circle cx="15" cy="14" r="11" fill="#e0f2fe" stroke="${palette.accent}" stroke-width="5"/>
         <rect x="24" y="24" width="17" height="7" rx="3" fill="${palette.accent}" stroke="#101827" stroke-width="3" transform="rotate(43 24 24)"/>
       </g>`;
-	if (action === "file") return `
+	if (action === "read") return `
       <g transform="translate(59 ${55 + bob}) rotate(${frame % 2 === 0 ? -5 : 5} 16 20)">
         <path d="M5 1h22l9 9v31H5z" fill="#eff6ff" stroke="#101827" stroke-width="3" stroke-linejoin="round"/>
         <path d="M27 1v10h9" fill="${palette.accent}" stroke="#101827" stroke-width="3" stroke-linejoin="round"/>
         <rect x="12" y="20" width="16" height="3" rx="1.5" fill="${palette.body}"/>
         <rect x="12" y="28" width="12" height="3" rx="1.5" fill="${palette.body}"/>
       </g>`;
-	if (action === "terminal") return `
+	if (action === "execute") return `
       <g transform="translate(55 ${61 + bob})">
         <rect x="0" y="0" width="39" height="29" rx="7" fill="#111827" stroke="#101827" stroke-width="3"/>
         <path d="M10 10l6 5-6 5" fill="none" stroke="#86efac" stroke-width="3" stroke-linecap="round" stroke-linejoin="round" opacity="${frame % 2 === 0 ? 1 : .4}"/>
         <path d="M20 20h9" stroke="#86efac" stroke-width="3" stroke-linecap="round"/>
-      </g>`;
-	if (action === "browser") return `
-      <g transform="translate(55 ${58 + bob})">
-        <rect x="0" y="0" width="40" height="31" rx="7" fill="#e0f2fe" stroke="#101827" stroke-width="3"/>
-        <path d="M1 11h38" stroke="${palette.accent}" stroke-width="8"/>
-        <circle cx="10" cy="10" r="2" fill="#101827"/>
-        <circle cx="17" cy="10" r="2" fill="#101827"/>
-        <rect x="11" y="21" width="20" height="4" rx="2" fill="${palette.body}"/>
       </g>`;
 	if (action === "success") return `
       <g fill="#facc15" transform="translate(61 ${12 + bob})">
         <path d="M12 0l3 8 8 3-8 3-3 8-3-8-8-3 8-3z"/>
         <path d="M-12 18l2 5 5 2-5 2-2 5-2-5-5-2 5-2z" opacity="0.78"/>
       </g>`;
-	if (action === "error") return `
+	if (action === "concern") return `
       <g transform="translate(61 ${56 + bob})">
         <path d="M18 0l18 32H0z" fill="#facc15" stroke="#101827" stroke-width="3" stroke-linejoin="round"/>
         <text x="18" y="26" text-anchor="middle" font-family="Arial, sans-serif" font-size="22" font-weight="900" fill="#101827">!</text>
@@ -170,14 +165,14 @@ function renderHead(style) {
 }
 function renderFrame(style, action, frame) {
 	const t = frame / Math.max(1, desktopPetActionFrameCount(action) - 1);
-	const bob = Math.sin(t * Math.PI * 2) * (action === "idle" ? 2.5 : 1.5);
-	const tilt = action === "toolbox" ? Math.sin(t * Math.PI * 2) * 2.5 : 0;
+	const bob = action === "sleep" ? 7 : action === "pickedUp" ? -6 : action === "released" ? 4 : Math.sin(t * Math.PI * 2) * (action === "idle" ? 2.5 : 1.5);
+	const tilt = action === "prepare" ? Math.sin(t * Math.PI * 2) * 2.5 : action === "pet" ? Math.sin(t * Math.PI) * 5 : 0;
 	const { palette } = style;
-	const face = action === "error" ? "#3f0f18" : palette.face;
-	const eye = action === "error" ? "#fca5a5" : palette.screen;
-	const mouth = action === "success" ? "M39 45q5 5 10 0" : "M42 46h9";
-	const leftArm = action === "typing" ? 23 + frame % 2 * 13 : action === "toolbox" ? 39 + frame % 2 * 10 : 9;
-	const rightArm = action === "typing" ? -23 - frame % 2 * 13 : action === "toolbox" ? -39 - frame % 2 * 10 : -9;
+	const face = action === "concern" ? "#3f0f18" : palette.face;
+	const eye = action === "concern" ? "#fca5a5" : palette.screen;
+	const mouth = action === "success" || action === "greet" || action === "pet" ? "M39 45q5 5 10 0" : "M42 46h9";
+	const leftArm = action === "create" || action === "execute" ? 23 + frame % 2 * 13 : action === "prepare" || action === "read" ? 39 + frame % 2 * 10 : action === "pickedUp" ? 58 : 9;
+	const rightArm = action === "create" || action === "execute" ? -23 - frame % 2 * 13 : action === "prepare" || action === "read" ? -39 - frame % 2 * 10 : action === "greet" || action === "wake" ? -48 - frame % 2 * 12 : action === "pickedUp" ? -58 : -9;
 	return `
     <g transform="translate(0 ${bob}) rotate(${tilt} 48 76)">
       ${renderHead(style)}
@@ -287,6 +282,7 @@ async function createDesktopPetPackage(input) {
 	await mkdir(targetRoot, { recursive: true });
 	const { id, dir } = await resolvePackageDir(targetRoot, (input.id?.trim() ? normalizePackageId(input.id) : null) || slugify(input.name?.trim() || titleFromPrompt(prompt), `pet-${hashString(prompt).toString(36)}`), input.overwrite === true);
 	const existingManifest = input.overwrite === true ? await readExistingManifest(dir) : null;
+	if (existingManifest && existingManifest.schemaVersion !== 2) throw new Error(`Existing pet package must use schemaVersion 2`);
 	const existingName = typeof existingManifest?.name === "string" ? existingManifest.name.trim() : "";
 	const persona = normalizePersona(input.persona ?? existingManifest?.persona);
 	const baseName = clampText(input.name?.trim() || existingName || titleFromPrompt(prompt), 36);
@@ -296,6 +292,7 @@ async function createDesktopPetPackage(input) {
 	const thumbnailPath = join(tempDir, "thumbnail.svg");
 	const manifestPath = join(tempDir, "manifest.json");
 	const manifest = {
+		schemaVersion: 2,
 		id,
 		name: baseName,
 		description,

package/dist/src/pets/manifest.d.ts

@@ -1,2 +1,3 @@
-export declare const DESKTOP_PET_ACTIONS: readonly ["idle", "typing", "toolbox", "search", "file", "terminal", "browser", "success", "error"];
+export declare const DESKTOP_PET_SCHEMA_VERSION: 2;
+export declare const DESKTOP_PET_ACTIONS: readonly ["idle", "sleep", "wake", "greet", "prepare", "research", "read", "create", "execute", "wait", "success", "concern", "pet", "pickedUp", "released"];
 export type DesktopPetPackageAction = (typeof DESKTOP_PET_ACTIONS)[number];

package/dist/src/pets/manifest.js

@@ -1,14 +1,21 @@
 //#region src/pets/manifest.ts
+const DESKTOP_PET_SCHEMA_VERSION = 2;
 const DESKTOP_PET_ACTIONS = [
 	"idle",
-	"typing",
-	"toolbox",
-	"search",
-	"file",
-	"terminal",
-	"browser",
+	"sleep",
+	"wake",
+	"greet",
+	"prepare",
+	"research",
+	"read",
+	"create",
+	"execute",
+	"wait",
 	"success",
-	"error"
+	"concern",
+	"pet",
+	"pickedUp",
+	"released"
 ];
 //#endregion
-export { DESKTOP_PET_ACTIONS };
+export { DESKTOP_PET_ACTIONS, DESKTOP_PET_SCHEMA_VERSION };

package/dist/src/pets/validator.js

@@ -135,6 +135,7 @@ async function validateDesktopPetPackage(dir) {
 		};
 	}
 	if (typeof manifest.id !== "string" || !manifest.id.trim()) details.push("id is required");
+	if (manifest.schemaVersion !== 2) details.push(`schemaVersion must be 2`);
 	if (typeof manifest.name !== "string" || !manifest.name.trim()) details.push("name is required");
 	if (typeof manifest.description !== "string" || !manifest.description.trim()) details.push("description is required");
 	if (positiveNumber(manifest.canvasWidth) === null || positiveNumber(manifest.canvasHeight) === null) details.push("canvasWidth and canvasHeight must be positive numbers");
@@ -143,9 +144,13 @@ async function validateDesktopPetPackage(dir) {
 	const rawAnimations = manifest.animations && typeof manifest.animations === "object" ? manifest.animations : null;
 	if (!rawAnimations) details.push("animations is required");
 	const animations = [];
-	if (rawAnimations) for (const action of DESKTOP_PET_ACTIONS) {
-		const animation = parseAnimation(action, rawAnimations[action], details);
-		if (animation) animations.push(animation);
+	if (rawAnimations) {
+		const supportedActions = new Set(DESKTOP_PET_ACTIONS);
+		for (const action of Object.keys(rawAnimations)) if (!supportedActions.has(action)) details.push(`${action}: unsupported animation action`);
+		for (const action of DESKTOP_PET_ACTIONS) {
+			const animation = parseAnimation(action, rawAnimations[action], details);
+			if (animation) animations.push(animation);
+		}
 	}
 	for (const animation of animations) {
 		const sourcePath = safeResolve(dir, animation.src);

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

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

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

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

@@ -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;