forge-openclaw-plugin 0.2.25 → 0.2.27

package/dist/server/{types.js → server/src/types.js}

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { LEGACY_WORKBENCH_PORT_KINDS, WORKBENCH_PORT_KINDS, normalizeWorkbenchPortKind } from "../../src/lib/workbench/nodes.js";
 export const taskStatusSchema = z.enum([
     "backlog",
     "focus",
@@ -33,6 +34,13 @@ 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 habitOrderBySchema = z.enum([
+    "needs_attention",
+    "name",
+    "streak",
+    "created_at",
+    "updated_at"
+]);
 export const calendarProviderSchema = z.enum([
     "google",
     "apple",
@@ -79,6 +87,35 @@ export const calendarTimeboxSourceSchema = z.enum([
     "live_run"
 ]);
 export const workAdjustmentEntityTypeSchema = z.enum(["task", "project"]);
+export const taskResolutionKindSchema = z.enum(["completed", "split"]);
+export const actionProfileModeSchema = z.enum([
+    "impulse",
+    "rate",
+    "hybrid",
+    "recovery",
+    "container"
+]);
+export const actionProfileSourceMethodSchema = z.enum([
+    "seeded",
+    "inferred",
+    "manual",
+    "learned"
+]);
+export const actionCostBandSchema = z.enum([
+    "tiny",
+    "light",
+    "standard",
+    "heavy",
+    "brutal"
+]);
+export const lifeForceStatKeySchema = z.enum([
+    "life_force",
+    "activation",
+    "focus",
+    "vigor",
+    "composure",
+    "flow"
+]);
 export const activityEntityTypeSchema = z.enum([
     "task",
     "habit",
@@ -115,7 +152,9 @@ export const activityEntityTypeSchema = z.enum([
     "calendar_event",
     "work_block",
     "work_block_template",
-    "task_timebox"
+    "task_timebox",
+    "sleep_session",
+    "workout_session"
 ]);
 export const activitySourceSchema = z.enum([
     "ui",
@@ -123,12 +162,18 @@ export const activitySourceSchema = z.enum([
     "agent",
     "system"
 ]);
-export const diagnosticLogLevelSchema = z.enum([
+export const diagnosticLogLevelSchema = z.preprocess((value) => {
+    if (typeof value !== "string") {
+        return value;
+    }
+    const normalized = value.trim().toLowerCase();
+    return normalized === "warn" ? "warning" : normalized;
+}, z.enum([
     "debug",
     "info",
     "warning",
     "error"
-]);
+]));
 export const diagnosticLogSourceSchema = z.enum([
     "ui",
     "openclaw",
@@ -210,7 +255,9 @@ export const crudEntityTypeSchema = z.enum([
     "preference_catalog_item",
     "preference_context",
     "preference_item",
-    "questionnaire_instrument"
+    "questionnaire_instrument",
+    "sleep_session",
+    "workout_session"
 ]);
 export const rewardableEntityTypeSchema = z.enum([
     "system",
@@ -447,6 +494,108 @@ export const workAdjustmentResultSchema = z.object({
     reward: z.lazy(() => rewardLedgerEventSchema).nullable(),
     metrics: z.lazy(() => xpMetricsPayloadSchema)
 });
+export const actionDemandWeightsSchema = z.object({
+    activation: z.number().min(0).max(1),
+    focus: z.number().min(0).max(1),
+    vigor: z.number().min(0).max(1),
+    composure: z.number().min(0).max(1),
+    flow: z.number().min(0).max(1)
+});
+export const actionProfileSchema = z.object({
+    id: z.string(),
+    profileKey: nonEmptyTrimmedString,
+    title: nonEmptyTrimmedString,
+    entityType: trimmedString.nullable().default(null),
+    mode: actionProfileModeSchema,
+    startupAp: z.number().min(0).default(0),
+    totalCostAp: z.number().min(0).default(0),
+    expectedDurationSeconds: z.number().int().positive().nullable().default(null),
+    sustainRateApPerHour: z.number().min(0).default(0),
+    demandWeights: actionDemandWeightsSchema,
+    doubleCountPolicy: z.enum([
+        "primary_only",
+        "secondary_weighted",
+        "always_count",
+        "container_only"
+    ]),
+    sourceMethod: actionProfileSourceMethodSchema,
+    costBand: actionCostBandSchema.default("standard"),
+    recoveryEffect: z.number().default(0),
+    metadata: z.record(z.string(), z.unknown()).default({}),
+    createdAt: z.string(),
+    updatedAt: z.string()
+});
+export const taskActionPointSummarySchema = z.object({
+    costBand: actionCostBandSchema,
+    totalCostAp: z.number().min(0),
+    expectedDurationSeconds: z.number().int().positive(),
+    sustainRateApPerHour: z.number().min(0),
+    spentTodayAp: z.number().min(0),
+    spentTotalAp: z.number().min(0),
+    remainingAp: z.number().min(0)
+});
+export const taskSplitSuggestionSchema = z.object({
+    shouldSplit: z.boolean(),
+    reason: trimmedString.nullable().default(null),
+    thresholdSeconds: z.number().int().positive()
+});
+export const lifeForceStatStateSchema = z.object({
+    key: lifeForceStatKeySchema,
+    label: nonEmptyTrimmedString,
+    level: z.number().int().min(1),
+    xp: z.number().min(0),
+    xpToNextLevel: z.number().min(0),
+    costModifier: z.number().min(0)
+});
+export const lifeForceCurvePointSchema = z.object({
+    minuteOfDay: z.number().int().min(0).max(24 * 60),
+    rateApPerHour: z.number().min(0),
+    locked: z.boolean().optional()
+});
+export const lifeForceDrainEntrySchema = z.object({
+    id: z.string(),
+    sourceType: nonEmptyTrimmedString,
+    sourceId: nonEmptyTrimmedString,
+    title: nonEmptyTrimmedString,
+    role: z.enum(["primary", "secondary", "background", "recovery"]),
+    apPerHour: z.number(),
+    instantAp: z.number(),
+    why: trimmedString.default(""),
+    startedAt: z.string().nullable().default(null),
+    endsAt: z.string().nullable().default(null)
+});
+export const lifeForceWarningSchema = z.object({
+    id: z.string(),
+    tone: z.enum(["info", "warning", "danger", "success"]),
+    title: nonEmptyTrimmedString,
+    detail: trimmedString.default("")
+});
+export const lifeForcePayloadSchema = z.object({
+    userId: z.string(),
+    dateKey: dateOnlySchema,
+    baselineDailyAp: z.number().min(0),
+    dailyBudgetAp: z.number().min(0),
+    spentTodayAp: z.number(),
+    remainingAp: z.number(),
+    forecastAp: z.number(),
+    targetBandMinAp: z.number().min(0),
+    targetBandMaxAp: z.number().min(0),
+    instantCapacityApPerHour: z.number().min(0),
+    instantFreeApPerHour: z.number(),
+    overloadApPerHour: z.number().min(0),
+    currentDrainApPerHour: z.number().min(0),
+    fatigueBufferApPerHour: z.number().min(0),
+    sleepRecoveryMultiplier: z.number().min(0),
+    readinessMultiplier: z.number().min(0),
+    fatigueDebtCarry: z.number().min(0),
+    stats: z.array(lifeForceStatStateSchema),
+    currentCurve: z.array(lifeForceCurvePointSchema),
+    activeDrains: z.array(lifeForceDrainEntrySchema),
+    warnings: z.array(lifeForceWarningSchema),
+    recommendations: z.array(trimmedString),
+    topTaskIdsNeedingSplit: z.array(z.string()),
+    updatedAt: z.string()
+});
 export const noteLinkSchema = z.object({
     entityType: crudEntityTypeSchema,
     entityId: nonEmptyTrimmedString,
@@ -558,10 +707,12 @@ export const taskSchema = z.object({
         .number()
         .int()
         .min(60)
-        .max(86_400)
+        .max(7 * 86_400)
         .nullable()
-        .default(null),
+        .default(86_400),
     schedulingRules: calendarSchedulingRulesSchema.nullable().default(null),
+    resolutionKind: taskResolutionKindSchema.nullable().default(null),
+    splitParentTaskId: z.string().nullable().default(null),
     completedAt: z.string().nullable(),
     createdAt: z.string(),
     updatedAt: z.string(),
@@ -576,6 +727,20 @@ export const taskSchema = z.object({
         activeRunCount: 0,
         hasCurrentRun: false,
         currentRunId: null
+    }),
+    actionPointSummary: taskActionPointSummarySchema.default({
+        costBand: "standard",
+        totalCostAp: 100,
+        expectedDurationSeconds: 86_400,
+        sustainRateApPerHour: 100 / 24,
+        spentTodayAp: 0,
+        spentTotalAp: 0,
+        remainingAp: 100
+    }),
+    splitSuggestion: taskSplitSuggestionSchema.default({
+        shouldSplit: false,
+        reason: null,
+        thresholdSeconds: 2 * 86_400
     })
 });
 export const taskRunSchema = z.object({
@@ -1220,6 +1385,9 @@ export const themePreferenceSchema = z.enum([
     "solar",
     "aurora",
     "ember",
+    "paper",
+    "dawn",
+    "atelier",
     "custom",
     "system"
 ]);
@@ -1249,10 +1417,29 @@ export const microsoftCalendarAuthSettingsSchema = z.object({
     isReadyForSignIn: z.boolean(),
     setupMessage: z.string()
 });
+export const googleCalendarAuthSettingsSchema = z.object({
+    clientId: z.string(),
+    clientSecret: z.string(),
+    storedClientId: z.string(),
+    storedClientSecret: z.string(),
+    appBaseUrl: z.string(),
+    redirectUri: z.string(),
+    allowedOrigins: z.array(z.string()),
+    usesPkce: z.literal(true),
+    requiresServerClientSecret: z.literal(false),
+    oauthClientType: z.literal("desktop_app"),
+    authMode: z.literal("localhost_pkce"),
+    isConfigured: z.boolean(),
+    isReadyForPairing: z.boolean(),
+    isLocalOnly: z.literal(true),
+    runtimeOrigin: z.string(),
+    setupMessage: z.string()
+});
 export const aiModelProviderSchema = z.enum([
     "openai-api",
     "openai-codex",
-    "openai-compatible"
+    "openai-compatible",
+    "mock"
 ]);
 export const aiModelAuthModeSchema = z.enum(["api_key", "oauth"]);
 export const aiModelConnectionStatusSchema = z.enum([
@@ -1414,17 +1601,59 @@ export const forgeBoxToolAdapterSchema = z.object({
     key: nonEmptyTrimmedString,
     label: nonEmptyTrimmedString,
     description: trimmedString.default(""),
-    accessMode: aiProcessorAccessModeSchema.default("read")
+    accessMode: aiProcessorAccessModeSchema.default("read"),
+    argsSchema: z.record(z.string(), z.unknown()).optional()
+});
+const workbenchPortKindSchema = z
+    .enum([...WORKBENCH_PORT_KINDS, ...LEGACY_WORKBENCH_PORT_KINDS])
+    .transform((value) => normalizeWorkbenchPortKind({ kind: value }));
+export const forgeBoxPortShapeFieldSchema = z.object({
+    key: nonEmptyTrimmedString,
+    label: nonEmptyTrimmedString,
+    kind: workbenchPortKindSchema.default("record"),
+    description: trimmedString.optional(),
+    required: z.boolean().default(false)
+});
+export const forgeBoxPortDefinitionSchema = z.object({
+    key: nonEmptyTrimmedString,
+    label: nonEmptyTrimmedString,
+    kind: workbenchPortKindSchema.default("record"),
+    description: trimmedString.optional(),
+    required: z.boolean().default(false),
+    expandableKeys: z.array(nonEmptyTrimmedString).default([]),
+    modelName: trimmedString.optional(),
+    itemKind: trimmedString.optional(),
+    shape: z.array(forgeBoxPortShapeFieldSchema).default([]),
+    exampleValue: trimmedString.optional()
+});
+export const aiConnectorPublicInputBindingSchema = z.object({
+    nodeId: nonEmptyTrimmedString,
+    targetKey: nonEmptyTrimmedString,
+    targetKind: z.enum(["input", "param"]).default("input")
+});
+export const aiConnectorPublicInputSchema = forgeBoxPortDefinitionSchema.extend({
+    defaultValue: z.unknown().optional(),
+    bindings: z.array(aiConnectorPublicInputBindingSchema).default([])
 });
 export const forgeBoxCatalogEntrySchema = z.object({
-    boxId: nonEmptyTrimmedString,
+    id: nonEmptyTrimmedString,
+    boxId: trimmedString.optional(),
     surfaceId: trimmedString.nullable(),
     routePath: trimmedString.nullable(),
-    label: nonEmptyTrimmedString,
+    title: nonEmptyTrimmedString,
+    label: trimmedString.optional(),
+    icon: trimmedString.nullable().optional(),
     description: trimmedString.default(""),
     category: nonEmptyTrimmedString,
-    capabilityModes: z.array(forgeBoxCapabilityModeSchema).default(["content"]),
-    toolAdapters: z.array(forgeBoxToolAdapterSchema).default([])
+    tags: z.array(nonEmptyTrimmedString).default([]),
+    capabilityModes: z.array(forgeBoxCapabilityModeSchema).default(["content"]).optional(),
+    inputs: z.array(forgeBoxPortDefinitionSchema).default([]),
+    params: z.array(forgeBoxPortDefinitionSchema).default([]),
+    output: z.array(forgeBoxPortDefinitionSchema).default([]),
+    tools: z.array(forgeBoxToolAdapterSchema).default([]),
+    outputs: z.array(forgeBoxPortDefinitionSchema).default([]).optional(),
+    toolAdapters: z.array(forgeBoxToolAdapterSchema).default([]).optional(),
+    snapshotResolverKey: trimmedString.optional()
 });
 export const forgeBoxSnapshotSchema = z.object({
     boxId: nonEmptyTrimmedString,
@@ -1436,11 +1665,16 @@ export const forgeBoxSnapshotSchema = z.object({
 });
 export const aiConnectorKindSchema = z.enum(["functor", "chat"]);
 export const aiConnectorNodeTypeSchema = z.enum([
+    "box",
     "box_input",
+    "value",
     "user_input",
     "functor",
     "chat",
-    "output"
+    "output",
+    "merge",
+    "template",
+    "pick_key"
 ]);
 export const aiConnectorNodeModelConfigSchema = z.object({
     connectionId: trimmedString.nullable().default(null),
@@ -1462,9 +1696,20 @@ export const aiConnectorNodeSchema = z.object({
         description: trimmedString.default(""),
         boxId: trimmedString.nullable().optional(),
         prompt: trimmedString.optional(),
+        promptTemplate: trimmedString.optional(),
         systemPrompt: trimmedString.optional(),
         outputKey: trimmedString.optional(),
         enabledToolKeys: z.array(nonEmptyTrimmedString).default([]),
+        inputs: z.array(forgeBoxPortDefinitionSchema).default([]).optional(),
+        outputs: z.array(forgeBoxPortDefinitionSchema).default([]).optional(),
+        params: z.array(forgeBoxPortDefinitionSchema).default([]).optional(),
+        paramValues: z.record(z.string(), z.unknown()).default({}).optional(),
+        template: trimmedString.optional(),
+        selectedKey: trimmedString.optional(),
+        valueType: z
+            .enum(["string", "number", "boolean", "null", "array", "object"])
+            .optional(),
+        valueLiteral: trimmedString.optional(),
         modelConfig: aiConnectorNodeModelConfigSchema.optional()
     })
 });
@@ -1488,7 +1733,55 @@ export const aiConnectorRunResultSchema = z.object({
         label: z.string(),
         text: z.string(),
         json: z.record(z.string(), z.unknown()).nullable()
+    })),
+    nodeResults: z
+        .array(z.object({
+        nodeId: nonEmptyTrimmedString,
+        nodeType: aiConnectorNodeTypeSchema,
+        label: nonEmptyTrimmedString,
+        input: z.array(z.object({
+            sourceNodeId: nonEmptyTrimmedString,
+            sourceHandle: trimmedString.nullable(),
+            targetHandle: trimmedString.nullable(),
+            text: z.string(),
+            json: z.record(z.string(), z.unknown()).nullable()
+        })),
+        primaryText: z.string(),
+        payload: z.record(z.string(), z.unknown()).nullable(),
+        outputMap: z.record(z.string(), z.object({
+            text: z.string(),
+            json: z.record(z.string(), z.unknown()).nullable()
+        })),
+        tools: z.array(z.string()).default([]),
+        logs: z.array(z.string()).default([]),
+        error: z.string().nullable(),
+        timingMs: z.number().int().nonnegative().nullable().optional()
     }))
+        .default([]),
+    debugTrace: z
+        .object({
+        nodes: z.array(z.object({
+            nodeId: nonEmptyTrimmedString,
+            nodeType: aiConnectorNodeTypeSchema,
+            label: nonEmptyTrimmedString,
+            input: z.array(z.object({
+                sourceNodeId: nonEmptyTrimmedString,
+                sourceHandle: trimmedString.nullable(),
+                targetHandle: trimmedString.nullable(),
+                text: z.string(),
+                json: z.record(z.string(), z.unknown()).nullable()
+            })),
+            output: z.object({
+                text: z.string(),
+                json: z.record(z.string(), z.unknown()).nullable()
+            }),
+            tools: z.array(z.string()).default([]),
+            logs: z.array(z.string()).default([]),
+            error: z.string().nullable()
+        })),
+        errors: z.array(z.string()).default([])
+    })
+        .optional()
 });
 export const aiConnectorRunSchema = z.object({
     id: nonEmptyTrimmedString,
@@ -1496,6 +1789,7 @@ export const aiConnectorRunSchema = z.object({
     mode: z.enum(["run", "chat"]),
     status: z.enum(["running", "completed", "failed"]),
     userInput: z.string(),
+    inputs: z.record(z.string(), z.unknown()).default({}),
     context: z.record(z.string(), z.unknown()).default({}),
     conversationId: trimmedString.nullable(),
     result: aiConnectorRunResultSchema.nullable(),
@@ -1528,6 +1822,7 @@ export const aiConnectorSchema = z.object({
         nodes: z.array(aiConnectorNodeSchema).default([]),
         edges: z.array(aiConnectorEdgeSchema).default([])
     }),
+    publicInputs: z.array(aiConnectorPublicInputSchema).default([]),
     publishedOutputs: z.array(aiConnectorOutputSchema).default([]),
     lastRun: aiConnectorRunSchema.nullable(),
     legacyProcessorId: trimmedString.nullable().default(null),
@@ -1792,6 +2087,7 @@ export const settingsPayloadSchema = z.object({
         psycheAuthRequired: z.boolean()
     }),
     calendarProviders: z.object({
+        google: googleCalendarAuthSettingsSchema,
         microsoft: microsoftCalendarAuthSettingsSchema
     }),
     modelSettings: modelSettingsPayloadSchema,
@@ -1982,6 +2278,8 @@ export const activityListQuerySchema = z.object({
     entityType: activityEntityTypeSchema.optional(),
     entityId: nonEmptyTrimmedString.optional(),
     source: activitySourceSchema.optional(),
+    from: flexibleCalendarQueryDateSchema.optional(),
+    to: flexibleCalendarQueryDateSchema.optional(),
     includeCorrected: z.coerce.boolean().optional(),
     userIds: repeatedTrimmedStringQuerySchema.optional(),
     limit: z.coerce.number().int().positive().max(100).optional()
@@ -2004,14 +2302,28 @@ export const calendarOverviewQuerySchema = z.object({
     to: flexibleCalendarQueryDateSchema.optional(),
     userIds: repeatedTrimmedStringQuerySchema.optional()
 });
+export const psycheObservationCalendarExportFormatSchema = z.enum([
+    "json",
+    "csv",
+    "markdown",
+    "ics"
+]);
+export const psycheObservationCalendarExportQuerySchema = z.object({
+    from: flexibleCalendarQueryDateSchema.optional(),
+    to: flexibleCalendarQueryDateSchema.optional(),
+    userIds: repeatedTrimmedStringQuerySchema.optional(),
+    tags: repeatedTrimmedStringQuerySchema.optional(),
+    includeObservations: z.coerce.boolean().optional(),
+    includeActivity: z.coerce.boolean().optional(),
+    onlyHumanOwned: z.coerce.boolean().optional(),
+    search: trimmedString.optional(),
+    format: psycheObservationCalendarExportFormatSchema.default("markdown")
+});
 export const createCalendarConnectionSchema = z.discriminatedUnion("provider", [
     z.object({
         provider: z.literal("google"),
         label: nonEmptyTrimmedString,
-        username: nonEmptyTrimmedString,
-        clientId: nonEmptyTrimmedString,
-        clientSecret: nonEmptyTrimmedString,
-        refreshToken: nonEmptyTrimmedString,
+        authSessionId: nonEmptyTrimmedString,
         selectedCalendarUrls: z.array(nonEmptyTrimmedString.url()).min(1),
         forgeCalendarUrl: nonEmptyTrimmedString.url().nullable().optional(),
         createForgeCalendar: z.boolean().optional().default(false)
@@ -2043,13 +2355,6 @@ export const createCalendarConnectionSchema = z.discriminatedUnion("provider", [
     })
 ]);
 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,
@@ -2065,6 +2370,10 @@ export const discoverCalendarConnectionSchema = z.discriminatedUnion("provider",
 export const startMicrosoftCalendarOauthSchema = z.object({
     label: nonEmptyTrimmedString.optional()
 });
+export const startGoogleCalendarOauthSchema = z.object({
+    label: nonEmptyTrimmedString.optional(),
+    browserOrigin: trimmedString.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"),
@@ -2078,6 +2387,14 @@ export const microsoftCalendarOauthSessionSchema = z.object({
     error: z.string().nullable(),
     discovery: calendarDiscoveryPayloadSchema.nullable()
 });
+export const googleCalendarOauthSessionSchema = 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()
@@ -2288,6 +2605,7 @@ export const habitListQuerySchema = z.object({
     status: habitStatusSchema.optional(),
     polarity: habitPolaritySchema.optional(),
     dueToday: z.coerce.boolean().optional(),
+    orderBy: habitOrderBySchema.optional(),
     userIds: repeatedTrimmedStringQuerySchema.optional(),
     limit: z.coerce.number().int().positive().max(100).optional()
 });
@@ -2360,12 +2678,13 @@ export const taskMutationShape = {
         .number()
         .int()
         .min(60)
-        .max(86_400)
+        .max(7 * 86_400)
         .nullable()
-        .default(null),
+        .default(86_400),
     schedulingRules: calendarSchedulingRulesSchema.nullable().default(null),
     sortOrder: z.number().int().nonnegative().optional(),
     tagIds: uniqueStringArraySchema.default([]),
+    actionCostBand: actionCostBandSchema.default("standard"),
     notes: z.array(nestedCreateNoteSchema).default([])
 };
 export const createTaskSchema = z.object(taskMutationShape);
@@ -2508,14 +2827,44 @@ export const updateTaskSchema = z.object({
         .number()
         .int()
         .min(60)
-        .max(86_400)
+        .max(7 * 86_400)
         .nullable()
         .optional(),
     schedulingRules: calendarSchedulingRulesSchema.nullable().optional(),
+    resolutionKind: taskResolutionKindSchema.nullable().optional(),
+    splitParentTaskId: z.string().nullable().optional(),
+    enforceTodayWorkLog: z.boolean().optional(),
+    completedTodayWorkSeconds: z
+        .number()
+        .int()
+        .min(0)
+        .max(7 * 86_400)
+        .optional(),
+    actionCostBand: actionCostBandSchema.optional(),
     sortOrder: z.number().int().nonnegative().optional(),
     tagIds: uniqueStringArraySchema.optional(),
     notes: z.array(nestedCreateNoteSchema).optional()
 });
+export const lifeForceProfilePatchSchema = z.object({
+    baseDailyAp: z.number().int().min(50).max(500).optional(),
+    readinessMultiplier: z.number().min(0.5).max(1.5).optional(),
+    stats: z
+        .record(lifeForceStatKeySchema, z.number().int().min(1).max(100))
+        .optional()
+});
+export const lifeForceTemplateUpdateSchema = z.object({
+    points: z.array(lifeForceCurvePointSchema).min(2)
+});
+export const fatigueSignalCreateSchema = z.object({
+    signalType: z.enum(["tired", "okay_again"]),
+    observedAt: dateTimeSchema.optional(),
+    note: trimmedString.optional()
+});
+export const taskSplitCreateSchema = z.object({
+    firstTitle: nonEmptyTrimmedString,
+    secondTitle: nonEmptyTrimmedString,
+    remainingRatio: z.number().min(0.1).max(0.9).default(0.5)
+});
 export const tagSuggestionRequestSchema = z.object({
     title: trimmedString.default(""),
     description: trimmedString.default(""),
@@ -2595,6 +2944,12 @@ export const updateSettingsSchema = z.object({
         .optional(),
     calendarProviders: z
         .object({
+        google: z
+            .object({
+            clientId: trimmedString.optional(),
+            clientSecret: trimmedString.optional()
+        })
+            .optional(),
         microsoft: z
             .object({
             clientId: trimmedString.optional(),
@@ -2603,7 +2958,37 @@ export const updateSettingsSchema = z.object({
         })
             .optional()
     })
-        .optional(),
+        .optional()
+        .superRefine((value, context) => {
+        if (!value) {
+            return;
+        }
+        const google = value.google;
+        if (!google) {
+            return;
+        }
+        const hasClientIdField = google.clientId !== undefined;
+        const hasClientSecretField = google.clientSecret !== undefined;
+        const hasClientIdValue = (google.clientId?.length ?? 0) > 0;
+        const hasClientSecretValue = (google.clientSecret?.length ?? 0) > 0;
+        if (hasClientIdField !== hasClientSecretField) {
+            const message = "When overriding Google OAuth credentials, provide both the client ID and client secret together, or clear both fields together.";
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["google", hasClientIdField ? "clientSecret" : "clientId"],
+                message
+            });
+            return;
+        }
+        if (hasClientIdValue !== hasClientSecretValue) {
+            const message = "When overriding Google OAuth credentials, provide both the client ID and client secret together, or clear both fields together.";
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["google", hasClientIdValue ? "clientSecret" : "clientId"],
+                message
+            });
+        }
+    }),
     modelSettings: z
         .object({
         forgeAgent: z
@@ -2640,6 +3025,7 @@ export const upsertAiModelConnectionSchema = z
     .superRefine((value, context) => {
     const authMode = value.authMode ??
         (value.provider === "openai-codex" ? "oauth" : "api_key");
+    const isMockProvider = value.provider === "mock";
     if (value.provider === "openai-codex" && authMode !== "oauth") {
         context.addIssue({
             code: z.ZodIssueCode.custom,
@@ -2648,6 +3034,7 @@ export const upsertAiModelConnectionSchema = z
         });
     }
     if (authMode === "api_key" &&
+        !isMockProvider &&
         !value.id?.trim() &&
         !value.apiKey?.trim()) {
         context.addIssue({
@@ -2724,6 +3111,7 @@ export const createAiConnectorSchema = z.object({
     kind: aiConnectorKindSchema.default("functor"),
     homeSurfaceId: trimmedString.nullable().default(null),
     endpointEnabled: z.boolean().default(true),
+    publicInputs: z.array(aiConnectorPublicInputSchema).default([]),
     graph: z
         .object({
         nodes: z.array(aiConnectorNodeSchema).default([]),
@@ -2737,6 +3125,7 @@ export const updateAiConnectorSchema = z.object({
     kind: aiConnectorKindSchema.optional(),
     homeSurfaceId: trimmedString.nullable().optional(),
     endpointEnabled: z.boolean().optional(),
+    publicInputs: z.array(aiConnectorPublicInputSchema).optional(),
     graph: z
         .object({
         nodes: z.array(aiConnectorNodeSchema).default([]),
@@ -2746,9 +3135,11 @@ export const updateAiConnectorSchema = z.object({
 });
 export const runAiConnectorSchema = z.object({
     userInput: trimmedString.default(""),
+    inputs: z.record(z.string(), z.unknown()).default({}),
     context: z.record(z.string(), z.unknown()).default({}),
     boxSnapshots: z.record(z.string(), z.unknown()).default({}),
-    conversationId: trimmedString.nullable().default(null)
+    conversationId: trimmedString.nullable().default(null),
+    debug: z.boolean().default(false)
 });
 export const createAgentTokenSchema = z.object({
     label: nonEmptyTrimmedString,