@tablestore/tablestore-agent-cli 0.2.11 → 0.4.0

package/dist/dashboard-runtime/dashboard/src/components/memory/memory-dream-create-dialog.tsx

@@ -6,9 +6,10 @@ import { useForm, useFieldArray } from "react-hook-form";
 import { zodResolver } from "@hookform/resolvers/zod";
 import { z } from "zod";
 import { toast } from "sonner";
-import { Plus, Trash2 } from "lucide-react";
+import { HelpCircle, Plus, Trash2 } from "lucide-react";
 
 import { Button } from "@/components/ui/button";
+import { Checkbox } from "@/components/ui/checkbox";
 import {
   Dialog,
   DialogContent,
@@ -20,6 +21,12 @@ import {
 import { Input } from "@/components/ui/input";
 import { Label } from "@/components/ui/label";
 import { Textarea } from "@/components/ui/textarea";
+import {
+  Tooltip,
+  TooltipContent,
+  TooltipProvider,
+  TooltipTrigger,
+} from "@/components/ui/tooltip";
 import {
   Select,
   SelectContent,
@@ -35,6 +42,7 @@ import {
 import {
   Form,
   FormControl,
+  FormDescription,
   FormField,
   FormItem,
   FormLabel,
@@ -43,8 +51,21 @@ import {
 import { useCreateDreamTask } from "@/hooks/use-create-dream-task";
 import { ScopeCombobox } from "@/components/memory/scope-combobox";
 import { useI18n } from "@/i18n/i18n-context";
-import type { TranslateFn } from "@/i18n/i18n-context";
-import type { DreamTaskType, MemoryScope } from "@/types/memory";
+import type { MessageKey, TranslateFn } from "@/i18n/i18n-context";
+import {
+  DREAM_APPLICATION_MODES,
+  dreamModeForcedEffort,
+  normalizeDreamMode,
+} from "@/lib/dream-create-options";
+import { cn } from "@/lib/utils";
+import type {
+  CreateDreamTaskRequest,
+  DreamApplyMode,
+  DreamEffort,
+  DreamScopeOutputMode,
+  DreamTaskType,
+  MemoryScope,
+} from "@/types/memory";
 
 interface DreamCreateDialogProps {
   memoryStoreName: string;
@@ -59,10 +80,14 @@ interface DreamSchemaMessages {
   atLeastOneNonWildcard: string;
   atLeastOneScope: string;
   scopesLimit: string;
+  highEffortScopesLimit: string;
+  effortCombination: string;
+  taskTypeExactScope: string;
   instructionsLimit: string;
   maxSessionsRange: string;
   maxMessagesRange: string;
   maxMemoriesRange: string;
+  expandedScopeLimitRange: string;
   thresholdRange: string;
   timestampInvalid: string;
   timestampOrder: string;
@@ -73,10 +98,14 @@ const DEFAULT_SCHEMA_MESSAGES: DreamSchemaMessages = {
   atLeastOneNonWildcard: "至少指定一个非通配符字段",
   atLeastOneScope: "至少一个 scope",
   scopesLimit: "scope 最多 20 个",
+  highEffortScopesLimit: "高 effort Dream scope 最多 8 个",
+  effortCombination: "effort 与应用模式组合无效",
+  taskTypeExactScope: "技能与画像任务必须且只能使用一个无通配符的精确 scope",
   instructionsLimit: "指令不能超过 4000 字节（UTF-8）",
-  maxSessionsRange: "最大会话数必须是 1 到 100 之间的整数",
-  maxMessagesRange: "最大消息数必须是 1 到 20000 之间的整数",
-  maxMemoriesRange: "最大记忆数必须是 1 到 5000 之间的整数",
+  maxSessionsRange: "最大会话数必须是 0 到 100 之间的整数",
+  maxMessagesRange: "最大消息数必须是 0 到 20000 之间的整数",
+  maxMemoriesRange: "最大记忆数必须是 0 到 5000 之间的整数",
+  expandedScopeLimitRange: "展开 scope 上限必须是 0 到 1000 之间的整数",
   thresholdRange: "置信度阈值必须在 0 到 1 之间",
   timestampInvalid: "时间格式不正确",
   timestampOrder: "最晚时间不能早于最早时间",
@@ -104,7 +133,7 @@ function optionalIntegerString(max: number, message: string) {
     .superRefine((value, ctx) => {
       if (!value) return;
       const parsed = Number(value);
-      if (!Number.isInteger(parsed) || parsed < 1 || parsed > max) {
+      if (!Number.isInteger(parsed) || parsed < 0 || parsed > max) {
         ctx.addIssue({ code: z.ZodIssueCode.custom, message });
       }
     });
@@ -142,17 +171,23 @@ function createDreamFormSchema(messages: DreamSchemaMessages) {
   return z
     .object({
       taskType: z.enum(["memory", "skill", "profile"]),
+      effort: z.enum(["low", "high"]),
       scopes: z
         .array(scopeSchema)
         .min(1, messages.atLeastOneScope)
         .max(20, messages.scopesLimit),
-      applyMode: z.enum(["proposal", "safe_auto"]),
+      applyMode: z.enum(["proposal", "safe_auto", "plan"]).optional(),
+      incremental: z.boolean().optional(),
       scopeOutputMode: z.enum(["preserve_scope", "promote_scope"]).optional(),
       minTimestamp: optionalTimestampString(messages.timestampInvalid),
       maxTimestamp: optionalTimestampString(messages.timestampInvalid),
       maxSessions: optionalIntegerString(100, messages.maxSessionsRange),
       maxMessages: optionalIntegerString(20_000, messages.maxMessagesRange),
       maxMemories: optionalIntegerString(5_000, messages.maxMemoriesRange),
+      expandedScopeLimit: optionalIntegerString(
+        1_000,
+        messages.expandedScopeLimitRange,
+      ),
       instructions: z
         .string()
         .optional()
@@ -170,18 +205,73 @@ function createDreamFormSchema(messages: DreamSchemaMessages) {
       thresholdMerge: optionalThresholdString(messages.thresholdRange),
     })
     .superRefine((values, ctx) => {
-      if (!values.minTimestamp || !values.maxTimestamp) return;
-      const minTimestamp = Date.parse(values.minTimestamp);
-      const maxTimestamp = Date.parse(values.maxTimestamp);
-      if (
-        Number.isFinite(minTimestamp) &&
-        Number.isFinite(maxTimestamp) &&
-        maxTimestamp < minTimestamp
-      ) {
+      if (values.minTimestamp && values.maxTimestamp) {
+        const minTimestamp = Date.parse(values.minTimestamp);
+        const maxTimestamp = Date.parse(values.maxTimestamp);
+        if (
+          Number.isFinite(minTimestamp) &&
+          Number.isFinite(maxTimestamp) &&
+          maxTimestamp < minTimestamp
+        ) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: messages.timestampOrder,
+            path: ["maxTimestamp"],
+          });
+        }
+      }
+
+      if (values.taskType !== "memory") {
+        if (
+          values.effort === "high" &&
+          (values.scopes.length !== 1 ||
+            values.scopes.some((scope) =>
+              [scope.appId, scope.tenantId, scope.agentId, scope.runId].some(
+                (segment) => !segment || segment === "*",
+              ),
+            ))
+        ) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: messages.taskTypeExactScope,
+            path: ["scopes"],
+          });
+        }
+        if (values.applyMode !== undefined) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: messages.effortCombination,
+            path: ["applyMode"],
+          });
+        }
+        return;
+      }
+
+      if (values.applyMode === undefined) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: messages.effortCombination,
+          path: ["applyMode"],
+        });
+      } else if (values.effort === "low" && values.applyMode === "plan") {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: messages.effortCombination,
+          path: ["applyMode"],
+        });
+      } else if (values.effort === "high" && values.applyMode === "proposal") {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: messages.effortCombination,
+          path: ["applyMode"],
+        });
+      }
+
+      if (values.effort === "high" && values.scopes.length > 8) {
         ctx.addIssue({
           code: z.ZodIssueCode.custom,
-          message: messages.timestampOrder,
-          path: ["maxTimestamp"],
+          message: messages.highEffortScopesLimit,
+          path: ["scopes"],
         });
       }
     });
