forge-openclaw-plugin 0.2.15 → 0.2.19

package/dist/server/types.js

@@ -1,5 +1,11 @@
 import { z } from "zod";
-export const taskStatusSchema = z.enum(["backlog", "focus", "in_progress", "blocked", "done"]);
+export const taskStatusSchema = z.enum([
+    "backlog",
+    "focus",
+    "in_progress",
+    "blocked",
+    "done"
+]);
 export const taskPrioritySchema = z.enum(["low", "medium", "high", "critical"]);
 export const taskEffortSchema = z.enum(["light", "deep", "marathon"]);
 export const taskEnergySchema = z.enum(["low", "steady", "high"]);
@@ -8,11 +14,71 @@ export const goalHorizonSchema = z.enum(["quarter", "year", "lifetime"]);
 export const projectStatusSchema = z.enum(["active", "paused", "completed"]);
 export const tagKindSchema = z.enum(["value", "category", "execution"]);
 export const taskDueFilterSchema = z.enum(["overdue", "today", "week"]);
-export const taskRunStatusSchema = z.enum(["active", "completed", "released", "timed_out"]);
+export const taskRunStatusSchema = z.enum([
+    "active",
+    "completed",
+    "released",
+    "timed_out"
+]);
 export const taskTimerModeSchema = z.enum(["planned", "unlimited"]);
