@elizaos/plugin-personal-assistant 2.0.3-beta.5 → 2.0.3-beta.7

package/dist/lifeops/service-mixin-goals.js

@@ -0,0 +1,884 @@
+import {
+  GoalsService,
+  scoreGoalSimilarity
+} from "@elizaos/plugin-goals/goals-service";
+import { LIFEOPS_GOAL_SUGGESTION_KINDS } from "../contracts/index.js";
+import { resolveDefaultTimeZone } from "./defaults.js";
+import {
+  mergeGoalSemanticReviewMetadata,
+  readGoalGroundingMetadata,
+  readGoalSemanticReviewMetadata
+} from "./goal-grounding.js";
+import { evaluateGoalProgressWithLlm } from "./goal-semantic-evaluator.js";
+import {
+  createLifeOpsAuditEvent
+} from "./repository.js";
+import {
+  GOAL_REVIEW_LOOKBACK_DAYS,
+  GOAL_SEMANTIC_REVIEW_CACHE_TTL_MS,
+  MAX_OVERVIEW_REMINDERS,
+  OVERVIEW_HORIZON_MINUTES
+} from "./service-constants.js";
+import {
+  buildActiveCalendarEventReminders,
+  buildActiveReminders,
+  isRecord,
+  mergeMetadata,
+  priorityToUrgency,
+  selectOverviewOccurrences
+} from "./service-helpers-misc.js";
+import { summarizeOverviewSection } from "./service-helpers-occurrence.js";
+import { shouldDeliverReminderForIntensity } from "./service-helpers-reminder.js";
+import { fail, normalizeReminderUrgency } from "./service-normalize.js";
+import { addMinutes, getZonedDateParts } from "./time.js";
+const ONE_DAY_MS = 24 * 60 * 60 * 1e3;
+const GOAL_STALE_DAYS_FREQUENT = 2;
+const GOAL_STALE_DAYS_WEEKLY = 10;
+const GOAL_STALE_DAYS_DEFAULT = 7;
+function withGoals(Base) {
+  const GoalsBase = Base;
+  class LifeOpsGoalServiceMixin extends GoalsBase {
+    // The goal CRUD back-end (create/update/delete/list/get + dedup + scoring)
+    // is owned by @elizaos/plugin-goals (`GoalsService`). PA keeps the
+    // cross-domain goal review / overview / experience-loop logic (which
+    // aggregates the definition / occurrence / reminder / calendar graph that
+    // is PA-owned) and delegates the CRUD methods here so the route + view stay
+    // byte-identical. recordAudit (shared `app_lifeops` audit store) and
+    // normalizeOwnership (PA domain/identity rules) are passed in as hooks.
+    goalsServiceInstance = null;
+    goalsService() {
+      if (!this.goalsServiceInstance) {
+        this.goalsServiceInstance = new GoalsService(this.runtime, {
+          recordAudit: (eventType, ownerType, ownerId, reason, inputs, decision) => this.recordAudit(
+            eventType,
+            ownerType,
+            ownerId,
+            reason,
+            inputs,
+            decision
+          ),
+          normalizeOwnership: (input, current) => this.normalizeOwnership(input, current)
+        });
+      }
+      return this.goalsServiceInstance;
+    }
+    async deleteGoal(goalId) {
+      return this.goalsService().deleteGoal(goalId);
+    }
+    async listGoals() {
+      return this.goalsService().listGoals();
+    }
+    async getGoal(goalId) {
+      return this.goalsService().getGoal(goalId);
+    }
+    async createGoal(request) {
+      return this.goalsService().createGoal(request);
+    }
+    async updateGoal(goalId, request) {
+      return this.goalsService().updateGoal(goalId, request);
+    }
+    async collectLinkedDefinitionsForGoal(goalRecord) {
+      const linkedDefinitionIds = new Set(
+        goalRecord.links.filter((link) => link.linkedType === "definition").map((link) => link.linkedId)
+      );
+      const definitions = await this.repository.listDefinitions(this.agentId());
+      return definitions.filter(
+        (definition) => definition.status !== "archived" && (definition.goalId === goalRecord.goal.id || linkedDefinitionIds.has(definition.id))
+      ).sort((left, right) => left.title.localeCompare(right.title));
+    }
+    async collectOccurrenceViewsForDefinitions(definitions) {
+      const views = [];
+      for (const definition of definitions) {
+        const occurrences = await this.repository.listOccurrencesForDefinition(
+          this.agentId(),
+          definition.id
+        );
+        for (const occurrence of occurrences) {
+          const view = await this.repository.getOccurrenceView(
+            this.agentId(),
+            occurrence.id
+          );
+          if (view) {
+            views.push(view);
+          }
+        }
+      }
+      views.sort(
+        (left, right) => new Date(left.updatedAt).getTime() - new Date(right.updatedAt).getTime()
+      );
+      return views;
+    }
+    deriveGoalReviewState(goal, definitions, activeOccurrences, overdueOccurrences, recentCompletions, lastActivityAt, now) {
+      if (goal.status === "satisfied") {
+        return "on_track";
+      }
+      if (goal.status !== "active") {
+        return goal.reviewState;
+      }
+      if (definitions.length === 0) {
+        return "needs_attention";
+      }
+      if (overdueOccurrences.length > 0) {
+        return "at_risk";
+      }
+      if (!lastActivityAt) {
+        return "needs_attention";
+      }
+      const cadenceKind = isRecord(goal.cadence) && typeof goal.cadence.kind === "string" ? goal.cadence.kind : null;
+      const staleMs = cadenceKind === "daily" || cadenceKind === "times_per_day" || cadenceKind === "interval" ? GOAL_STALE_DAYS_FREQUENT * ONE_DAY_MS : cadenceKind === "weekly" ? GOAL_STALE_DAYS_WEEKLY * ONE_DAY_MS : GOAL_STALE_DAYS_DEFAULT * ONE_DAY_MS;
+      const lastActivityTime = new Date(lastActivityAt).getTime();
+      if (!Number.isFinite(lastActivityTime)) {
+        return "needs_attention";
+      }
+      if (now.getTime() - lastActivityTime > staleMs) {
+        return activeOccurrences.length > 0 ? "needs_attention" : "at_risk";
+      }
+      if (recentCompletions.length === 0 && activeOccurrences.length === 0) {
+        return "needs_attention";
+      }
+      return "on_track";
+    }
+    buildGoalReviewExplanation(args) {
+      if (args.goal.status === "satisfied") {
+        return "This goal is marked satisfied and currently does not need more support work.";
+      }
+      if (args.linkedDefinitionCount === 0) {
+        return "This goal has no linked support tasks or routines yet, so there is nothing concrete to keep it moving.";
+      }
+      if (args.overdueOccurrenceCount > 0) {
+        return `This goal is at risk because ${args.overdueOccurrenceCount} linked support ${args.overdueOccurrenceCount === 1 ? "item is" : "items are"} overdue.`;
+      }
+      if (args.completedLast7Days > 0) {
+        return `This goal is on track because ${args.completedLast7Days} linked support ${args.completedLast7Days === 1 ? "item was" : "items were"} completed in the last 7 days.`;
+      }
+      if (args.activeOccurrenceCount > 0) {
+        return `This goal has ${args.activeOccurrenceCount} active support ${args.activeOccurrenceCount === 1 ? "item" : "items"} in flight right now.`;
+      }
+      if (args.lastActivityAt) {
+        return `This goal has support structure, but it has been quiet since ${args.lastActivityAt}.`;
+      }
+      if (args.reviewState === "needs_attention") {
+        return "This goal needs a clearer support structure or a new check-in.";
+      }
+      return "This goal has support structure and does not currently have overdue work.";
+    }
+    buildGoalSupportSuggestions(args) {
+      const suggestions = [];
+      if (args.linkedDefinitions.length === 0) {
+        suggestions.push({
+          kind: LIFEOPS_GOAL_SUGGESTION_KINDS[0],
+          title: "Create the first support routine",
+          detail: "Break this goal into a recurring task, habit, or routine so the agent can track and remind against something concrete.",
+          definitionId: null,
+          occurrenceId: null
+        });
+        return suggestions;
+      }
+      for (const overdue of args.overdueOccurrences.slice(0, 2)) {
+        suggestions.push({
+          kind: LIFEOPS_GOAL_SUGGESTION_KINDS[2],
+          title: overdue.title,
+          detail: "Resolve or reschedule this overdue support item so the goal is no longer drifting.",
+          definitionId: overdue.definitionId,
+          occurrenceId: overdue.id
+        });
+      }
+      if (suggestions.length === 0 && args.activeOccurrences.length > 0) {
+        const next = args.activeOccurrences[0];
+        suggestions.push({
+          kind: LIFEOPS_GOAL_SUGGESTION_KINDS[1],
+          title: next.title,
+          detail: "This is the clearest current action that advances the goal right now.",
+          definitionId: next.definitionId,
+          occurrenceId: next.id
+        });
+      }
+      if (args.recentCompletions.length === 0) {
+        suggestions.push({
+          kind: LIFEOPS_GOAL_SUGGESTION_KINDS[3],
+          title: "Review progress",
+          detail: "Check whether the current cadence still fits the goal, or whether the goal needs a stronger routine.",
+          definitionId: null,
+          occurrenceId: null
+        });
+      }
+      if (suggestions.length < 3 && args.linkedDefinitions.every((definition) => definition.kind === "task")) {
+        suggestions.push({
+          kind: LIFEOPS_GOAL_SUGGESTION_KINDS[4],
+          title: "Tighten the support cadence",
+          detail: "This goal only has one-off tasks linked to it. Consider adding a recurring habit or routine if progress should stay continuous.",
+          definitionId: null,
+          occurrenceId: null
+        });
+      }
+      return suggestions.slice(0, 3);
+    }
+    scoreGoalSimilarity(args) {
+      return scoreGoalSimilarity(args);
+    }
+    buildExperienceLoopSuggestions(args) {
+      const suggestions = [];
+      const seen = /* @__PURE__ */ new Set();
+      const pushSuggestion = (suggestion) => {
+        const key = `${suggestion.definitionId ?? "none"}:${suggestion.title.toLowerCase()}`;
+        if (seen.has(key)) {
+          return;
+        }
+        seen.add(key);
+        suggestions.push(suggestion);
+      };
+      for (const completion of args.recentCompletions.slice(0, 2)) {
+        pushSuggestion({
+          sourceGoalId: args.goal.id,
+          definitionId: completion.definitionId,
+          title: completion.title,
+          detail: `Carry forward "${completion.title}" because it was one of the support steps you actually completed when "${args.goal.title}" stayed on track.`
+        });
+      }
+      for (const definition of args.linkedDefinitions.slice(0, 3)) {
+        pushSuggestion({
+          sourceGoalId: args.goal.id,
+          definitionId: definition.id,
+          title: definition.title,
+          detail: `Re-use "${definition.title}" if the new goal needs the same support structure that helped "${args.goal.title}".`
+        });
+      }
+      return suggestions.slice(0, 3);
+    }
+    formatLocalHourMinute(isoValue, timeZone) {
+      if (!isoValue) {
+        return null;
+      }
+      const date = new Date(isoValue);
+      if (Number.isNaN(date.getTime())) {
+        return null;
+      }
+      const parts = getZonedDateParts(date, timeZone);
+      return `${String(parts.hour).padStart(2, "0")}:${String(
+        parts.minute
+      ).padStart(2, "0")}`;
+    }
+    median(values) {
+      if (values.length === 0) {
+        return null;
+      }
+      const sorted = [...values].sort((left, right) => left - right);
+      const middle = Math.floor(sorted.length / 2);
+      if (sorted.length % 2 === 1) {
+        return sorted[middle];
+      }
+      return (sorted[middle - 1] + sorted[middle]) / 2;
+    }
+    async buildGoalSemanticEvidence(args) {
+      const timeZone = resolveDefaultTimeZone();
+      const linkedDefinitionSummaries = args.linkedDefinitions.slice(0, 8).map((definition) => ({
+        id: definition.id,
+        kind: definition.kind,
+        title: definition.title,
+        cadence: definition.cadence,
+        status: definition.status
+      }));
+      const sleepSignals = (await this.listActivitySignals({
+        sinceAt: new Date(
+          args.now.getTime() - 30 * 24 * 60 * 60 * 1e3
+        ).toISOString(),
+        limit: 80
+      })).filter((signal) => signal.health?.sleep).slice(0, 30);
+      const sleepSessions = sleepSignals.map((signal) => {
+        const sleep = signal.health?.sleep;
+        if (!sleep) {
+          return null;
+        }
+        return {
+          observedAt: signal.observedAt,
+          asleepAt: sleep.asleepAt,
+          awakeAt: sleep.awakeAt,
+          durationMinutes: sleep.durationMinutes,
+          localBedtime: this.formatLocalHourMinute(sleep.asleepAt, timeZone),
+          localWakeTime: this.formatLocalHourMinute(sleep.awakeAt, timeZone),
+          stage: sleep.stage
+        };
+      }).filter(
+        (session) => session !== null
+      ).slice(0, 14);
+      const sleepStartHours = sleepSessions.map((session) => {
+        const localBedtime = session.localBedtime;
+        if (!localBedtime) {
+          return null;
+        }
+        const [hour, minute] = localBedtime.split(":").map(Number);
+        if (!Number.isFinite(hour) || !Number.isFinite(minute)) {
+          return null;
+        }
+        return hour + minute / 60;
+      }).filter((value) => value !== null);
+      const wakeHours = sleepSessions.map((session) => {
+        const localWakeTime = session.localWakeTime;
+        if (!localWakeTime) {
+          return null;
+        }
+        const [hour, minute] = localWakeTime.split(":").map(Number);
+        if (!Number.isFinite(hour) || !Number.isFinite(minute)) {
+          return null;
+        }
+        return hour + minute / 60;
+      }).filter((value) => value !== null);
+      const durations = sleepSessions.map((session) => session.durationMinutes).filter((value) => typeof value === "number");
+      return {
+        now: args.now.toISOString(),
+        timeZone,
+        goalGrounding: readGoalGroundingMetadata(args.goal.metadata),
+        deterministicSummary: args.summary,
+        reviewState: args.reviewState,
+        linkedDefinitions: linkedDefinitionSummaries,
+        activeOccurrences: args.activeOccurrences.slice(0, 8).map((occurrence) => ({
+          id: occurrence.id,
+          title: occurrence.title,
+          dueAt: occurrence.dueAt,
+          state: occurrence.state
+        })),
+        overdueOccurrences: args.overdueOccurrences.slice(0, 8).map((occurrence) => ({
+          id: occurrence.id,
+          title: occurrence.title,
+          dueAt: occurrence.dueAt,
+          state: occurrence.state
+        })),
+        recentCompletions: args.recentCompletions.slice(0, 8).map((occurrence) => ({
+          id: occurrence.id,
+          title: occurrence.title,
+          updatedAt: occurrence.updatedAt
+        })),
+        lastActivityAt: args.lastActivityAt,
+        sleepSummary: {
+          sampleCount: sleepSessions.length,
+          typicalBedtimeHour: this.median(sleepStartHours),
+          typicalWakeHour: this.median(wakeHours),
+          typicalSleepDurationMinutes: durations.length > 0 ? Math.round(
+            durations.reduce((sum, value) => sum + value, 0) / durations.length
+          ) : null
+        },
+        sleepSessions
+      };
+    }
+    getCachedSemanticGoalReview(args) {
+      const cached = readGoalSemanticReviewMetadata(args.goal.metadata);
+      if (!cached) {
+        return null;
+      }
+      const reviewedAtMs = new Date(cached.reviewedAt).getTime();
+      if (!Number.isFinite(reviewedAtMs)) {
+        return null;
+      }
+      if (args.now.getTime() - reviewedAtMs > GOAL_SEMANTIC_REVIEW_CACHE_TTL_MS) {
+        return null;
+      }
+      return cached;
+    }
+    async syncComputedGoalReviewState(goal, reviewState, summary, semanticReview, now) {
+      const currentSemanticReview = readGoalSemanticReviewMetadata(
+        goal.metadata
+      );
+      const semanticUnchanged = !semanticReview || currentSemanticReview && semanticReview && currentSemanticReview.reviewedAt === semanticReview.reviewedAt && currentSemanticReview.reviewState === semanticReview.reviewState && currentSemanticReview.explanation === semanticReview.explanation;
+      if (goal.reviewState === reviewState && semanticUnchanged) {
+        return goal;
+      }
+      const mergedMetadata = mergeMetadata(goal.metadata, {
+        computedGoalReview: {
+          reviewedAt: now.toISOString(),
+          reviewState,
+          summary
+        }
+      });
+      const nextGoal = {
+        ...goal,
+        reviewState,
+        metadata: semanticReview ? mergeGoalSemanticReviewMetadata(mergedMetadata, semanticReview) : mergedMetadata,
+        updatedAt: now.toISOString()
+      };
+      await this.repository.updateGoal(nextGoal);
+      await this.repository.createAuditEvent(
+        createLifeOpsAuditEvent({
+          agentId: this.agentId(),
+          eventType: "goal_reviewed",
+          ownerType: "goal",
+          ownerId: goal.id,
+          reason: "goal review recomputed",
+          inputs: {
+            previousReviewState: goal.reviewState
+          },
+          decision: {
+            reviewState,
+            summary
+          },
+          actor: "agent"
+        })
+      );
+      return nextGoal;
+    }
+    async buildGoalReview(goalRecord, now, options = {}) {
+      const linkedDefinitions = await this.collectLinkedDefinitionsForGoal(goalRecord);
+      const allOccurrenceViews = await this.collectOccurrenceViewsForDefinitions(linkedDefinitions);
+      const lookbackStart = new Date(
+        now.getTime() - GOAL_REVIEW_LOOKBACK_DAYS * 24 * 60 * 60 * 1e3
+      );
+      const activeOccurrences = allOccurrenceViews.filter(
+        (occurrence) => occurrence.state === "visible" || occurrence.state === "snoozed"
+      );
+      const overdueOccurrences = activeOccurrences.filter((occurrence) => {
+        if (!occurrence.dueAt) {
+          return false;
+        }
+        return new Date(occurrence.dueAt).getTime() < now.getTime();
+      });
+      const recentCompletions = allOccurrenceViews.filter(
+        (occurrence) => occurrence.state === "completed" && new Date(occurrence.updatedAt).getTime() >= lookbackStart.getTime()
+      );
+      const lastActivityAt = allOccurrenceViews.reduce(
+        (latest, occurrence) => {
+          const currentTime = new Date(occurrence.updatedAt).getTime();
+          if (!Number.isFinite(currentTime)) {
+            return latest;
+          }
+          if (!latest) {
+            return occurrence.updatedAt;
+          }
+          return currentTime > new Date(latest).getTime() ? occurrence.updatedAt : latest;
+        },
+        null
+      );
+      const derivedReviewState = this.deriveGoalReviewState(
+        goalRecord.goal,
+        linkedDefinitions,
+        activeOccurrences,
+        overdueOccurrences,
+        recentCompletions,
+        lastActivityAt,
+        now
+      );
+      const summary = {
+        linkedDefinitionCount: linkedDefinitions.length,
+        activeOccurrenceCount: activeOccurrences.length,
+        overdueOccurrenceCount: overdueOccurrences.length,
+        completedLast7Days: recentCompletions.length,
+        lastActivityAt,
+        reviewState: derivedReviewState,
+        explanation: this.buildGoalReviewExplanation({
+          goal: goalRecord.goal,
+          linkedDefinitionCount: linkedDefinitions.length,
+          activeOccurrenceCount: activeOccurrences.length,
+          overdueOccurrenceCount: overdueOccurrences.length,
+          completedLast7Days: recentCompletions.length,
+          reviewState: derivedReviewState,
+          lastActivityAt
+        })
+      };
+      const cachedSemanticReview = this.getCachedSemanticGoalReview({
+        goal: goalRecord.goal,
+        now
+      });
+      const semanticEvidence = readGoalGroundingMetadata(
+        goalRecord.goal.metadata
+      ) ? await this.buildGoalSemanticEvidence({
+        activeOccurrences,
+        goal: goalRecord.goal,
+        lastActivityAt,
+        linkedDefinitions,
+        overdueOccurrences,
+        recentCompletions,
+        reviewState: derivedReviewState,
+        summary,
+        now
+      }) : null;
+      const semanticReview = cachedSemanticReview ?? (options.allowSemanticEvaluation && semanticEvidence ? await evaluateGoalProgressWithLlm({
+        runtime: this.runtime,
+        evidence: semanticEvidence,
+        goal: goalRecord.goal,
+        nowIso: now.toISOString()
+      }) : null);
+      const effectiveReviewState = semanticReview?.reviewState ?? derivedReviewState;
+      const effectiveSummary = {
+        ...summary,
+        reviewState: effectiveReviewState,
+        explanation: semanticReview?.explanation ?? summary.explanation,
+        progressScore: semanticReview?.progressScore ?? null,
+        confidence: semanticReview?.confidence ?? null,
+        evidenceSummary: semanticReview?.evidenceSummary ?? null,
+        missingEvidence: semanticReview?.missingEvidence ?? [],
+        groundingState: readGoalGroundingMetadata(goalRecord.goal.metadata)?.groundingState ?? null,
+        groundingSummary: readGoalGroundingMetadata(goalRecord.goal.metadata)?.summary ?? null,
+        semanticReviewedAt: semanticReview?.reviewedAt ?? null
+      };
+      const goal = await this.syncComputedGoalReviewState(
+        goalRecord.goal,
+        effectiveReviewState,
+        effectiveSummary,
+        semanticReview,
+        now
+      );
+      const suggestions = semanticReview?.suggestions.length ? semanticReview.suggestions.map((suggestion) => ({
+        kind: suggestion.kind ?? "review_progress",
+        title: suggestion.title,
+        detail: suggestion.detail,
+        definitionId: null,
+        occurrenceId: null
+      })) : this.buildGoalSupportSuggestions({
+        goal,
+        linkedDefinitions,
+        activeOccurrences,
+        overdueOccurrences,
+        recentCompletions
+      });
+      return {
+        goal,
+        links: goalRecord.links,
+        linkedDefinitions,
+        activeOccurrences,
+        overdueOccurrences,
+        recentCompletions,
+        suggestions,
+        audits: await this.repository.listAuditEvents(
+          this.agentId(),
+          "goal",
+          goal.id
+        ),
+        summary: {
+          ...effectiveSummary,
+          reviewState: goal.reviewState
+        }
+      };
+    }
+    async reviewGoal(goalId, now = /* @__PURE__ */ new Date()) {
+      const goalRecord = await this.getGoalRecord(goalId);
+      return this.buildGoalReview(goalRecord, now, {
+        allowSemanticEvaluation: true
+      });
+    }
+    async buildGoalExperienceLoop(reference, now = /* @__PURE__ */ new Date()) {
+      const goalRecords = await this.listGoals();
+      const matches = [];
+      for (const record of goalRecords) {
+        if (record.goal.id === reference.goalId) {
+          continue;
+        }
+        if (record.goal.status !== "satisfied") {
+          continue;
+        }
+        const score = this.scoreGoalSimilarity({
+          reference,
+          candidate: record.goal
+        });
+        if (score < 0.34) {
+          continue;
+        }
+        const review = await this.buildGoalReview(record, now, {
+          allowSemanticEvaluation: false
+        });
+        matches.push({
+          goalId: review.goal.id,
+          title: review.goal.title,
+          description: review.goal.description,
+          score: Number(score.toFixed(3)),
+          scoreSort: score,
+          status: review.goal.status,
+          reviewState: review.summary.reviewState,
+          linkedDefinitionCount: review.summary.linkedDefinitionCount,
+          completedLast7Days: review.summary.completedLast7Days,
+          lastActivityAt: review.summary.lastActivityAt,
+          explanation: review.summary.explanation,
+          carryForwardSuggestions: this.buildExperienceLoopSuggestions({
+            goal: review.goal,
+            linkedDefinitions: review.linkedDefinitions,
+            recentCompletions: review.recentCompletions
+          })
+        });
+      }
+      matches.sort((left, right) => right.scoreSort - left.scoreSort);
+      const similarGoals = matches.slice(0, 3).map(({ scoreSort: _scoreSort, ...match }) => match);
+      const carryForwardSeen = /* @__PURE__ */ new Set();
+      const suggestedCarryForward = [];
+      for (const match of similarGoals) {
+        for (const suggestion of match.carryForwardSuggestions) {
+          const key = `${suggestion.sourceGoalId}:${suggestion.definitionId ?? "none"}:${suggestion.title.toLowerCase()}`;
+          if (carryForwardSeen.has(key)) {
+            continue;
+          }
+          carryForwardSeen.add(key);
+          suggestedCarryForward.push(suggestion);
+        }
+      }
+      const topMatch = similarGoals[0] ?? null;
+      return {
+        referenceGoalId: reference.goalId ?? null,
+        referenceTitle: reference.title,
+        similarGoals,
+        suggestedCarryForward: suggestedCarryForward.slice(0, 4),
+        summary: topMatch ? `A similar completed goal, "${topMatch.title}", is the best carry-forward reference for "${reference.title}".` : null
+      };
+    }
+    async reviewGoalsForWeek(now = /* @__PURE__ */ new Date()) {
+      const goals = (await this.repository.listGoals(this.agentId())).filter(
+        (goal) => goal.status === "active"
+      );
+      const reviews = [];
+      for (const goal of goals) {
+        reviews.push(
+          await this.buildGoalReview(
+            {
+              goal,
+              links: await this.repository.listGoalLinksForGoal(
+                this.agentId(),
+                goal.id
+              )
+            },
+            now,
+            { allowSemanticEvaluation: false }
+          )
+        );
+      }
+      const onTrack = reviews.filter(
+        (review) => review.summary.reviewState === "on_track"
+      );
+      const atRisk = reviews.filter(
+        (review) => review.summary.reviewState === "at_risk"
+      );
+      const needsAttention = reviews.filter(
+        (review) => review.summary.reviewState === "needs_attention"
+      );
+      const idle = reviews.filter(
+        (review) => review.summary.reviewState === "idle"
+      );
+      return {
+        generatedAt: now.toISOString(),
+        reviewWindow: "this_week",
+        summary: {
+          totalGoals: reviews.length,
+          onTrackCount: onTrack.length,
+          atRiskCount: atRisk.length,
+          needsAttentionCount: needsAttention.length,
+          idleCount: idle.length
+        },
+        onTrack,
+        atRisk,
+        needsAttention,
+        idle
+      };
+    }
+    async explainOccurrence(occurrenceId) {
+      const occurrence = await this.repository.getOccurrenceView(
+        this.agentId(),
+        occurrenceId
+      );
+      if (!occurrence) {
+        fail(404, "life-ops occurrence not found");
+      }
+      const definitionRecord = await this.getDefinitionRecord(
+        occurrence.definitionId
+      );
+      const linkedGoal = definitionRecord.definition.goalId ? await this.getGoalRecord(definitionRecord.definition.goalId) : null;
+      const reminderInspection = await this.inspectReminder(
+        "occurrence",
+        occurrence.id
+      );
+      const definitionAudits = await this.repository.listAuditEvents(
+        this.agentId(),
+        "definition",
+        definitionRecord.definition.id
+      );
+      const lastReminderAttempt = reminderInspection.attempts[0] ?? null;
+      const lastOccurrenceAudit = reminderInspection.audits[0] ?? null;
+      const whyVisible = occurrence.state === "snoozed" && occurrence.snoozedUntil ? `This item is still visible because it was snoozed until ${occurrence.snoozedUntil}.` : occurrence.dueAt ? `This item is visible because it is due at ${occurrence.dueAt} and its current relevance window started at ${occurrence.relevanceStartAt}.` : `This item is visible because its current relevance window started at ${occurrence.relevanceStartAt}.`;
+      return {
+        occurrence,
+        definition: definitionRecord.definition,
+        definitionPerformance: definitionRecord.performance,
+        reminderPlan: definitionRecord.reminderPlan,
+        linkedGoal,
+        reminderInspection,
+        definitionAudits,
+        summary: {
+          originalIntent: definitionRecord.definition.originalIntent,
+          source: definitionRecord.definition.source,
+          whyVisible,
+          lastReminderAt: lastReminderAttempt?.attemptedAt ?? null,
+          lastReminderChannel: lastReminderAttempt?.channel,
+          lastReminderOutcome: lastReminderAttempt?.outcome,
+          lastActionSummary: lastOccurrenceAudit ? `${lastOccurrenceAudit.reason} at ${lastOccurrenceAudit.createdAt}` : null
+        }
+      };
+    }
+    async refreshGoalReviewStates(now) {
+      const goals = (await this.repository.listGoals(this.agentId())).filter(
+        (goal) => goal.status === "active"
+      );
+      const refreshed = [];
+      for (const goal of goals) {
+        const review = await this.buildGoalReview(
+          {
+            goal,
+            links: await this.repository.listGoalLinksForGoal(
+              this.agentId(),
+              goal.id
+            )
+          },
+          now,
+          { allowSemanticEvaluation: false }
+        );
+        refreshed.push(review.goal);
+      }
+      return refreshed;
+    }
+    async getOverview(now = /* @__PURE__ */ new Date()) {
+      const schedule = await this.refreshEffectiveScheduleState({
+        timezone: resolveDefaultTimeZone(),
+        now
+      });
+      const definitions = await this.repository.listActiveDefinitions(
+        this.agentId()
+      );
+      for (const definition of definitions) {
+        await this.refreshDefinitionOccurrences(definition, now);
+      }
+      const definitionsById = new Map(
+        definitions.map((definition) => [definition.id, definition])
+      );
+      const horizon = addMinutes(now, OVERVIEW_HORIZON_MINUTES).toISOString();
+      const overviewOccurrences = await this.repository.listOccurrenceViewsForOverview(
+        this.agentId(),
+        horizon
+      );
+      const reminderPlans = await this.repository.listReminderPlansForOwners(
+        this.agentId(),
+        "definition",
+        overviewOccurrences.map((occurrence) => occurrence.definitionId)
+      );
+      const policies = await this.repository.listChannelPolicies(
+        this.agentId()
+      );
+      const definitionPreferencesById = /* @__PURE__ */ new Map();
+      const plansByDefinitionId = /* @__PURE__ */ new Map();
+      for (const plan of reminderPlans) {
+        const definition = definitionsById.get(plan.ownerId) ?? null;
+        const preference = this.buildReminderPreferenceResponse(
+          definition,
+          policies
+        );
+        definitionPreferencesById.set(plan.ownerId, preference);
+        const effectivePlan = this.resolveEffectiveReminderPlan(
+          plan,
+          preference
+        );
+        if (effectivePlan) {
+          plansByDefinitionId.set(plan.ownerId, effectivePlan);
+        }
+      }
+      const calendarEvents = await this.repository.listCalendarEvents(
+        this.agentId(),
+        "google",
+        now.toISOString(),
+        addMinutes(now, OVERVIEW_HORIZON_MINUTES).toISOString()
+      );
+      const calendarReminderPlans = await this.repository.listReminderPlansForOwners(
+        this.agentId(),
+        "calendar_event",
+        calendarEvents.map((event) => event.id)
+      );
+      const globalReminderPreference = this.buildReminderPreferenceResponse(
+        null,
+        policies
+      );
+      const occurrenceUrgencies = /* @__PURE__ */ new Map();
+      for (const occurrence of overviewOccurrences) {
+        occurrenceUrgencies.set(
+          occurrence.id,
+          typeof occurrence.metadata.urgency === "string" ? normalizeReminderUrgency(occurrence.metadata.urgency) : priorityToUrgency(occurrence.priority)
+        );
+      }
+      const eventUrgencies = /* @__PURE__ */ new Map();
+      for (const event of calendarEvents) {
+        eventUrgencies.set(
+          event.id,
+          typeof event.metadata.urgency === "string" ? normalizeReminderUrgency(event.metadata.urgency) : "medium"
+        );
+      }
+      const plansByEventId = /* @__PURE__ */ new Map();
+      for (const plan of calendarReminderPlans) {
+        const effectivePlan = this.resolveEffectiveReminderPlan(
+          plan,
+          globalReminderPreference
+        );
+        if (effectivePlan) {
+          plansByEventId.set(plan.ownerId, effectivePlan);
+        }
+      }
+      const goals = await this.refreshGoalReviewStates(now);
+      const allReminders = [
+        ...buildActiveReminders(
+          overviewOccurrences,
+          plansByDefinitionId,
+          now
+        ).filter(
+          (reminder) => shouldDeliverReminderForIntensity(
+            definitionPreferencesById.get(reminder.definitionId ?? "")?.effective?.intensity ?? globalReminderPreference.effective.intensity,
+            occurrenceUrgencies.get(reminder.ownerId) ?? "medium"
+          )
+        ),
+        ...buildActiveCalendarEventReminders(
+          calendarEvents,
+          plansByEventId,
+          this.ownerEntityId(),
+          now
+        ).filter(
+          (reminder) => shouldDeliverReminderForIntensity(
+            globalReminderPreference.effective.intensity,
+            eventUrgencies.get(reminder.ownerId) ?? "medium"
+          )
+        )
+      ].sort(
+        (left, right) => new Date(left.scheduledFor).getTime() - new Date(right.scheduledFor).getTime()
+      );
+      const ownerSectionBase = {
+        occurrences: selectOverviewOccurrences(
+          overviewOccurrences.filter(
+            (occurrence) => occurrence.subjectType === "owner"
+          )
+        ),
+        goals: goals.filter((goal) => goal.subjectType === "owner"),
+        reminders: allReminders.filter((reminder) => reminder.subjectType === "owner").slice(0, MAX_OVERVIEW_REMINDERS)
+      };
+      const agentSectionBase = {
+        occurrences: selectOverviewOccurrences(
+          overviewOccurrences.filter(
+            (occurrence) => occurrence.subjectType === "agent"
+          )
+        ),
+        goals: goals.filter((goal) => goal.subjectType === "agent"),
+        reminders: allReminders.filter((reminder) => reminder.subjectType === "agent").slice(0, MAX_OVERVIEW_REMINDERS)
+      };
+      const owner = {
+        ...ownerSectionBase,
+        summary: summarizeOverviewSection(ownerSectionBase, now)
+      };
+      const agentOps = {
+        ...agentSectionBase,
+        summary: summarizeOverviewSection(agentSectionBase, now)
+      };
+      return {
+        occurrences: owner.occurrences,
+        goals: owner.goals,
+        reminders: owner.reminders,
+        summary: owner.summary,
+        owner,
+        agentOps,
+        schedule
+      };
+    }
+    async listChannelPolicies() {
+      return this.repository.listChannelPolicies(this.agentId());
+    }
+  }
+  return LifeOpsGoalServiceMixin;
+}
+export {
+  withGoals
+};
+//# sourceMappingURL=service-mixin-goals.js.map