@@ -198,22 +288,230 @@ function buildFormSchema(t: TranslateFn) {
     atLeastOneNonWildcard: t("memory.dream.atLeastOneNonWildcard"),
     atLeastOneScope: t("memory.dream.atLeastOneScope"),
     scopesLimit: t("memory.dream.scopesLimit"),
+    highEffortScopesLimit: t("memory.dream.highEffortScopesLimit"),
+    effortCombination: t("memory.dream.effortCombination"),
+    taskTypeExactScope: t("memory.dream.taskTypeExactScope"),
     instructionsLimit: t("memory.dream.instructionsLimit"),
     maxSessionsRange: t("memory.dream.maxSessionsRange"),
     maxMessagesRange: t("memory.dream.maxMessagesRange"),
     maxMemoriesRange: t("memory.dream.maxMemoriesRange"),
+    expandedScopeLimitRange: t("memory.dream.expandedScopeLimitRange"),
     thresholdRange: t("memory.dream.thresholdRange"),
     timestampInvalid: t("memory.dream.timestampInvalid"),
     timestampOrder: t("memory.dream.timestampOrder"),
   });
 }
 
-type FormValues = z.infer<typeof dreamCreateFormSchema>;
+export type DreamCreateFormValues = z.infer<typeof dreamCreateFormSchema>;
+type FormValues = DreamCreateFormValues;
+
+const DREAM_EFFORTS = ["low", "high"] as const;
+
+export function dreamEffortOptions(
+  _taskType: DreamTaskType,
+): readonly (typeof DREAM_EFFORTS)[number][] {
+  return DREAM_EFFORTS;
+}
+
+export function normalizeTaskTypeChange(
+  taskType: DreamTaskType,
+  current: Pick<DreamCreateFormValues, "effort" | "applyMode" | "scopes"> &
+    Partial<
+      Pick<
+        DreamCreateFormValues,
+        | "scopeOutputMode"
+        | "thresholdAdd"
+        | "thresholdUpdate"
+        | "thresholdMerge"
+      >
+    >,
+) {
+  if (taskType === "memory") {
+    return {
+      ...current,
+      applyMode:
+        current.applyMode ??
+        (current.effort === "high" ? "safe_auto" : "proposal"),
+      scopeOutputMode: current.scopeOutputMode ?? "preserve_scope",
+    };
+  }
+  return {
+    ...current,
+    applyMode: undefined,
+    scopeOutputMode: undefined,
+    thresholdAdd: undefined,
+    thresholdUpdate: undefined,
+    thresholdMerge: undefined,
+    scopes:
+      current.effort === "high" ? current.scopes.slice(0, 1) : current.scopes,
+  };
+}
+
+const APPLICATION_MODE_KEYS: Record<
+  DreamApplyMode,
+  { title: MessageKey; summary: MessageKey; help: MessageKey }
+> = {
+  proposal: {
+    title: "memory.dream.applyModeRequestApproval",
+    summary: "memory.dream.applyModeRequestApprovalSummary",
+    help: "memory.dream.applyModeRequestApprovalHelp",
+  },
+  safe_auto: {
+    title: "memory.dream.applyModeHelpMeApprove",
+    summary: "memory.dream.applyModeHelpMeApproveSummary",
+    help: "memory.dream.applyModeHelpMeApproveHelp",
+  },
+  plan: {
+    title: "memory.dream.applyModePlanMode",
+    summary: "memory.dream.applyModePlanModeSummary",
+    help: "memory.dream.applyModePlanModeHelp",
+  },
+};
+
+export function DreamApplicationModeCards({
+  value,
+  effort,
+  onChange,
+  t,
+}: {
+  value: DreamApplyMode;
+  effort: DreamEffort;
+  onChange: (value: DreamApplyMode, effort: DreamEffort) => void;
+  t: TranslateFn;
+}) {
+  return (
+    <TooltipProvider delayDuration={150}>
+      <div
+        className="grid gap-2 sm:grid-cols-3"
+        role="radiogroup"
+        aria-label={t("memory.dream.applyMode")}
+      >
+        {DREAM_APPLICATION_MODES.map((mode) => {
+          const keys = APPLICATION_MODE_KEYS[mode.value];
+          const selected = value === mode.value;
+          return (
+            <div
+              key={mode.value}
+              className={cn(
+                "flex min-h-28 rounded-lg border bg-card transition-colors",
+                selected
+                  ? "border-primary bg-primary-soft ring-1 ring-primary/20"
+                  : "border-border hover:border-primary/40 hover:bg-muted/30",
+              )}
+            >
+              <button
+                type="button"
+                role="radio"
+                aria-checked={selected}
+                className="min-w-0 flex-1 rounded-l-lg p-3 text-left focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-primary"
+                onClick={() => {
+                  const normalized = normalizeDreamMode(mode.value, effort);
+                  onChange(normalized.applyMode, normalized.effort);
+                }}
+              >
+                <span className="block text-sm font-semibold">
+                  {t(keys.title)}
+                </span>
+                <span className="mt-1 block text-xs leading-5 text-muted-foreground">
+                  {t(keys.summary)}
+                </span>
+              </button>
+              <Tooltip>
+                <TooltipTrigger asChild>
+                  <button
+                    type="button"
+                    className="m-2 h-7 w-7 shrink-0 rounded-full text-muted-foreground hover:bg-muted hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-primary"
+                    aria-label={t("memory.dream.applyModeHelpLabel", {
+                      mode: t(keys.title),
+                    })}
+                  >
+                    <HelpCircle className="mx-auto h-4 w-4" />
+                  </button>
+                </TooltipTrigger>
+                <TooltipContent className="max-w-72 leading-5" side="top">
+                  {t(keys.help)}
+                </TooltipContent>
+              </Tooltip>
+            </div>
+          );
+        })}
+      </div>
+    </TooltipProvider>
+  );
+}
+
+const OUTPUT_LOCATIONS: ReadonlyArray<{
+  value: DreamScopeOutputMode;
+  title: MessageKey;
+  summary: MessageKey;
+}> = [
+  {
+    value: "preserve_scope",
+    title: "memory.dream.preserveScope",
+    summary: "memory.dream.preserveScopeSummary",
+  },
+  {
+    value: "promote_scope",
+    title: "memory.dream.promoteScope",
+    summary: "memory.dream.promoteScopeSummary",
+  },
+];
+
+export function DreamOutputLocationCards({
+  value,
+  onChange,
+  t,
+}: {
+  value: DreamScopeOutputMode;
+  onChange: (value: DreamScopeOutputMode) => void;
+  t: TranslateFn;
+}) {
+  return (
+    <div className="space-y-2">
+      <div
+        className="grid gap-2 sm:grid-cols-2"
+        role="radiogroup"
+        aria-label={t("memory.dream.scopeOutputMode")}
+      >
+        {OUTPUT_LOCATIONS.map((option) => {
+          const selected = value === option.value;
+          return (
+            <button
+              key={option.value}
+              type="button"
+              role="radio"
+              aria-checked={selected}
+              className={cn(
+                "rounded-lg border p-3 text-left transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-primary",
+                selected
+                  ? "border-primary bg-primary-soft ring-1 ring-primary/20"
+                  : "border-border hover:border-primary/40 hover:bg-muted/30",
+              )}
+              onClick={() => onChange(option.value)}
+            >
+              <span className="block text-sm font-semibold">
+                {t(option.title)}
+              </span>
+              <span className="mt-1 block text-xs leading-5 text-muted-foreground">
+                {t(option.summary)}
+              </span>
+            </button>
+          );
+        })}
+      </div>
+      {value === "promote_scope" ? (
+        <p className="rounded-md bg-muted/40 px-3 py-2 text-xs text-muted-foreground">
+          {t("memory.dream.promoteScopeHint")}
+        </p>
+      ) : null}
+    </div>
+  );
+}
 
 function parseOptionalInt(raw: string | undefined): number | undefined {
-  if (!raw) return undefined;
+  if (raw === undefined || raw.trim() === "") return undefined;
   const n = Number(raw);
-  if (!Number.isFinite(n) || !Number.isInteger(n) || n <= 0) return undefined;
+  if (!Number.isFinite(n) || !Number.isInteger(n) || n < 0) return undefined;
   return n;
 }
 