-export const timeAccountingModeSchema = z.enum(["split", "parallel", "primary_only"]);
+export const timeAccountingModeSchema = z.enum([
+    "split",
+    "parallel",
+    "primary_only"
+]);
+export const habitFrequencySchema = z.enum(["daily", "weekly"]);
+export const habitPolaritySchema = z.enum(["positive", "negative"]);
+export const habitStatusSchema = z.enum(["active", "paused", "archived"]);
+export const habitCheckInStatusSchema = z.enum(["done", "missed"]);
+export const calendarProviderSchema = z.enum([
+    "google",
+    "apple",
+    "caldav",
+    "microsoft"
+]);
+export const calendarConnectionStatusSchema = z.enum([
+    "connected",
+    "needs_attention",
+    "error"
+]);
+export const calendarOwnershipSchema = z.enum(["external", "forge"]);
+export const calendarEventOriginSchema = z.enum([
+    "native",
+    "google",
+    "apple",
+    "caldav",
+    "microsoft",
+    "derived"
+]);
+export const calendarAvailabilitySchema = z.enum(["busy", "free"]);
+export const calendarEventStatusSchema = z.enum([
+    "confirmed",
+    "tentative",
+    "cancelled"
+]);
+export const workBlockKindSchema = z.enum([
+    "main_activity",
+    "secondary_activity",
+    "third_activity",
+    "rest",
+    "holiday",
+    "custom"
+]);
+export const calendarTimeboxStatusSchema = z.enum([
+    "planned",
+    "active",
+    "completed",
+    "cancelled"
+]);
+export const calendarTimeboxSourceSchema = z.enum([
+    "manual",
+    "suggested",
+    "live_run"
+]);
+export const workAdjustmentEntityTypeSchema = z.enum(["task", "project"]);
 export const activityEntityTypeSchema = z.enum([
     "task",
+    "habit",
     "goal",
     "project",
     "domain",
@@ -33,26 +99,80 @@ export const activityEntityTypeSchema = z.enum([
     "approval_request",
     "agent_action",
     "reward",
-    "session"
+    "session",
+    "calendar_connection",
+    "calendar",
+    "calendar_event",
+    "work_block",
+    "work_block_template",
+    "task_timebox"
+]);
+export const activitySourceSchema = z.enum([
+    "ui",
+    "openclaw",
+    "agent",
+    "system"
+]);
+export const agentTrustLevelSchema = z.enum([
+    "standard",
+    "trusted",
+    "autonomous"
+]);
+export const autonomyModeSchema = z.enum([
+    "approval_required",
+    "scoped_write",
+    "autonomous"
+]);
+export const approvalModeSchema = z.enum([
+    "approval_by_default",
+    "high_impact_only",
+    "none"
 ]);
-export const activitySourceSchema = z.enum(["ui", "openclaw", "agent", "system"]);
-export const agentTrustLevelSchema = z.enum(["standard", "trusted", "autonomous"]);
-export const autonomyModeSchema = z.enum(["approval_required", "scoped_write", "autonomous"]);
-export const approvalModeSchema = z.enum(["approval_by_default", "high_impact_only", "none"]);
 export const insightOriginSchema = z.enum(["system", "user", "agent"]);
-export const insightStatusSchema = z.enum(["open", "accepted", "dismissed", "snoozed", "applied", "expired"]);
-export const insightVisibilitySchema = z.enum(["visible", "pending_review", "archived"]);
-export const insightFeedbackTypeSchema = z.enum(["accepted", "dismissed", "applied", "snoozed"]);
-export const approvalRequestStatusSchema = z.enum(["pending", "approved", "rejected", "cancelled", "executed"]);
+export const insightStatusSchema = z.enum([
+    "open",
+    "accepted",
+    "dismissed",
+    "snoozed",
+    "applied",
+    "expired"
+]);
+export const insightVisibilitySchema = z.enum([
+    "visible",
+    "pending_review",
+    "archived"
+]);
+export const insightFeedbackTypeSchema = z.enum([
+    "accepted",
+    "dismissed",
+    "applied",
+    "snoozed"
+]);
+export const approvalRequestStatusSchema = z.enum([
+    "pending",
+    "approved",
+    "rejected",
+    "cancelled",
+    "executed"
+]);
 export const actionRiskLevelSchema = z.enum(["low", "medium", "high"]);
-export const agentActionStatusSchema = z.enum(["pending_approval", "approved", "rejected", "executed"]);
+export const agentActionStatusSchema = z.enum([
+    "pending_approval",
+    "approved",
+    "rejected",
+    "executed"
+]);
 export const crudEntityTypeSchema = z.enum([
     "goal",
     "project",
     "task",
+    "habit",
     "tag",
     "note",
     "insight",
+    "calendar_event",
+    "work_block_template",
+    "task_timebox",
     "psyche_value",
     "behavior_pattern",
     "behavior",
@@ -63,6 +183,22 @@ export const crudEntityTypeSchema = z.enum([
     "emotion_definition",
     "trigger_report"
 ]);
+export const rewardableEntityTypeSchema = z.enum([
+    "system",
+    "goal",
+    "project",
+    "task",
+    "habit",
+    "tag",
+    "note",
+    "insight",
+    "psyche_value",
+    "behavior_pattern",
+    "behavior",
+    "belief_entry",
+    "mode_profile",
+    "trigger_report"
+]);
 export const deleteModeSchema = z.enum(["soft", "hard"]);
 export const rewardRuleFamilySchema = z.enum([
     "completion",
@@ -75,7 +211,12 @@ export const rewardRuleFamilySchema = z.enum([
 export const appLocaleSchema = z.enum(["en", "fr"]);
 const trimmedString = z.string().trim();
 const nonEmptyTrimmedString = trimmedString.min(1);
-const rewardConfigValueSchema = z.union([z.string(), z.number(), z.boolean(), z.null()]);
+const rewardConfigValueSchema = z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.null()
+]);
 function isValidDateOnly(value) {
     if (!/^\d{4}-\d{2}-\d{2}$/.test(value)) {
         return false;
@@ -89,9 +230,15 @@ function isValidDateOnly(value) {
         candidate.getUTCMonth() === month - 1 &&
         candidate.getUTCDate() === day);
 }
+function isValidDateTime(value) {
+    return !Number.isNaN(Date.parse(value));
+}
 const dateOnlySchema = trimmedString.refine(isValidDateOnly, {
     message: "Expected a valid date in YYYY-MM-DD format"
 });
+const dateTimeSchema = trimmedString.refine(isValidDateTime, {
+    message: "Expected a valid ISO date-time string"
+});
 const uniqueStringArraySchema = z
     .array(nonEmptyTrimmedString)
     .superRefine((values, context) => {
@@ -108,6 +255,31 @@ const uniqueStringArraySchema = z
         seen.add(value);
     });
 });
+const integerMinuteSchema = z
+    .number()
+    .int()
+    .min(0)
+    .max(24 * 60);
+export const calendarSchedulingRulesSchema = z.object({
+    allowWorkBlockKinds: z.array(workBlockKindSchema).default([]),
+    blockWorkBlockKinds: z.array(workBlockKindSchema).default([]),
+    allowCalendarIds: uniqueStringArraySchema.default([]),
+    blockCalendarIds: uniqueStringArraySchema.default([]),
+    allowEventTypes: uniqueStringArraySchema.default([]),
+    blockEventTypes: uniqueStringArraySchema.default([]),
+    allowEventKeywords: uniqueStringArraySchema.default([]),
+    blockEventKeywords: uniqueStringArraySchema.default([]),
+    allowAvailability: z.array(calendarAvailabilitySchema).default([]),
+    blockAvailability: z.array(calendarAvailabilitySchema).default([])
+});
+export const calendarContextConflictSchema = z.object({
+    kind: z.enum(["external_event", "work_block"]),
+    id: z.string(),
+    title: z.string(),
+    reason: z.string(),
+    startsAt: z.string(),
+    endsAt: z.string()
+});
 export const tagSchema = z.object({
     id: z.string(),
     name: nonEmptyTrimmedString,
@@ -118,15 +290,65 @@ export const tagSchema = z.object({
 export const taskTimeSummarySchema = z.object({
     totalTrackedSeconds: z.number().int().nonnegative(),
     totalCreditedSeconds: z.number().nonnegative(),
+    liveTrackedSeconds: z.number().int().nonnegative().default(0),
+    liveCreditedSeconds: z.number().nonnegative().default(0),
+    manualAdjustedSeconds: z.number().int().default(0),
     activeRunCount: z.number().int().nonnegative(),
     hasCurrentRun: z.boolean(),
     currentRunId: z.string().nullable()
 });
+export const workAdjustmentSchema = z.object({
+    id: z.string(),
+    entityType: workAdjustmentEntityTypeSchema,
+    entityId: z.string(),
+    requestedDeltaMinutes: z
+        .number()
+        .int()
+        .refine((value) => value !== 0, {
+        message: "requestedDeltaMinutes must not be zero"
+    }),
+    appliedDeltaMinutes: z.number().int(),
+    note: z.string(),
+    actor: z.string().nullable(),
+    source: activitySourceSchema,
+    createdAt: z.string()
+});
+export const workAdjustmentTargetSummarySchema = z.object({
+    entityType: workAdjustmentEntityTypeSchema,
+    entityId: z.string(),
+    title: z.string(),
+    time: taskTimeSummarySchema
+});
+export const workAdjustmentResultSchema = z.object({
+    adjustment: workAdjustmentSchema,
+    target: workAdjustmentTargetSummarySchema,
+    reward: z.lazy(() => rewardLedgerEventSchema).nullable(),
+    metrics: z.lazy(() => xpMetricsPayloadSchema)
+});
 export const noteLinkSchema = z.object({
     entityType: crudEntityTypeSchema,
     entityId: nonEmptyTrimmedString,
     anchorKey: trimmedString.nullable().default(null)
 });
+const noteTagSchema = nonEmptyTrimmedString.max(80);
+const uniqueNoteTagArraySchema = z
+    .array(noteTagSchema)
+    .max(24)
+    .superRefine((values, context) => {
+    const seen = new Set();
+    values.forEach((value, index) => {
+        const normalized = value.toLowerCase();
+        if (seen.has(normalized)) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: [index],
+                message: `Duplicate note tag '${value}' is not allowed`
+            });
+            return;
+        }
+        seen.add(normalized);
+    });
+});
 export const noteSchema = z.object({
     id: z.string(),
     contentMarkdown: nonEmptyTrimmedString,
@@ -135,7 +357,9 @@ export const noteSchema = z.object({
     source: activitySourceSchema,
     createdAt: z.string(),
     updatedAt: z.string(),
-    links: z.array(noteLinkSchema).min(1)
+    links: z.array(noteLinkSchema).min(1),
+    tags: uniqueNoteTagArraySchema.default([]),
+    destroyAt: dateTimeSchema.nullable().default(null)
 });
 export const noteSummarySchema = z.object({
     count: z.number().int().nonnegative(),
@@ -163,6 +387,18 @@ export const projectSchema = z.object({
     status: projectStatusSchema,
     targetPoints: z.number().int().nonnegative(),
     themeColor: z.string(),
+    schedulingRules: calendarSchedulingRulesSchema.default({
+        allowWorkBlockKinds: [],
+        blockWorkBlockKinds: [],
+        allowCalendarIds: [],
+        blockCalendarIds: [],
+        allowEventTypes: [],
+        blockEventTypes: [],
+        allowEventKeywords: [],
+        blockEventKeywords: [],
+        allowAvailability: [],
+        blockAvailability: []
+    }),
     createdAt: z.string(),
     updatedAt: z.string()
 });
@@ -180,6 +416,14 @@ export const taskSchema = z.object({
     energy: taskEnergySchema,
     points: z.number().int().nonnegative(),
     sortOrder: z.number().int().nonnegative(),
+    plannedDurationSeconds: z
+        .number()
+        .int()
+        .min(60)
+        .max(86_400)
+        .nullable()
+        .default(null),
+    schedulingRules: calendarSchedulingRulesSchema.nullable().default(null),
     completedAt: z.string().nullable(),
     createdAt: z.string(),
     updatedAt: z.string(),
@@ -187,6 +431,9 @@ export const taskSchema = z.object({
     time: taskTimeSummarySchema.default({
         totalTrackedSeconds: 0,
         totalCreditedSeconds: 0,
+        liveTrackedSeconds: 0,
+        liveCreditedSeconds: 0,
+        manualAdjustedSeconds: 0,
         activeRunCount: 0,
         hasCurrentRun: false,
         currentRunId: null
@@ -213,8 +460,234 @@ export const taskRunSchema = z.object({
     completedAt: z.string().nullable(),
     releasedAt: z.string().nullable(),
     timedOutAt: z.string().nullable(),
+    overrideReason: trimmedString.nullable().default(null),
+    updatedAt: z.string()
+});
+export const calendarConnectionSchema = z.object({
+    id: z.string(),
+    provider: calendarProviderSchema,
+    label: nonEmptyTrimmedString,
+    accountLabel: trimmedString,
+    status: calendarConnectionStatusSchema,
+    config: z.record(z.string(), z.union([z.string(), z.number(), z.boolean(), z.null()])),
+    forgeCalendarId: z.string().nullable(),
+    lastSyncedAt: z.string().nullable(),
+    lastSyncError: trimmedString.nullable(),
+    createdAt: z.string(),
+    updatedAt: z.string()
+});
+export const calendarDiscoveryCalendarSchema = z.object({
+    url: nonEmptyTrimmedString.url(),
+    displayName: nonEmptyTrimmedString,
+    description: trimmedString,
+    color: z.string(),
+    timezone: trimmedString,
+    isPrimary: z.boolean(),
+    canWrite: z.boolean(),
+    selectedByDefault: z.boolean(),
+    isForgeCandidate: z.boolean()
+});
+export const calendarDiscoveryPayloadSchema = z.object({
+    provider: calendarProviderSchema,
+    accountLabel: trimmedString,
+    serverUrl: nonEmptyTrimmedString.url(),
+    principalUrl: z.string().nullable(),
+    homeUrl: z.string().nullable(),
+    calendars: z.array(calendarDiscoveryCalendarSchema)
+});
+export const calendarSchema = z.object({
+    id: z.string(),
+    connectionId: z.string(),
+    remoteId: nonEmptyTrimmedString,
+    title: nonEmptyTrimmedString,
+    description: trimmedString,
+    color: z.string(),
+    timezone: nonEmptyTrimmedString,
+    isPrimary: z.boolean(),
+    canWrite: z.boolean(),
+    selectedForSync: z.boolean(),
+    forgeManaged: z.boolean(),
+    lastSyncedAt: z.string().nullable(),
+    createdAt: z.string(),
+    updatedAt: z.string()
+});
+export const calendarEventSourceSchema = z.object({
+    id: z.string(),
+    provider: calendarProviderSchema,
+    connectionId: z.string().nullable(),
+    calendarId: z.string().nullable(),
+    remoteCalendarId: trimmedString.nullable(),
+    remoteEventId: nonEmptyTrimmedString,
+    remoteUid: trimmedString.nullable(),
+    recurrenceInstanceId: trimmedString.nullable(),
+    isMasterRecurring: z.boolean(),
+    remoteHref: trimmedString.nullable(),
+    remoteEtag: trimmedString.nullable(),
+    syncState: z.enum([
+        "pending_create",
+        "pending_update",
+        "pending_delete",
+        "synced",
+        "error",
+        "deleted"
+    ]),
+    lastSyncedAt: z.string().nullable(),
+    createdAt: z.string(),
+    updatedAt: z.string()
+});
+export const calendarEventLinkSchema = z.object({
+    id: z.string(),
+    entityType: crudEntityTypeSchema,
+    entityId: nonEmptyTrimmedString,
+    relationshipType: nonEmptyTrimmedString.default("context"),
+    createdAt: z.string(),
+    updatedAt: z.string()
+});
+export const calendarEventSchema = z.object({
+    id: z.string(),
+    connectionId: z.string().nullable(),
+    calendarId: z.string().nullable(),
+    remoteId: trimmedString.nullable(),
+    ownership: calendarOwnershipSchema,
+    originType: calendarEventOriginSchema,
+    status: calendarEventStatusSchema,
+    title: nonEmptyTrimmedString,
+    description: trimmedString,
+    location: trimmedString,
+    startAt: z.string(),
+    endAt: z.string(),
+    timezone: nonEmptyTrimmedString,
+    isAllDay: z.boolean(),
+    availability: calendarAvailabilitySchema,
+    eventType: trimmedString,
+    categories: z.array(z.string()).default([]),
+    sourceMappings: z.array(calendarEventSourceSchema).default([]),
+    links: z.array(calendarEventLinkSchema).default([]),
+    remoteUpdatedAt: z.string().nullable(),
+    deletedAt: z.string().nullable(),
+    createdAt: z.string(),
     updatedAt: z.string()
 });
+export const workBlockTemplateSchema = z
+    .object({
+    id: z.string(),
+    title: nonEmptyTrimmedString,
+    kind: workBlockKindSchema,
+    color: z.string(),
+    timezone: nonEmptyTrimmedString,
+    weekDays: z.array(z.number().int().min(0).max(6)).min(1).max(7),
+    startMinute: integerMinuteSchema,
+    endMinute: integerMinuteSchema,
+    startsOn: dateOnlySchema.nullable().default(null),
+    endsOn: dateOnlySchema.nullable().default(null),
+    blockingState: z.enum(["allowed", "blocked"]),
+    createdAt: z.string(),
+    updatedAt: z.string()
+})
+    .superRefine((value, context) => {
+    if (value.endMinute <= value.startMinute) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["endMinute"],
+            message: "endMinute must be greater than startMinute"
+        });
+    }
+    if (value.startsOn && value.endsOn && value.endsOn < value.startsOn) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["endsOn"],
+            message: "endsOn must be on or after startsOn"
+        });
+    }
+});
+export const workBlockInstanceSchema = z.object({
+    id: z.string(),
+    templateId: z.string(),
+    dateKey: dateOnlySchema,
+    startAt: z.string(),
+    endAt: z.string(),
+    title: nonEmptyTrimmedString,
+    kind: workBlockKindSchema,
+    color: z.string(),
+    blockingState: z.enum(["allowed", "blocked"]),
+    calendarEventId: z.string().nullable(),
+    createdAt: z.string(),
+    updatedAt: z.string()
+});
+export const taskTimeboxSchema = z.object({
+    id: z.string(),
+    taskId: z.string(),
+    projectId: z.string().nullable(),
+    connectionId: z.string().nullable(),
+    calendarId: z.string().nullable(),
+    remoteEventId: z.string().nullable(),
+    linkedTaskRunId: z.string().nullable(),
+    status: calendarTimeboxStatusSchema,
+    source: calendarTimeboxSourceSchema,
+    title: nonEmptyTrimmedString,
+    startsAt: z.string(),
+    endsAt: z.string(),
+    overrideReason: trimmedString.nullable(),
+    createdAt: z.string(),
+    updatedAt: z.string()
+});
+export const calendarOverviewPayloadSchema = z.object({
+    generatedAt: z.string(),
+    providers: z.array(z.object({
+        provider: calendarProviderSchema,
+        label: z.string(),
+        supportsDedicatedForgeCalendar: z.boolean(),
+        connectionHelp: z.string()
+    })),
+    connections: z.array(calendarConnectionSchema),
+    calendars: z.array(calendarSchema),
+    events: z.array(calendarEventSchema),
+    workBlockTemplates: z.array(workBlockTemplateSchema),
+    workBlockInstances: z.array(workBlockInstanceSchema),
+    timeboxes: z.array(taskTimeboxSchema)
+});
+export const habitCheckInSchema = z.object({
+    id: z.string(),
+    habitId: z.string(),
+    dateKey: z.string(),
+    status: habitCheckInStatusSchema,
+    note: z.string(),
+    deltaXp: z.number().int(),
+    createdAt: z.string(),
+    updatedAt: z.string()
+});
+export const habitSchema = z.object({
+    id: z.string(),
+    title: nonEmptyTrimmedString,
+    description: trimmedString,
+    status: habitStatusSchema,
+    polarity: habitPolaritySchema,
+    frequency: habitFrequencySchema,
+    targetCount: z.number().int().positive(),
+    weekDays: z.array(z.number().int().min(0).max(6)).default([]),
+    linkedGoalIds: uniqueStringArraySchema.default([]),
+    linkedProjectIds: uniqueStringArraySchema.default([]),
+    linkedTaskIds: uniqueStringArraySchema.default([]),
+    linkedValueIds: uniqueStringArraySchema.default([]),
+    linkedPatternIds: uniqueStringArraySchema.default([]),
+    linkedBehaviorIds: uniqueStringArraySchema.default([]),
+    linkedBeliefIds: uniqueStringArraySchema.default([]),
+    linkedModeIds: uniqueStringArraySchema.default([]),
+    linkedReportIds: uniqueStringArraySchema.default([]),
+    linkedBehaviorId: z.string().nullable(),
+    linkedBehaviorTitle: z.string().nullable(),
+    linkedBehaviorTitles: z.array(z.string()).default([]),
+    rewardXp: z.number().int().positive(),
+    penaltyXp: z.number().int().positive(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    lastCheckInAt: z.string().nullable(),
+    lastCheckInStatus: habitCheckInStatusSchema.nullable(),
+    streakCount: z.number().int().nonnegative(),
+    completionRate: z.number().min(0).max(100),
+    dueToday: z.boolean(),
+    checkIns: z.array(habitCheckInSchema).default([])
+});
 export const activityEventSchema = z.object({
     id: z.string(),
     entityType: activityEntityTypeSchema,
@@ -244,7 +717,12 @@ export const dashboardStatsSchema = z.object({
     overdueTasks: z.number().int().nonnegative(),
     dueThisWeek: z.number().int().nonnegative()
 });
-export const executionBucketToneSchema = z.enum(["urgent", "accent", "neutral", "success"]);
+export const executionBucketToneSchema = z.enum([
+    "urgent",
+    "accent",
+    "neutral",
+    "success"
+]);
 export const dashboardExecutionBucketSchema = z.object({
     id: z.enum(["overdue", "due_soon", "focus_now", "recently_completed"]),
     label: z.string(),
@@ -276,7 +754,12 @@ export const gamificationProfileSchema = z.object({
     topGoalId: z.string().nullable(),
     topGoalTitle: z.string().nullable()
 });
-export const achievementTierSchema = z.enum(["bronze", "silver", "gold", "platinum"]);
+export const achievementTierSchema = z.enum([
+    "bronze",
+    "silver",
+    "gold",
+    "platinum"
+]);
 export const achievementSignalSchema = z.object({
     id: z.string(),
     title: z.string(),
@@ -314,6 +797,7 @@ export const dashboardPayloadSchema = z.object({
     goals: z.array(dashboardGoalSchema),
     projects: z.array(projectSummarySchema),
     tasks: z.array(taskSchema),
+    habits: z.array(habitSchema),
     tags: z.array(tagSchema),
     suggestedTags: z.array(tagSchema),
     owners: z.array(z.string()),
@@ -354,6 +838,7 @@ export const overviewContextSchema = z.object({
     projects: z.array(projectSummarySchema),
     activeGoals: z.array(dashboardGoalSchema),
     topTasks: z.array(taskSchema),
+    dueHabits: z.array(habitSchema),
     recentEvidence: z.array(activityEventSchema),
     achievements: z.array(achievementSignalSchema),
     domainBalance: z.array(contextDomainBalanceSchema),
@@ -368,7 +853,16 @@ export const todayQuestSchema = z.object({
     completed: z.boolean()
 });
 export const todayTimelineBucketSchema = z.object({
-    id: z.enum(["completed", "active", "upcoming", "deferred", "in_progress", "ready", "blocked", "done"]),
+    id: z.enum([
+        "completed",
+        "active",
+        "upcoming",
+        "deferred",
+        "in_progress",
+        "ready",
+        "blocked",
+        "done"
+    ]),
     label: z.string(),
     tasks: z.array(taskSchema)
 });
@@ -381,8 +875,12 @@ export const todayContextSchema = z.object({
         sessionLabel: z.string()
     }),
     timeline: z.array(todayTimelineBucketSchema),
+    dueHabits: z.array(habitSchema),
     dailyQuests: z.array(todayQuestSchema),
     milestoneRewards: z.array(milestoneRewardSchema),
+    recentHabitRewards: z
+        .array(z.lazy(() => rewardLedgerEventSchema))
+        .default([]),
     momentum: z.object({
         streakDays: z.number().int().nonnegative(),
         momentumScore: z.number().int().min(0).max(100),
@@ -471,6 +969,9 @@ export const weeklyReviewCalibrationSchema = z.object({
 export const weeklyReviewPayloadSchema = z.object({
     generatedAt: z.string(),
     windowLabel: z.string(),
+    weekKey: z.string(),
+    weekStartDate: z.string(),
+    weekEndDate: z.string(),
     momentumSummary: z.object({
         totalXp: z.number().int().nonnegative(),
         focusHours: z.number().int().nonnegative(),
@@ -484,8 +985,31 @@ export const weeklyReviewPayloadSchema = z.object({
         title: z.string(),
         summary: z.string(),
         rewardXp: z.number().int().nonnegative()
+    }),
+    completion: z.object({
+        finalized: z.boolean(),
+        finalizedAt: z.string().nullable(),
+        finalizedBy: z.string().nullable()
     })
 });
+export const weeklyReviewClosureSchema = z.object({
+    id: z.string(),
+    weekKey: z.string(),
+    weekStartDate: z.string(),
+    weekEndDate: z.string(),
+    windowLabel: z.string(),
+    actor: z.string().nullable(),
+    source: activitySourceSchema,
+    rewardId: z.string(),
+    activityEventId: z.string(),
+    createdAt: z.string()
+});
+export const finalizeWeeklyReviewResultSchema = z.object({
+    review: weeklyReviewPayloadSchema,
+    closure: weeklyReviewClosureSchema,
+    reward: z.lazy(() => rewardLedgerEventSchema),
+    metrics: z.lazy(() => xpMetricsPayloadSchema)
+});
 export const notificationPreferencesSchema = z.object({
     goalDriftAlerts: z.boolean(),
     dailyQuestReminders: z.boolean(),
@@ -496,6 +1020,17 @@ export const executionSettingsSchema = z.object({
     maxActiveTasks: z.number().int().min(1).max(8),
     timeAccountingMode: timeAccountingModeSchema
 });
+export const microsoftCalendarAuthSettingsSchema = z.object({
+    clientId: z.string(),
+    tenantId: z.string(),
+    redirectUri: z.string(),
+    usesClientSecret: z.literal(false),
+    readOnly: z.literal(true),
+    authMode: z.literal("public_client_pkce"),
+    isConfigured: z.boolean(),
+    isReadyForSignIn: z.boolean(),
+    setupMessage: z.string()
+});
 export const agentTokenSummarySchema = z.object({
     id: z.string(),
     label: z.string(),
@@ -656,6 +1191,7 @@ export const operatorContextPayloadSchema = z.object({
     generatedAt: z.string(),
     activeProjects: z.array(projectSummarySchema),
     focusTasks: z.array(taskSchema),
+    dueHabits: z.array(habitSchema),
     currentBoard: z.object({
         backlog: z.array(taskSchema),
         focus: z.array(taskSchema),
@@ -675,15 +1211,29 @@ export const updateRewardRuleSchema = z.object({
     config: z.record(z.string(), rewardConfigValueSchema).optional()
 });
 export const createManualRewardGrantSchema = z.object({
-    entityType: nonEmptyTrimmedString,
+    entityType: rewardableEntityTypeSchema,
     entityId: nonEmptyTrimmedString,
-    deltaXp: z.number().int().refine((value) => value !== 0, {
+    deltaXp: z
+        .number()
+        .int()
+        .refine((value) => value !== 0, {
         message: "deltaXp must not be zero"
     }),
     reasonTitle: nonEmptyTrimmedString,
     reasonSummary: trimmedString.default(""),
     metadata: z.record(z.string(), rewardConfigValueSchema).default({})
 });
+export const createWorkAdjustmentSchema = z.object({
+    entityType: workAdjustmentEntityTypeSchema,
+    entityId: nonEmptyTrimmedString,
+    deltaMinutes: z
+        .number()
+        .int()
+        .refine((value) => value !== 0, {
+        message: "deltaMinutes must not be zero"
+    }),
+    note: trimmedString.default("")
+});
 export const settingsPayloadSchema = z.object({
     profile: z.object({
         operatorName: z.string(),
@@ -702,6 +1252,9 @@ export const settingsPayloadSchema = z.object({
         tokenCount: z.number().int().nonnegative(),
         psycheAuthRequired: z.boolean()
     }),
+    calendarProviders: z.object({
+        microsoft: microsoftCalendarAuthSettingsSchema
+    }),
     agents: z.array(agentIdentitySchema),
     agentTokens: z.array(agentTokenSummarySchema)
 });
@@ -727,28 +1280,103 @@ export const createNoteLinkSchema = z.object({
     entityId: nonEmptyTrimmedString,
     anchorKey: trimmedString.nullable().default(null)
 });
+const repeatedTrimmedStringQuerySchema = z.preprocess((value) => {
+    if (value === undefined || value === null || value === "") {
+        return [];
+    }
+    return Array.isArray(value) ? value : [value];
+}, z.array(trimmedString));
+const repeatedUnknownQuerySchema = z.preprocess((value) => {
+    if (value === undefined || value === null || value === "") {
+        return [];
+    }
+    return Array.isArray(value) ? value : [value];
+}, z.array(z.unknown()));
+const noteLinkedEntityFilterSchema = z.object({
+    entityType: crudEntityTypeSchema,
+    entityId: nonEmptyTrimmedString
+});
+function parseLinkedEntityQueryValue(raw) {
+    const separatorIndex = raw.indexOf(":");
+    if (separatorIndex <= 0 || separatorIndex >= raw.length - 1) {
+        throw new Error("Expected linked entity filters in entityType:entityId format");
+    }
+    return {
+        entityType: raw.slice(0, separatorIndex),
+        entityId: raw.slice(separatorIndex + 1)
+    };
+}
 export const createNoteSchema = z.object({
     contentMarkdown: nonEmptyTrimmedString,
     author: trimmedString.nullable().default(null),
-    links: z.array(createNoteLinkSchema).min(1)
+    links: z.array(createNoteLinkSchema).min(1),
+    tags: uniqueNoteTagArraySchema.default([]),
+    destroyAt: dateTimeSchema.nullable().default(null)
 });
 export const nestedCreateNoteSchema = z.object({
     contentMarkdown: nonEmptyTrimmedString,
     author: trimmedString.nullable().default(null),
-    links: z.array(createNoteLinkSchema).default([])
+    links: z.array(createNoteLinkSchema).default([]),
+    tags: uniqueNoteTagArraySchema.default([]),
+    destroyAt: dateTimeSchema.nullable().default(null)
 });
 export const updateNoteSchema = z.object({
     contentMarkdown: nonEmptyTrimmedString.optional(),
     author: trimmedString.nullable().optional(),
-    links: z.array(createNoteLinkSchema).min(1).optional()
+    links: z.array(createNoteLinkSchema).min(1).optional(),
+    tags: uniqueNoteTagArraySchema.optional(),
+    destroyAt: dateTimeSchema.nullable().optional()
 });
-export const notesListQuerySchema = z.object({
+export const notesListQuerySchema = z
+    .object({
     linkedEntityType: crudEntityTypeSchema.optional(),
     linkedEntityId: nonEmptyTrimmedString.optional(),
     anchorKey: trimmedString.nullable().optional(),
     author: trimmedString.optional(),
     query: trimmedString.optional(),
+    linkedTo: repeatedUnknownQuerySchema.transform((values, context) => values.map((value, index) => {
+        try {
+            if (typeof value === "string") {
+                return noteLinkedEntityFilterSchema.parse(parseLinkedEntityQueryValue(value));
+            }
+            return noteLinkedEntityFilterSchema.parse(value);
+        }
+        catch (error) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["linkedTo", index],
+                message: error instanceof Error ? error.message : "Invalid linkedTo filter"
+            });
+            return {
+                entityType: "goal",
+                entityId: "__invalid__"
+            };
+        }
+    })),
+    tags: repeatedTrimmedStringQuerySchema,
+    textTerms: repeatedTrimmedStringQuerySchema,
+    updatedFrom: dateOnlySchema.optional(),
+    updatedTo: dateOnlySchema.optional(),
     limit: z.coerce.number().int().positive().max(200).optional()
+})
+    .superRefine((value, context) => {
+    if (value.linkedEntityType !== undefined &&
+        value.linkedEntityId === undefined) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["linkedEntityId"],
+            message: "linkedEntityId is required when linkedEntityType is provided"
+        });
+    }
+    if (value.updatedFrom &&
+        value.updatedTo &&
+        value.updatedTo < value.updatedFrom) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["updatedTo"],
+            message: "updatedTo must be on or after updatedFrom"
+        });
+    }
 });
 export const taskListQuerySchema = z.object({
     status: taskStatusSchema.optional(),
@@ -777,13 +1405,270 @@ export const projectListQuerySchema = z.object({
     status: projectStatusSchema.optional(),
     limit: z.coerce.number().int().positive().max(100).optional()
 });
+export const calendarOverviewQuerySchema = z.object({
+    from: z.string().datetime().optional(),
+    to: z.string().datetime().optional()
+});
+export const createCalendarConnectionSchema = z.discriminatedUnion("provider", [
+    z.object({
+        provider: z.literal("google"),
+        label: nonEmptyTrimmedString,
+        username: nonEmptyTrimmedString,
+        clientId: nonEmptyTrimmedString,
+        clientSecret: nonEmptyTrimmedString,
+        refreshToken: nonEmptyTrimmedString,
+        selectedCalendarUrls: z.array(nonEmptyTrimmedString.url()).min(1),
+        forgeCalendarUrl: nonEmptyTrimmedString.url().nullable().optional(),
+        createForgeCalendar: z.boolean().optional().default(false)
+    }),
+    z.object({
+        provider: z.literal("apple"),
+        label: nonEmptyTrimmedString,
+        username: nonEmptyTrimmedString,
+        password: nonEmptyTrimmedString,
+        selectedCalendarUrls: z.array(nonEmptyTrimmedString.url()).min(1),
+        forgeCalendarUrl: nonEmptyTrimmedString.url().nullable().optional(),
+        createForgeCalendar: z.boolean().optional().default(false)
+    }),
+    z.object({
+        provider: z.literal("caldav"),
+        label: nonEmptyTrimmedString,
+        serverUrl: nonEmptyTrimmedString.url(),
+        username: nonEmptyTrimmedString,
+        password: nonEmptyTrimmedString,
+        selectedCalendarUrls: z.array(nonEmptyTrimmedString.url()).min(1),
+        forgeCalendarUrl: nonEmptyTrimmedString.url().nullable().optional(),
+        createForgeCalendar: z.boolean().optional().default(false)
+    }),
+    z.object({
+        provider: z.literal("microsoft"),
+        label: nonEmptyTrimmedString,
+        authSessionId: nonEmptyTrimmedString,
+        selectedCalendarUrls: z.array(nonEmptyTrimmedString.url()).min(1)
+    })
+]);
+export const discoverCalendarConnectionSchema = z.discriminatedUnion("provider", [
+    z.object({
+        provider: z.literal("google"),
+        username: nonEmptyTrimmedString,
+        clientId: nonEmptyTrimmedString,
+        clientSecret: nonEmptyTrimmedString,
+        refreshToken: nonEmptyTrimmedString
+    }),
+    z.object({
+        provider: z.literal("apple"),
+        username: nonEmptyTrimmedString,
+        password: nonEmptyTrimmedString
+    }),
+    z.object({
+        provider: z.literal("caldav"),
+        serverUrl: nonEmptyTrimmedString.url(),
+        username: nonEmptyTrimmedString,
+        password: nonEmptyTrimmedString
+    })
+]);
+export const startMicrosoftCalendarOauthSchema = z.object({
+    label: nonEmptyTrimmedString.optional()
+});
+export const testMicrosoftCalendarOauthConfigurationSchema = z.object({
+    clientId: nonEmptyTrimmedString.regex(/^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/, "Microsoft client IDs must use the standard app registration GUID format."),
+    tenantId: trimmedString.default("common"),
+    redirectUri: nonEmptyTrimmedString.url()
+});
+export const microsoftCalendarOauthSessionSchema = z.object({
+    sessionId: nonEmptyTrimmedString,
+    status: z.enum(["pending", "authorized", "error", "consumed", "expired"]),
+    authUrl: z.string().url().nullable(),
+    accountLabel: z.string().nullable(),
+    error: z.string().nullable(),
+    discovery: calendarDiscoveryPayloadSchema.nullable()
+});
+export const updateCalendarConnectionSchema = z.object({
+    label: nonEmptyTrimmedString.optional(),
+    selectedCalendarUrls: z.array(nonEmptyTrimmedString.url()).optional()
+});
+const workBlockTemplateMutationShape = {
+    title: nonEmptyTrimmedString,
+    kind: workBlockKindSchema.default("custom"),
+    color: z
+        .string()
+        .regex(/^#[0-9a-fA-F]{6}$/)
+        .default("#60a5fa"),
+    timezone: nonEmptyTrimmedString.default("UTC"),
+    weekDays: z.array(z.number().int().min(0).max(6)).min(1).max(7),
+    startMinute: integerMinuteSchema,
+    endMinute: integerMinuteSchema,
+    startsOn: dateOnlySchema.nullable().optional(),
+    endsOn: dateOnlySchema.nullable().optional(),
+    blockingState: z.enum(["allowed", "blocked"]).default("blocked")
+};
+export const createWorkBlockTemplateSchema = z
+    .object(workBlockTemplateMutationShape)
+    .superRefine((value, context) => {
+    if (value.endMinute <= value.startMinute) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["endMinute"],
+            message: "endMinute must be greater than startMinute"
+        });
+    }
+    if (value.startsOn && value.endsOn && value.endsOn < value.startsOn) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["endsOn"],
+            message: "endsOn must be on or after startsOn"
+        });
+    }
+});
+export const updateWorkBlockTemplateSchema = z
+    .object({
+    title: nonEmptyTrimmedString.optional(),
+    kind: workBlockKindSchema.optional(),
+    color: z
+        .string()
+        .regex(/^#[0-9a-fA-F]{6}$/)
+        .optional(),
+    timezone: nonEmptyTrimmedString.optional(),
+    weekDays: z.array(z.number().int().min(0).max(6)).min(1).max(7).optional(),
+    startMinute: integerMinuteSchema.optional(),
+    endMinute: integerMinuteSchema.optional(),
+    startsOn: dateOnlySchema.nullable().optional(),
+    endsOn: dateOnlySchema.nullable().optional(),
+    blockingState: z.enum(["allowed", "blocked"]).optional()
+})
+    .superRefine((value, context) => {
+    if (value.startMinute !== undefined &&
+        value.endMinute !== undefined &&
+        value.endMinute <= value.startMinute) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["endMinute"],
+            message: "endMinute must be greater than startMinute"
+        });
+    }
+    if (value.startsOn !== undefined &&
+        value.endsOn !== undefined &&
+        value.startsOn &&
+        value.endsOn &&
+        value.endsOn < value.startsOn) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["endsOn"],
+            message: "endsOn must be on or after startsOn"
+        });
+    }
+});
+export const createTaskTimeboxSchema = z
+    .object({
+    taskId: nonEmptyTrimmedString,
+    projectId: nonEmptyTrimmedString.nullable().optional(),
+    title: nonEmptyTrimmedString,
+    startsAt: z.string().datetime(),
+    endsAt: z.string().datetime(),
+    source: calendarTimeboxSourceSchema.default("manual"),
+    status: calendarTimeboxStatusSchema.default("planned"),
+    overrideReason: trimmedString.nullable().default(null)
+})
+    .superRefine((value, context) => {
+    if (Date.parse(value.endsAt) <= Date.parse(value.startsAt)) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["endsAt"],
+            message: "endsAt must be after startsAt"
+        });
+    }
+});
+export const updateTaskTimeboxSchema = z.object({
+    title: nonEmptyTrimmedString.optional(),
+    startsAt: z.string().datetime().optional(),
+    endsAt: z.string().datetime().optional(),
+    status: calendarTimeboxStatusSchema.optional(),
+    overrideReason: trimmedString.nullable().optional()
+});
+export const recommendTaskTimeboxesSchema = z.object({
+    taskId: nonEmptyTrimmedString,
+    from: z.string().datetime().optional(),
+    to: z.string().datetime().optional(),
+    limit: z.coerce.number().int().positive().max(12).optional()
+});
+export const updateCalendarEventSchema = z
+    .object({
+    title: nonEmptyTrimmedString.optional(),
+    description: trimmedString.optional(),
+    location: trimmedString.optional(),
+    startAt: z.string().datetime().optional(),
+    endAt: z.string().datetime().optional(),
+    timezone: nonEmptyTrimmedString.optional(),
+    isAllDay: z.boolean().optional(),
+    availability: calendarAvailabilitySchema.optional(),
+    eventType: trimmedString.optional(),
+    categories: z.array(trimmedString).optional(),
+    preferredCalendarId: nonEmptyTrimmedString.nullable().optional(),
+    links: z
+        .array(z.object({
+        entityType: crudEntityTypeSchema,
+        entityId: nonEmptyTrimmedString,
+        relationshipType: nonEmptyTrimmedString.default("context")
+    }))
+        .optional()
+})
+    .superRefine((value, context) => {
+    if (value.startAt !== undefined &&
+        value.endAt !== undefined &&
+        Date.parse(value.endAt) <= Date.parse(value.startAt)) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["endAt"],
+            message: "endAt must be after startAt"
+        });
+    }
+});
+export const createCalendarEventSchema = z
+    .object({
+    title: nonEmptyTrimmedString,
+    description: trimmedString.default(""),
+    location: trimmedString.default(""),
+    startAt: z.string().datetime(),
+    endAt: z.string().datetime(),
+    timezone: nonEmptyTrimmedString.default("UTC"),
+    isAllDay: z.boolean().default(false),
+    availability: calendarAvailabilitySchema.default("busy"),
+    eventType: trimmedString.default(""),
+    categories: z.array(trimmedString).default([]),
+    preferredCalendarId: nonEmptyTrimmedString.nullable().optional(),
+    links: z
+        .array(z.object({
+        entityType: crudEntityTypeSchema,
+        entityId: nonEmptyTrimmedString,
+        relationshipType: nonEmptyTrimmedString.default("context")
+    }))
+        .default([])
+})
+    .superRefine((value, context) => {
+    if (Date.parse(value.endAt) <= Date.parse(value.startAt)) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["endAt"],
+            message: "endAt must be after startAt"
+        });
+    }
+});
+export const habitListQuerySchema = z.object({
+    status: habitStatusSchema.optional(),
+    polarity: habitPolaritySchema.optional(),
+    dueToday: z.coerce.boolean().optional(),
+    limit: z.coerce.number().int().positive().max(100).optional()
+});
 export const createGoalSchema = z.object({
     title: nonEmptyTrimmedString,
     description: trimmedString.default(""),
     horizon: goalHorizonSchema.default("year"),
     status: goalStatusSchema.default("active"),
     targetPoints: z.number().int().min(25).max(10000).default(400),
-    themeColor: z.string().regex(/^#[0-9a-fA-F]{6}$/).default("#c8a46b"),
+    themeColor: z
+        .string()
+        .regex(/^#[0-9a-fA-F]{6}$/)
+        .default("#c8a46b"),
     tagIds: uniqueStringArraySchema.default([]),
     notes: z.array(nestedCreateNoteSchema).default([])
 });
@@ -791,7 +1676,10 @@ export const updateGoalSchema = createGoalSchema.partial();
 export const createTagSchema = z.object({
     name: nonEmptyTrimmedString,
     kind: tagKindSchema.default("category"),
-    color: z.string().regex(/^#[0-9a-fA-F]{6}$/).default("#71717a"),
+    color: z
+        .string()
+        .regex(/^#[0-9a-fA-F]{6}$/)
+        .default("#71717a"),
     description: trimmedString.default("")
 });
 export const updateTagSchema = createTagSchema.partial();
@@ -801,7 +1689,22 @@ export const createProjectSchema = z.object({
     description: trimmedString.default(""),
     status: projectStatusSchema.default("active"),
     targetPoints: z.number().int().min(25).max(10000).default(240),
-    themeColor: z.string().regex(/^#[0-9a-fA-F]{6}$/).default("#c0c1ff"),
+    themeColor: z
+        .string()
+        .regex(/^#[0-9a-fA-F]{6}$/)
+        .default("#c0c1ff"),
+    schedulingRules: calendarSchedulingRulesSchema.default({
+        allowWorkBlockKinds: [],
+        blockWorkBlockKinds: [],
+        allowCalendarIds: [],
+        blockCalendarIds: [],
+        allowEventTypes: [],
+        blockEventTypes: [],
+        allowEventKeywords: [],
+        blockEventKeywords: [],
+        allowAvailability: [],
+        blockAvailability: []
+    }),
     notes: z.array(nestedCreateNoteSchema).default([])
 });
 export const updateProjectSchema = createProjectSchema.partial();
@@ -817,11 +1720,84 @@ export const taskMutationShape = {
     effort: taskEffortSchema.default("deep"),
     energy: taskEnergySchema.default("steady"),
     points: z.number().int().min(5).max(500).default(40),
+    plannedDurationSeconds: z
+        .number()
+        .int()
+        .min(60)
+        .max(86_400)
+        .nullable()
+        .default(null),
+    schedulingRules: calendarSchedulingRulesSchema.nullable().default(null),
     sortOrder: z.number().int().nonnegative().optional(),
     tagIds: uniqueStringArraySchema.default([]),
     notes: z.array(nestedCreateNoteSchema).default([])
 };
 export const createTaskSchema = z.object(taskMutationShape);
+const habitMutationShape = {
+    title: nonEmptyTrimmedString,
+    description: trimmedString.default(""),
+    status: habitStatusSchema.default("active"),
+    polarity: habitPolaritySchema.default("positive"),
+    frequency: habitFrequencySchema.default("daily"),
+    targetCount: z.number().int().min(1).max(14).default(1),
+    weekDays: z.array(z.number().int().min(0).max(6)).max(7).default([]),
+    linkedGoalIds: uniqueStringArraySchema.default([]),
+    linkedProjectIds: uniqueStringArraySchema.default([]),
+    linkedTaskIds: uniqueStringArraySchema.default([]),
+    linkedValueIds: uniqueStringArraySchema.default([]),
+    linkedPatternIds: uniqueStringArraySchema.default([]),
+    linkedBehaviorIds: uniqueStringArraySchema.default([]),
+    linkedBeliefIds: uniqueStringArraySchema.default([]),
+    linkedModeIds: uniqueStringArraySchema.default([]),
+    linkedReportIds: uniqueStringArraySchema.default([]),
+    linkedBehaviorId: nonEmptyTrimmedString.nullable().default(null),
+    rewardXp: z.number().int().min(1).max(100).default(12),
+    penaltyXp: z.number().int().min(1).max(100).default(8)
+};
+export const createHabitSchema = z
+    .object(habitMutationShape)
+    .superRefine((value, context) => {
+    if (value.frequency === "weekly" && value.weekDays.length === 0) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["weekDays"],
+            message: "Select at least one weekday for weekly habits"
+        });
+    }
+});
+export const updateHabitSchema = z
+    .object({
+    title: nonEmptyTrimmedString.optional(),
+    description: trimmedString.optional(),
+    status: habitStatusSchema.optional(),
+    polarity: habitPolaritySchema.optional(),
+    frequency: habitFrequencySchema.optional(),
+    targetCount: z.number().int().min(1).max(14).optional(),
+    weekDays: z.array(z.number().int().min(0).max(6)).max(7).optional(),
+    linkedGoalIds: uniqueStringArraySchema.optional(),
+    linkedProjectIds: uniqueStringArraySchema.optional(),
+    linkedTaskIds: uniqueStringArraySchema.optional(),
+    linkedValueIds: uniqueStringArraySchema.optional(),
+    linkedPatternIds: uniqueStringArraySchema.optional(),
+    linkedBehaviorIds: uniqueStringArraySchema.optional(),
+    linkedBeliefIds: uniqueStringArraySchema.optional(),
+    linkedModeIds: uniqueStringArraySchema.optional(),
+    linkedReportIds: uniqueStringArraySchema.optional(),
+    linkedBehaviorId: nonEmptyTrimmedString.nullable().optional(),
+    rewardXp: z.number().int().min(1).max(100).optional(),
+    penaltyXp: z.number().int().min(1).max(100).optional()
+})
+    .superRefine((value, context) => {
+    if (value.frequency === "weekly" &&
+        value.weekDays !== undefined &&
+        value.weekDays.length === 0) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["weekDays"],
+            message: "Select at least one weekday for weekly habits"
+        });
+    }
+});
 export const updateTaskSchema = z.object({
     title: nonEmptyTrimmedString.optional(),
     description: trimmedString.optional(),
@@ -834,6 +1810,14 @@ export const updateTaskSchema = z.object({
     effort: taskEffortSchema.optional(),
     energy: taskEnergySchema.optional(),
     points: z.number().int().min(5).max(500).optional(),
+    plannedDurationSeconds: z
+        .number()
+        .int()
+        .min(60)
+        .max(86_400)
+        .nullable()
+        .optional(),
+    schedulingRules: calendarSchedulingRulesSchema.nullable().optional(),
     sortOrder: z.number().int().nonnegative().optional(),
     tagIds: uniqueStringArraySchema.optional(),
     notes: z.array(nestedCreateNoteSchema).optional()
@@ -844,22 +1828,33 @@ export const tagSuggestionRequestSchema = z.object({
     goalId: nonEmptyTrimmedString.nullable().default(null),
     selectedTagIds: uniqueStringArraySchema.default([])
 });
-export const taskRunClaimSchema = z.object({
+export const taskRunClaimSchema = z
+    .object({
     actor: nonEmptyTrimmedString,
     timerMode: taskTimerModeSchema.default("unlimited"),
-    plannedDurationSeconds: z.coerce.number().int().min(60).max(86_400).nullable().default(null),
+    plannedDurationSeconds: z.coerce
+        .number()
+        .int()
+        .min(60)
+        .max(86_400)
+        .nullable()
+        .default(null),
     isCurrent: z.coerce.boolean().default(true),
     leaseTtlSeconds: z.coerce.number().int().min(1).max(14400).default(900),
-    note: trimmedString.default("")
-}).superRefine((value, context) => {
-    if (value.timerMode === "planned" && value.plannedDurationSeconds === null) {
+    note: trimmedString.default(""),
+    overrideReason: trimmedString.optional()
+})
+    .superRefine((value, context) => {
+    if (value.timerMode === "planned" &&
+        value.plannedDurationSeconds === null) {
         context.addIssue({
             code: z.ZodIssueCode.custom,
             path: ["plannedDurationSeconds"],
             message: "plannedDurationSeconds is required when timerMode is planned"
         });
     }
-    if (value.timerMode === "unlimited" && value.plannedDurationSeconds !== null) {
+    if (value.timerMode === "unlimited" &&
+        value.plannedDurationSeconds !== null) {
         context.addIssue({
             code: z.ZodIssueCode.custom,
             path: ["plannedDurationSeconds"],
@@ -870,7 +1865,8 @@ export const taskRunClaimSchema = z.object({
 export const taskRunHeartbeatSchema = z.object({
     actor: nonEmptyTrimmedString.optional(),
     leaseTtlSeconds: z.coerce.number().int().min(1).max(14400).default(900),
-    note: trimmedString.optional()
+    note: trimmedString.optional(),
+    overrideReason: trimmedString.optional()
 });
 export const taskRunFinishSchema = z.object({
     actor: nonEmptyTrimmedString.optional(),
@@ -880,6 +1876,11 @@ export const taskRunFinishSchema = z.object({
 export const taskRunFocusSchema = z.object({
     actor: nonEmptyTrimmedString.optional()
 });
+export const createHabitCheckInSchema = z.object({
+    dateKey: dateOnlySchema.default(new Date().toISOString().slice(0, 10)),
+    status: habitCheckInStatusSchema,
+    note: trimmedString.default("")
+});
 export const updateSettingsSchema = z.object({
     profile: z
         .object({
@@ -895,6 +1896,17 @@ export const updateSettingsSchema = z.object({
     security: z
         .object({
         psycheAuthRequired: z.boolean().optional()
+    })
+        .optional(),
+    calendarProviders: z
+        .object({
+        microsoft: z
+            .object({
+            clientId: trimmedString.optional(),
+            tenantId: trimmedString.optional(),
+            redirectUri: trimmedString.optional()
+        })
+            .optional()
     })
         .optional()
 });
@@ -962,7 +1974,9 @@ export const resolveApprovalRequestSchema = z.object({
 export const createSessionEventSchema = z.object({
     sessionId: nonEmptyTrimmedString,
     eventType: nonEmptyTrimmedString,
-    metrics: z.record(z.string(), z.union([z.string(), z.number(), z.boolean(), z.null()])).default({})
+    metrics: z
+        .record(z.string(), z.union([z.string(), z.number(), z.boolean(), z.null()]))
+        .default({})
 });
 export const removeActivityEventSchema = z.object({
     reason: trimmedString.default("Removed from the visible archive.")
@@ -977,41 +1991,50 @@ const crudEntityLinkSchema = z.object({
 });
 export const batchCreateEntitiesSchema = z.object({
     atomic: z.boolean().default(false),
-    operations: z.array(z.object({
+    operations: z
+        .array(z.object({
         entityType: crudEntityTypeSchema,
         clientRef: trimmedString.optional(),
         data: z.record(z.string(), z.unknown())
-    })).min(1)
+    }))
+        .min(1)
 });
 export const batchUpdateEntitiesSchema = z.object({
     atomic: z.boolean().default(false),
-    operations: z.array(z.object({
+    operations: z
+        .array(z.object({
         entityType: crudEntityTypeSchema,
         id: nonEmptyTrimmedString,
         clientRef: trimmedString.optional(),
         patch: z.record(z.string(), z.unknown())
-    })).min(1)
+    }))
+        .min(1)
 });
 export const batchDeleteEntitiesSchema = z.object({
     atomic: z.boolean().default(false),
-    operations: z.array(z.object({
+    operations: z
+        .array(z.object({
         entityType: crudEntityTypeSchema,
         id: nonEmptyTrimmedString,
         clientRef: trimmedString.optional(),
         mode: deleteModeSchema.default("soft"),
         reason: trimmedString.default("")
-    })).min(1)
+    }))
+        .min(1)
 });
 export const batchRestoreEntitiesSchema = z.object({
     atomic: z.boolean().default(false),
-    operations: z.array(z.object({
+    operations: z
+        .array(z.object({
         entityType: crudEntityTypeSchema,
         id: nonEmptyTrimmedString,
         clientRef: trimmedString.optional()
-    })).min(1)
+    }))
+        .min(1)
 });
 export const batchSearchEntitiesSchema = z.object({
-    searches: z.array(z.object({
+    searches: z
+        .array(z.object({
         entityTypes: z.array(crudEntityTypeSchema).optional(),
         query: trimmedString.optional(),
         ids: uniqueStringArraySchema.optional(),
@@ -1020,7 +2043,8 @@ export const batchSearchEntitiesSchema = z.object({
         includeDeleted: z.boolean().default(false),
         limit: z.number().int().positive().max(200).default(25),
         clientRef: trimmedString.optional()
-    })).min(1)
+    }))
+        .min(1)
 });
 export const uncompleteTaskSchema = z.object({
     status: taskStatusSchema.exclude(["done"]).default("focus")