@@ -224,6 +522,61 @@ function parseOptionalThreshold(raw: string | undefined): number | undefined {
   return n;
 }
 
+export function buildDreamCreateRequest(
+  values: DreamCreateFormValues,
+): CreateDreamTaskRequest {
+  const thresholds: Record<string, number> = {};
+  const thresholdAdd = parseOptionalThreshold(values.thresholdAdd);
+  const thresholdUpdate = parseOptionalThreshold(values.thresholdUpdate);
+  const thresholdMerge = parseOptionalThreshold(values.thresholdMerge);
+  if (thresholdAdd !== undefined) thresholds.add = thresholdAdd;
+  if (thresholdUpdate !== undefined) thresholds.update = thresholdUpdate;
+  if (thresholdMerge !== undefined) thresholds.merge = thresholdMerge;
+
+  const isMemory = values.taskType === "memory";
+  return {
+    scopes: values.scopes.map((scope) => {
+      const result: MemoryScope = { appId: scope.appId };
+      if (scope.tenantId) result.tenantId = scope.tenantId;
+      if (scope.agentId) result.agentId = scope.agentId;
+      if (scope.runId) result.runId = scope.runId;
+      return result;
+    }),
+    taskType: values.taskType,
+    effort: values.effort,
+    incremental: Boolean(values.incremental),
+    ...(isMemory && values.applyMode && { applyMode: values.applyMode }),
+    ...(isMemory &&
+      values.scopeOutputMode && {
+        scopeOutputMode: values.scopeOutputMode,
+      }),
+    ...(values.minTimestamp && {
+      minTimestamp: Date.parse(values.minTimestamp),
+    }),
+    ...(values.maxTimestamp && {
+      maxTimestamp: Date.parse(values.maxTimestamp),
+    }),
+    ...(parseOptionalInt(values.maxSessions) !== undefined && {
+      maxSessions: parseOptionalInt(values.maxSessions),
+    }),
+    ...(parseOptionalInt(values.maxMessages) !== undefined && {
+      maxMessages: parseOptionalInt(values.maxMessages),
+    }),
+    ...(parseOptionalInt(values.maxMemories) !== undefined && {
+      maxMemories: parseOptionalInt(values.maxMemories),
+    }),
+    ...(parseOptionalInt(values.expandedScopeLimit) !== undefined && {
+      expandedScopeLimit: parseOptionalInt(values.expandedScopeLimit),
+    }),
+    ...(values.instructions && { instructions: values.instructions }),
+    ...(values.clientToken && { clientToken: values.clientToken }),
+    ...(isMemory &&
+      Object.keys(thresholds).length > 0 && {
+        confidenceThresholds: thresholds,
+      }),
+  };
+}
+
 export function MemoryDreamCreateDialog(props: DreamCreateDialogProps) {
   const { locale } = useI18n();
   return <MemoryDreamCreateDialogInner key={locale} {...props} />;
@@ -265,7 +618,10 @@ function MemoryDreamCreateDialogInner({
               : "",
         },
       ],
+      effort: "low",
       applyMode: "proposal",
+      scopeOutputMode: "preserve_scope",
+      incremental: false,
     },
   });
 
@@ -275,55 +631,19 @@ function MemoryDreamCreateDialogInner({
   });
 
   const taskType = form.watch("taskType");
+  const effort = form.watch("effort");
+  const applyMode = form.watch("applyMode") ?? "proposal";
+  const forcedEffort = dreamModeForcedEffort(applyMode);
   const isMemoryType = taskType === "memory";
 
   const [advancedOpen, setAdvancedOpen] = useState(false);
   const [thresholdsOpen, setThresholdsOpen] = useState(false);
 
   const onSubmit = async (values: FormValues) => {
-    const thresholds: Record<string, number> = {};
-    const tAdd = parseOptionalThreshold(values.thresholdAdd);
-    const tUpdate = parseOptionalThreshold(values.thresholdUpdate);
-    const tMerge = parseOptionalThreshold(values.thresholdMerge);
-    if (tAdd !== undefined) thresholds.add = tAdd;
-    if (tUpdate !== undefined) thresholds.update = tUpdate;
-    if (tMerge !== undefined) thresholds.merge = tMerge;
-
-    const isMemory = values.taskType === "memory";
-
     try {
-      const result = await createMutation.mutateAsync({
-        scopes: values.scopes.map((s) => {
-          const out: MemoryScope = { appId: s.appId };
-          if (s.tenantId) out.tenantId = s.tenantId;
-          if (s.agentId) out.agentId = s.agentId;
-          if (s.runId) out.runId = s.runId;
-          return out;
-        }),
-        taskType: values.taskType,
-        ...(isMemory && { applyMode: values.applyMode }),
-        ...(isMemory &&
-          values.scopeOutputMode && {
-            scopeOutputMode: values.scopeOutputMode,
-          }),
-        ...(values.minTimestamp && { minTimestamp: values.minTimestamp }),
-        ...(values.maxTimestamp && { maxTimestamp: values.maxTimestamp }),
-        ...(parseOptionalInt(values.maxSessions) !== undefined && {
-          maxSessions: parseOptionalInt(values.maxSessions),
-        }),
-        ...(parseOptionalInt(values.maxMessages) !== undefined && {
-          maxMessages: parseOptionalInt(values.maxMessages),
-        }),
-        ...(parseOptionalInt(values.maxMemories) !== undefined && {
-          maxMemories: parseOptionalInt(values.maxMemories),
-        }),
-        ...(values.instructions && { instructions: values.instructions }),
-        ...(values.clientToken && { clientToken: values.clientToken }),
-        ...(isMemory &&
-          Object.keys(thresholds).length > 0 && {
-            confidenceThresholds: thresholds,
-          }),
-      });
+      const result = await createMutation.mutateAsync(
+        buildDreamCreateRequest(values),
+      );
 
       const TOAST_MSG: Record<DreamTaskType, string> = {
         memory: t("memory.dream.toastMemoryCreated"),
@@ -362,8 +682,29 @@ function MemoryDreamCreateDialogInner({
                 <FormItem>
                   <FormLabel>{t("memory.dream.taskType")}</FormLabel>
                   <Select
-                    onValueChange={field.onChange}
-                    defaultValue={field.value}
+                    onValueChange={(value) => {
+                      field.onChange(value);
+                      const next = normalizeTaskTypeChange(
+                        value as DreamTaskType,
+                        {
+                          effort: form.getValues("effort"),
+                          applyMode: form.getValues("applyMode"),
+                          scopeOutputMode: form.getValues("scopeOutputMode"),
+                          thresholdAdd: form.getValues("thresholdAdd"),
+                          thresholdUpdate: form.getValues("thresholdUpdate"),
+                          thresholdMerge: form.getValues("thresholdMerge"),
+                          scopes: form.getValues("scopes"),
+                        },
+                      );
+                      form.setValue("effort", next.effort);
+                      form.setValue("applyMode", next.applyMode);
+                      form.setValue("scopeOutputMode", next.scopeOutputMode);
+                      form.setValue("thresholdAdd", next.thresholdAdd);
+                      form.setValue("thresholdUpdate", next.thresholdUpdate);
+                      form.setValue("thresholdMerge", next.thresholdMerge);
+                      form.setValue("scopes", next.scopes);
+                    }}
+                    value={field.value}
                   >
                     <FormControl>
                       <SelectTrigger>
@@ -392,17 +733,24 @@ function MemoryDreamCreateDialogInner({
                 <Label className="text-sm font-medium">
                   {t("memory.common.scopeRange")}
                 </Label>
-                <Button
-                  type="button"
-                  size="sm"
-                  variant="ghost"
-                  onClick={() =>
-                    append({ appId: "", tenantId: "", agentId: "", runId: "" })
-                  }
-                >
-                  <Plus className="mr-1 h-3.5 w-3.5" />
-                  {t("memory.dream.addScope")}
-                </Button>
+                {(isMemoryType || effort === "low") && (
+                  <Button
+                    type="button"
+                    size="sm"
+                    variant="ghost"
+                    onClick={() =>
+                      append({
+                        appId: "",
+                        tenantId: "",
+                        agentId: "",
+                        runId: "",
+                      })
+                    }
+                  >
+                    <Plus className="mr-1 h-3.5 w-3.5" />
+                    {t("memory.dream.addScope")}
+                  </Button>
+                )}
               </div>
               <div className="space-y-3">
                 {fields.map((field, index) => (
@@ -468,70 +816,97 @@ function MemoryDreamCreateDialogInner({
               </div>
             </section>
 
-            {isMemoryType && (
-              <section className="grid gap-3 sm:grid-cols-2">
-                <FormField
-                  control={form.control}
-                  name="applyMode"
-                  render={({ field }) => (
-                    <FormItem>
-                      <FormLabel>{t("memory.dream.applyMode")}</FormLabel>
-                      <Select
-                        onValueChange={field.onChange}
-                        defaultValue={field.value}
-                      >
-                        <FormControl>
-                          <SelectTrigger>
-                            <SelectValue />
-                          </SelectTrigger>
-                        </FormControl>
-                        <SelectContent>
-                          <SelectItem value="proposal">
-                            {t("memory.dream.applyModeProposalOption")}
-                          </SelectItem>
-                          <SelectItem value="safe_auto">
-                            {t("memory.dream.applyModeSafeAutoOption")}
-                          </SelectItem>
-                        </SelectContent>
-                      </Select>
-                      <FormMessage />
-                    </FormItem>
-                  )}
-                />
-                <FormField
-                  control={form.control}
-                  name="scopeOutputMode"
-                  render={({ field }) => (
-                    <FormItem>
-                      <FormLabel>{t("memory.dream.scopeOutputMode")}</FormLabel>
-                      <Select
-                        onValueChange={field.onChange}
-                        value={field.value ?? ""}
-                      >
-                        <FormControl>
-                          <SelectTrigger>
-                            <SelectValue
-                              placeholder={t(
-                                "memory.dream.scopeOutputModePlaceholder",
-                              )}
-                            />
-                          </SelectTrigger>
-                        </FormControl>
-                        <SelectContent>
-                          <SelectItem value="preserve_scope">
-                            {t("memory.dream.preserveScope")}
-                          </SelectItem>
-                          <SelectItem value="promote_scope">
-                            {t("memory.dream.promoteScope")}
+            {isMemoryType ? (
+              <FormField
+                control={form.control}
+                name="applyMode"
+                render={({ field }) => (
+                  <FormItem>
+                    <FormLabel>{t("memory.dream.applyMode")}</FormLabel>
+                    <DreamApplicationModeCards
+                      value={field.value ?? "proposal"}
+                      effort={effort}
+                      t={t}
+                      onChange={(value, normalizedEffort) => {
+                        field.onChange(value);
+                        form.setValue("effort", normalizedEffort, {
+                          shouldValidate: true,
+                        });
+                      }}
+                    />
+                    <FormMessage />
+                  </FormItem>
+                )}
+              />
+            ) : null}
+
+            <section className="grid gap-3 sm:grid-cols-2">
+              <FormField
+                control={form.control}
+                name="effort"
+                render={({ field }) => (
+                  <FormItem>
+                    <FormLabel>{t("memory.dream.effort")}</FormLabel>
+                    <Select
+                      onValueChange={(value) => {
+                        field.onChange(value);
+                        if (!isMemoryType && value === "high") {
+                          form.setValue(
+                            "scopes",
+                            form.getValues("scopes").slice(0, 1),
+                          );
+                        }
+                      }}
+                      value={field.value}
+                      disabled={isMemoryType && forcedEffort !== undefined}
+                    >
+                      <FormControl>
+                        <SelectTrigger>
+                          <SelectValue />
+                        </SelectTrigger>
+                      </FormControl>
+                      <SelectContent>
+                        {dreamEffortOptions(taskType).map((level) => (
+                          <SelectItem key={level} value={level}>
+                            {level === "low"
+                              ? t("memory.dream.effortLow")
+                              : t("memory.dream.effortHigh")}
                           </SelectItem>
-                        </SelectContent>
-                      </Select>
-                      <FormMessage />
-                    </FormItem>
-                  )}
-                />
-              </section>
-            )}
+                        ))}
+                      </SelectContent>
+                    </Select>
+                    {isMemoryType && forcedEffort ? (
+                      <FormDescription>
+                        {t(
+                          forcedEffort === "low"
+                            ? "memory.dream.effortLockedLow"
+                            : "memory.dream.effortLockedHigh",
+                        )}
+                      </FormDescription>
+                    ) : null}
+                    <FormMessage />
+                  </FormItem>
+                )}
+              />
+            </section>
+
+            {isMemoryType ? (
+              <FormField
+                control={form.control}
+                name="scopeOutputMode"
+                render={({ field }) => (
+                  <FormItem>
+                    <FormLabel>{t("memory.dream.scopeOutputMode")}</FormLabel>
+                    <DreamOutputLocationCards
+                      value={field.value ?? "preserve_scope"}
+                      onChange={field.onChange}
+                      t={t}
+                    />
+                    <FormMessage />
+                  </FormItem>
+                )}
+              />
+            ) : null}
 
             <FormField
               control={form.control}
@@ -623,6 +998,11 @@ function MemoryDreamCreateDialogInner({
                   label={t("memory.dream.maxMemories")}
                   form={form}
                 />
+                <NumberField
+                  name="expandedScopeLimit"
+                  label={t("memory.dream.expandedScopeLimit")}
+                  form={form}
+                />
                 <DatetimeField
                   name="minTimestamp"
                   label={t("memory.dream.minTimestamp")}
@@ -648,6 +1028,26 @@ function MemoryDreamCreateDialogInner({
                     </FormItem>
                   )}
                 />
+                <FormField
+                  control={form.control}
+                  name="incremental"
+                  render={({ field }) => (
+                    <FormItem className="flex items-center gap-2 pt-5">
+                      <FormControl>
+                        <Checkbox
+                          checked={Boolean(field.value)}
+                          onCheckedChange={(checked) =>
+                            field.onChange(checked === true)
+                          }
+                        />
+                      </FormControl>
+                      <FormLabel className="text-xs">
+                        {t("memory.dream.incremental")}
+                      </FormLabel>
+                      <FormMessage />
+                    </FormItem>
+                  )}
+                />
               </CollapsibleContent>
             </Collapsible>