diff --git a/.changeset/import-proposal-json.md b/.changeset/import-proposal-json.md
new file mode 100644
index 0000000000..3c36228fef
--- /dev/null
+++ b/.changeset/import-proposal-json.md
@@ -0,0 +1,5 @@
+---
+"@anticapture/dashboard": minor
+---
+
+Import a proposal from JSON when creating one.
diff --git a/apps/dashboard/features/create-proposal/components/BodyField.tsx b/apps/dashboard/features/create-proposal/components/BodyField.tsx
index a1ecefd9d0..13d32cce2d 100644
--- a/apps/dashboard/features/create-proposal/components/BodyField.tsx
+++ b/apps/dashboard/features/create-proposal/components/BodyField.tsx
@@ -10,6 +10,8 @@ import {
   MDXEditor,
   Separator,
   StrikeThroughSupSubToggles,
+  codeBlockPlugin,
+  codeMirrorPlugin,
   diffSourcePlugin,
   headingsPlugin,
   linkDialogPlugin,
@@ -76,7 +78,6 @@ export const BodyField = ({ version = 0 }: BodyFieldProps) => {
           "[&_.mdxeditor-toolbar]:rounded-base! [&_.mdxeditor-toolbar]:!mb-2 [&_.mdxeditor-toolbar]:!bg-transparent [&_.mdxeditor-toolbar]:!px-0 [&_.mdxeditor-toolbar]:!py-0",
           "[&_.mdxeditor-root-contenteditable]:max-h-100 md:[&_.mdxeditor-root-contenteditable]:max-h-150 [&_.mdxeditor-root-contenteditable]:overflow-y-auto",
           "[&_.cm-editor]:min-h-75 [&_.cm-editor]:max-h-100 [&_.cm-scroller]:min-h-75 [&_.cm-scroller]:max-h-100 md:[&_.cm-editor]:min-h-130 md:[&_.cm-editor]:max-h-150 md:[&_.cm-scroller]:min-h-130 md:[&_.cm-scroller]:max-h-150",
-          // Markdown source view (CodeMirror) — match the dashboard theme
           "[&_.cm-editor]:bg-surface-background [&_.cm-editor]:text-primary",
           "[&_.cm-scroller]:bg-surface-background",
           "[&_.cm-content]:bg-surface-background [&_.cm-content]:text-primary [&_.cm-content]:caret-primary",
@@ -91,7 +92,6 @@ export const BodyField = ({ version = 0 }: BodyFieldProps) => {
           "[&_.tok-comment]:text-secondary [&_.tok-comment]:italic",
           "[&_.tok-number]:text-warning [&_.tok-bool]:text-warning [&_.tok-atom]:text-warning",
           "[&_.tok-punctuation]:text-secondary [&_.tok-meta]:text-secondary",
-          // Heading styles for Visual Editor content (mdxeditor content area)
           "[&_.mdxeditor-root-contenteditable_h1]:mb-3 [&_.mdxeditor-root-contenteditable_h1]:mt-4 [&_.mdxeditor-root-contenteditable_h1]:text-2xl [&_.mdxeditor-root-contenteditable_h1]:font-semibold",
           "[&_.mdxeditor-root-contenteditable_h2]:mb-2 [&_.mdxeditor-root-contenteditable_h2]:mt-4 [&_.mdxeditor-root-contenteditable_h2]:text-xl [&_.mdxeditor-root-contenteditable_h2]:font-semibold",
           "[&_.mdxeditor-root-contenteditable_h3]:mb-2 [&_.mdxeditor-root-contenteditable_h3]:mt-3 [&_.mdxeditor-root-contenteditable_h3]:text-lg [&_.mdxeditor-root-contenteditable_h3]:font-semibold",
@@ -122,6 +122,17 @@ export const BodyField = ({ version = 0 }: BodyFieldProps) => {
                 linkPlugin(),
                 linkDialogPlugin(),
                 tablePlugin(),
+                codeBlockPlugin({ defaultCodeBlockLanguage: "" }),
+                codeMirrorPlugin({
+                  codeBlockLanguages: {
+                    "": "Plain text",
+                    json: "JSON",
+                    js: "JavaScript",
+                    ts: "TypeScript",
+                    solidity: "Solidity",
+                    bash: "Shell",
+                  },
+                }),
                 markdownShortcutPlugin(),
                 diffSourcePlugin({
                   viewMode: mode === "markdown" ? "source" : "rich-text",
diff --git a/apps/dashboard/features/create-proposal/components/JsonTextarea.tsx b/apps/dashboard/features/create-proposal/components/JsonTextarea.tsx
new file mode 100644
index 0000000000..471765165c
--- /dev/null
+++ b/apps/dashboard/features/create-proposal/components/JsonTextarea.tsx
@@ -0,0 +1,86 @@
+"use client";
+
+import { useRef, type Ref } from "react";
+
+import { cn } from "@/shared/utils/cn";
+
+type JsonTextareaProps = {
+  value: string;
+  onChange: (value: string) => void;
+  placeholder?: string;
+  errorLine?: number;
+  showLineNumbers?: boolean;
+  hasError?: boolean;
+  ariaLabel?: string;
+  className?: string;
+  ref?: Ref<HTMLTextAreaElement>;
+};
+
+export const JsonTextarea = ({
+  value,
+  onChange,
+  placeholder,
+  errorLine,
+  showLineNumbers = false,
+  hasError = false,
+  ariaLabel,
+  className,
+  ref,
+}: JsonTextareaProps) => {
+  const gutterRef = useRef<HTMLDivElement>(null);
+
+  const lineCount = value === "" ? 0 : value.split("\n").length;
+
+  const gutterDigits = Math.max(2, String(lineCount).length);
+
+  return (
+    <div
+      className={cn(
+        "border-border-contrast bg-surface-default rounded-base flex overflow-hidden border transition-all duration-200",
+        "focus-within:shadow-[var(--shadow-focus-ring)]",
+        "max-h-[50vh] min-h-32 resize-y",
+        hasError && "border-error",
+        className,
+      )}
+    >
+      {showLineNumbers && (
+        <div
+          ref={gutterRef}
+          aria-hidden
+          style={{ width: `calc(${gutterDigits}ch + 1rem)` }}
+          className="text-dimmed pointer-events-none shrink-0 select-none overflow-hidden py-2 pl-2 pr-2 text-right font-mono text-xs leading-5"
+        >
+          {Array.from({ length: lineCount }, (_, index) => {
+            const line = index + 1;
+            return (
+              <div
+                key={line}
+                className={line === errorLine ? "text-error" : ""}
+              >
+                {line}
+              </div>
+            );
+          })}
+        </div>
+      )}
+
+      <textarea
+        ref={ref}
+        value={value}
+        onChange={(event) => onChange(event.target.value)}
+        onScroll={(event) => {
+          const gutter = gutterRef.current;
+          if (gutter) gutter.scrollTop = event.currentTarget.scrollTop;
+        }}
+        placeholder={placeholder}
+        spellCheck={false}
+        aria-label={ariaLabel}
+        className={cn(
+          "text-primary placeholder:text-dimmed h-full w-full resize-none whitespace-pre bg-transparent py-2 pr-2.5 font-mono text-xs leading-5",
+          "scrollbar-thin overflow-auto border-0 outline-none",
+          showLineNumbers ? "pl-0" : "pl-2.5",
+        )}
+      />
+    </div>
+  );
+};
diff --git a/apps/dashboard/features/create-proposal/components/NewProposalMenu.tsx b/apps/dashboard/features/create-proposal/components/NewProposalMenu.tsx
new file mode 100644
index 0000000000..0d4f5dd846
--- /dev/null
+++ b/apps/dashboard/features/create-proposal/components/NewProposalMenu.tsx
@@ -0,0 +1,89 @@
+"use client";
+
+import * as PopoverPrimitive from "@radix-ui/react-popover";
+import { Plus } from "lucide-react";
+import { useState } from "react";
+
+import { Button } from "@/shared/components/design-system/buttons/button/Button";
+import { itemStatusStyles } from "@/shared/components/design-system/combobox/styles";
+import { cn } from "@/shared/utils/cn";
+
+type NewProposalMenuProps = {
+  onCreateNew: () => void;
+  onImportJson: () => void;
+  triggerProps?: React.ComponentProps<typeof Button> &
+    Partial<Record<`data-${string}`, string | undefined>>;
+};
+
+const MenuItem = ({
+  label,
+  onSelect,
+}: {
+  label: string;
+  onSelect: () => void;
+}) => (
+  <button
+    type="button"
+    role="menuitem"
+    onClick={onSelect}
+    className={cn(
+      "flex w-full items-center px-3 py-2 text-left",
+      "text-primary text-sm font-normal leading-5",
+      itemStatusStyles.default,
+      "hover:bg-surface-hover cursor-pointer transition-colors duration-150",
+    )}
+  >
+    {label}
+  </button>
+);
+
+export const NewProposalMenu = ({
+  onCreateNew,
+  onImportJson,
+  triggerProps,
+}: NewProposalMenuProps) => {
+  const [open, setOpen] = useState(false);
+
+  const choose = (action: () => void) => () => {
+    setOpen(false);
+    action();
+  };
+
+  return (
+    <PopoverPrimitive.Root open={open} onOpenChange={setOpen}>
+      <PopoverPrimitive.Trigger asChild>
+        <Button
+          variant="primary"
+          size="md"
+          aria-haspopup="menu"
+          aria-expanded={open}
+          {...triggerProps}
+          className={cn(
+            "flex-1 whitespace-nowrap lg:w-fit lg:flex-none",
+            triggerProps?.className,
+          )}
+        >
+          <Plus className="size-4" />
+          New Proposal
+        </Button>
+      </PopoverPrimitive.Trigger>
+
+      <PopoverPrimitive.Content
+        role="menu"
+        align="end"
+        sideOffset={4}
+        className={cn(
+          "flex flex-col",
+          "min-w-40 py-1",
+          "bg-surface-contrast",
+          "border-border-contrast rounded-base border",
+          "z-50",
+          "animate-[popover-slide-in_0.15s_ease-out]",
+        )}
+      >
+        <MenuItem label="Create new" onSelect={choose(onCreateNew)} />
+        <MenuItem label="Import JSON" onSelect={choose(onImportJson)} />
+      </PopoverPrimitive.Content>
+    </PopoverPrimitive.Root>
+  );
+};
diff --git a/apps/dashboard/features/create-proposal/components/ProposalCreationForm.tsx b/apps/dashboard/features/create-proposal/components/ProposalCreationForm.tsx
index 57dace226d..5a6ec43b64 100644
--- a/apps/dashboard/features/create-proposal/components/ProposalCreationForm.tsx
+++ b/apps/dashboard/features/create-proposal/components/ProposalCreationForm.tsx
@@ -3,7 +3,7 @@
 import { zodResolver } from "@hookform/resolvers/zod";
 import { ChevronLeft } from "lucide-react";
 import { useEffect, useMemo, useRef, useState } from "react";
-import { FormProvider, useForm } from "react-hook-form";
+import { FormProvider, useFieldArray, useForm } from "react-hook-form";
 import Link from "next/link";
 import {
   useParams,
@@ -47,6 +47,7 @@ import { DraftViewToggle } from "@/features/create-proposal/components/preview/D
 import { DraftPreview } from "@/features/create-proposal/components/preview/DraftPreview";
 import { draftPreviewCopy } from "@/features/create-proposal/utils/draftThresholdCopy";
 import { getRecipientPublishState } from "@/features/create-proposal/utils/recipientPublishState";
+import { cloneAction } from "@/features/create-proposal/utils/cloneAction";
 import { ActionsList } from "@/features/create-proposal/components/actions/ActionsList";
 import { ActionsPlaceholderCard } from "@/features/create-proposal/components/actions/ActionsPlaceholderCard";
 import { AddTransferModal } from "@/features/create-proposal/components/modals/AddTransferModal";
@@ -56,6 +57,10 @@ import { PublishModal } from "@/features/create-proposal/components/modals/Publi
 import { ProposalSubmittedModal } from "@/features/create-proposal/components/modals/ProposalSubmittedModal";
 import { SubmissionFailedModal } from "@/features/create-proposal/components/modals/SubmissionFailedModal";
 import { InsufficientVPModal } from "@/features/create-proposal/components/modals/InsufficientVPModal";
+import {
+  takeImportedProposal,
+  type ImportedProposal,
+} from "@/features/create-proposal/utils/importHandoff";
 import type {
   CustomAction,
   ERC20TransferAction,
@@ -63,11 +68,6 @@ import type {
   ProposalAction,
 } from "@/features/create-proposal/types";
 
-/**
- * Normalizes a ProposalAction for use in RHF form state.
- * The `Abi` type from viem is `readonly (AbiItem)[]`, but the Zod-inferred
- * form type expects a mutable `any[]`. We spread to get a mutable copy.
- */
 function toFormAction(
   action: ProposalAction,
 ): ProposalFormValues["actions"][number] {
@@ -118,7 +118,6 @@ export const ProposalCreationForm = ({
     "view",
     parseAsStringEnum<"editor" | "preview">(["editor", "preview"]),
   );
-  // A shared link (has draftId) defaults to Preview; a new proposal to Editor.
   const view = viewParam ?? (draftId ? "preview" : "editor");
 
   const form = useForm<ProposalFormValues>({
@@ -126,6 +125,16 @@ export const ProposalCreationForm = ({
     defaultValues: DEFAULTS,
     mode: "onChange",
   });
+
+  const actionsArray = useFieldArray({
+    control: form.control,
+    name: "actions",
+  });
+
+  const revalidateActions = () => {
+    void form.trigger("actions");
+  };
+
   const hydratedDraftIdRef = useRef<string | undefined>(undefined);
 
   useEffect(() => {
@@ -140,7 +149,6 @@ export const ProposalCreationForm = ({
         body: d.body,
         actions: d.actions.map(toFormAction),
       });
-      // Locally-owned draft has no shared author.
       setSharedAuthor(undefined);
       setCurrentDraftId(draftId);
       setBodyVersion((v) => v + 1);
@@ -151,7 +159,6 @@ export const ProposalCreationForm = ({
 
     if (drafts.isLoading) return;
 
-    // Guards against an out-of-order response overwriting the form.
     let cancelled = false;
 
     void getDraft(draftId)
@@ -159,14 +166,8 @@ export const ProposalCreationForm = ({
         if (cancelled) return;
         hydratedDraftIdRef.current = draftId;
         if (!shared) return;
-        // A draft link belongs to one DAO: refuse content prepared for
-        // another one (stale or crafted cross-DAO links would otherwise be
-        // previewed — and publishable — under this route's DAO).
         if (shared.daoId !== daoId) {
           showCustomToast("This draft belongs to another DAO", "error");
-          // The URL's draftId must not stay armed as the save target: a
-          // later Save Draft would overwrite the foreign-DAO draft with
-          // this route's form content.
           setCurrentDraftId(undefined);
           return;
         }
@@ -177,9 +178,6 @@ export const ProposalCreationForm = ({
           body: shared.body,
           actions: shared.actions.map((a) => toFormAction(a as ProposalAction)),
         });
-        // Ownership is derived server-side from the session (works for
-        // wallet- and email/Google-authored drafts alike), not by comparing
-        // the author against the connected wallet.
         setCurrentDraftId(shared.isOwner ? draftId : undefined);
         setBodyVersion((v) => v + 1);
         setHydratedDraftId(draftId);
@@ -192,7 +190,6 @@ export const ProposalCreationForm = ({
     return () => {
       cancelled = true;
     };
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [draftId, drafts.drafts, drafts.isLoading]);
 
   const [currentDraftId, setCurrentDraftId] = useState<string | undefined>(
@@ -201,7 +198,6 @@ export const ProposalCreationForm = ({
   const [sharedAuthor, setSharedAuthor] = useState<string | undefined>(
     undefined,
   );
-  // The draftId whose content is loaded into the form (gates Edit/fork).
   const [hydratedDraftId, setHydratedDraftId] = useState<string | undefined>(
     undefined,
   );
@@ -218,11 +214,6 @@ export const ProposalCreationForm = ({
   const [insufficientOpen, setInsufficientOpen] = useState(false);
   const [isSavingDraft, setIsSavingDraft] = useState(false);
 
-  // Email/Google sign-in leaves the page, so a dirty form would be lost on
-  // the auth round-trip. Save Draft stashes the values before opening the
-  // login modal; back on the page the stash is restored — after any shared
-  // draft hydrated, so the user's newer edits win — and cleared. The in-page
-  // SIWE path restores a byte-identical form, a visual no-op.
   const pendingDraftStashKey = `anticapture:pending-draft:${daoId}`;
   useEffect(() => {
     let raw: string | null = null;
@@ -239,19 +230,16 @@ export const ProposalCreationForm = ({
       });
       setBodyVersion((v) => v + 1);
     } catch {
-      // corrupted stash — drop it
+      // A corrupt stash is dropped, not surfaced: the form is usable without it.
     } finally {
       try {
         sessionStorage.removeItem(pendingDraftStashKey);
       } catch {
-        // ignore
+        // Storage that refuses this refused the write too.
       }
     }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [pendingDraftStashKey, draftId, hydratedDraftId]);
-  // Publish deferred while a disconnected user connects, resumed once ready.
   const [pendingAction, setPendingAction] = useState<"publish" | null>(null);
-  // Ref so rapid clicks see an in-flight save before state commits.
   const isSavingDraftRef = useRef(false);
 
   const draftContentLoaded = !draftId || hydratedDraftId === draftId;
@@ -268,9 +256,6 @@ export const ProposalCreationForm = ({
   const canPublish =
     hasTitle && hasBody && hasActions && !!address && form.formState.isValid;
 
-  // The drafts endpoint rejects bodies past BODY_CHAR_LIMIT, and neither Save
-  // Draft nor Share runs schema validation before POSTing — without this the
-  // request fails with the generic "Could not save draft".
   const isBodyOverLimit = (values.body?.length ?? 0) > BODY_CHAR_LIMIT;
   const bodyOverLimitMessage = `Description is over the ${BODY_CHAR_LIMIT.toLocaleString()} character limit`;
 
@@ -278,7 +263,7 @@ export const ProposalCreationForm = ({
     try {
       sessionStorage.setItem(pendingDraftStashKey, JSON.stringify(values));
     } catch {
-      // Storage can be blocked; the in-page SIWE path still preserves the form.
+      // Best effort: a refused stash costs the round trip, not the draft.
     }
   };
 
@@ -287,16 +272,13 @@ export const ProposalCreationForm = ({
       showCustomToast(bodyOverLimitMessage, "error");
       return;
     }
-    // Persist before sharing when unsaved or dirty, so the link isn't stale.
     let id = currentDraftId;
     if (!id || form.formState.isDirty) {
-      // Session-gated like Save Draft — email/Google authors have no wallet.
       if (drafts.needsAuth) {
         stashPendingDraft();
         openLogin();
         return;
       }
-      // Guard against duplicate creates from rapid clicks (shared with Save Draft).
       if (isSavingDraftRef.current) return;
       isSavingDraftRef.current = true;
       setIsSavingDraft(true);
@@ -333,10 +315,7 @@ export const ProposalCreationForm = ({
   };
 
   const handleEditCopy = () => {
-    // Forking the blank default form would lose the shared content.
     if (!draftContentLoaded) return;
-    // Edit doesn't persist: drop the draftId and open a new prefilled form
-    // (RHF state survives the query-only nav). Saved only via Save Draft.
     setSharedAuthor(undefined);
     setCurrentDraftId(undefined);
     hydratedDraftIdRef.current = undefined;
@@ -346,9 +325,6 @@ export const ProposalCreationForm = ({
 
   const handlePreviewPublish = () => {
     if (!address) {
-      // Publishing is an on-chain transaction, so it only needs a connected
-      // wallet: the picker opens directly, with no sign-in step. Saving and
-      // sharing drafts stay session-gated below. See useWalletPrompt.
       setPendingAction("publish");
       promptWalletConnection();
       return;
@@ -356,14 +332,11 @@ export const ProposalCreationForm = ({
     handlePublishClick();
   };
 
-  // Resume a deferred publish only once VP, threshold, and draft hydration are
-  // all ready (each reads 0n/blank while loading and would mis-decide).
   useEffect(() => {
     if (!address || pendingAction !== "publish") return;
     if (vp.isLoading || isLoadingThreshold || !draftContentLoaded) return;
     setPendingAction(null);
     handlePublishClick();
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [
     address,
     pendingAction,
@@ -377,17 +350,11 @@ export const ProposalCreationForm = ({
       showCustomToast(bodyOverLimitMessage, "error");
       return;
     }
-    // Saving is session-gated now, not wallet-gated: prompt sign-in when there
-    // is no session (the user may be connected but not authenticated).
     if (drafts.needsAuth) {
-      // Stash the form first: the email/Google paths leave the page, and the
-      // restore effect above brings the content back after the round-trip.
       stashPendingDraft();
-      // storage blocked — the in-page SIWE path still preserves the form
       openLogin();
       return;
     }
-    // Guard against duplicate creates while a save is in flight.
     if (isSavingDraftRef.current) return;
     isSavingDraftRef.current = true;
     setIsSavingDraft(true);
@@ -421,11 +388,8 @@ export const ProposalCreationForm = ({
   };
 
   const handlePublishClick = () => {
-    // Validate here too — the resume path calls this directly.
     if (!canPublish) return;
-    // Stale form values until the current draftId hydrates; don't publish them.
     if (!draftContentLoaded) return;
-    // VP/threshold read 0n while loading; wait before comparing.
     if (vp.isLoading || isLoadingThreshold) {
       showCustomToast(
         "Still checking your voting power — try again in a moment.",
@@ -442,7 +406,6 @@ export const ProposalCreationForm = ({
     setPublishOpen(true);
   };
 
-  // Transition publish → submitted/failed
   useEffect(() => {
     if (publisher.isReceiptSuccess) {
       setPublishOpen(false);
@@ -461,28 +424,57 @@ export const ProposalCreationForm = ({
   const addAction = (
     action: EthTransferAction | ERC20TransferAction | CustomAction,
   ) => {
-    form.setValue("actions", [...values.actions, toFormAction(action)], {
-      shouldDirty: true,
-      shouldValidate: true,
-    });
+    actionsArray.append(toFormAction(action));
+    revalidateActions();
   };
 
   const submitAction = (
     action: EthTransferAction | ERC20TransferAction | CustomAction,
   ) => {
     if (editActionIndex !== null) {
-      const next = [...values.actions];
-      next[editActionIndex] = toFormAction(action);
-      form.setValue("actions", next, {
-        shouldDirty: true,
-        shouldValidate: true,
-      });
+      actionsArray.update(editActionIndex, toFormAction(action));
+      revalidateActions();
       setEditActionIndex(null);
     } else {
       addAction(action);
     }
   };
 
+  const applyImportedProposal = (imported: ImportedProposal) => {
+    const options = { shouldDirty: true, shouldValidate: true } as const;
+    if (imported.title !== undefined) {
+      form.setValue("title", imported.title, options);
+    }
+    if (imported.discussionUrl !== undefined) {
+      form.setValue("discussionUrl", imported.discussionUrl, options);
+    }
+    if (imported.body !== undefined) {
+      form.setValue("body", imported.body, options);
+      setBodyVersion((v) => v + 1);
+    }
+    if (imported.actions !== undefined) {
+      actionsArray.replace(imported.actions);
+      form.setValue("actions", imported.actions, options);
+    }
+    showCustomToast("Proposal fields imported", "success");
+  };
+
+  const importAppliedRef = useRef(false);
+  useEffect(() => {
+    if (draftId || importAppliedRef.current) return;
+    const imported = takeImportedProposal(daoId);
+    if (!imported) return;
+    importAppliedRef.current = true;
+    applyImportedProposal(imported);
+  }, [daoId, draftId]);
+
+  const duplicateAction = (index: number) => {
+    const source = form.getValues(`actions.${index}`);
+    if (!source) return;
+    actionsArray.insert(index + 1, cloneAction(source));
+    revalidateActions();
+  };
+
   const openEditForAction = (index: number) => {
     const action = values.actions[index];
     if (!action) return;
@@ -518,19 +510,12 @@ export const ProposalCreationForm = ({
     return formatNumberUserReadable(numeric, 0);
   }, [currentVpText]);
 
-  // The drafts list is session-scoped (the User API returns only the session
-  // user's drafts), so a draft present in it is owned — no wallet comparison
-  // needed, and it holds for email/Google authors who have no wallet.
   const ownedDraft = draftId ? drafts.getDraft(draftId) : undefined;
   const ownsDraft = Boolean(ownedDraft);
   const isRecipient = Boolean(draftId) && !drafts.isLoading && !ownsDraft;
-  // Editor only for a new proposal or an owned draft (no load-dependent flash).
   const canShowEditor = !draftId || ownsDraft;
   const authorAddress = sharedAuthor ?? address ?? "";
 
-  // Once ownership resolves (e.g. an author connects on their own share link),
-  // adopt the draftId so saves update the existing draft instead of creating a
-  // duplicate.
   useEffect(() => {
     if (ownsDraft && draftId && currentDraftId !== draftId) {
       setCurrentDraftId(draftId);
@@ -561,10 +546,6 @@ export const ProposalCreationForm = ({
       )
     : draftPreviewCopy({ role: "author" });
 
-  // Recipients can only ever see the Preview — they have no editor access.
-  // Gated on draftContentLoaded so a not-yet-resolved ownership check (drafts
-  // still loading on mount) can't misclassify an owner as a recipient and
-  // force their own draft into Preview.
   useEffect(() => {
     if (isRecipient && draftContentLoaded && view !== "preview") {
       void setView("preview");
@@ -645,8 +626,6 @@ export const ProposalCreationForm = ({
           onEdit={handleEditCopy}
           editDisabled={!draftContentLoaded}
           isWhitelabelRoute={isWhitelabelRoute}
-          // Enabled while disconnected (to open the wallet); once connected,
-          // block an invalid form, a loading threshold, or below-threshold.
           publishDisabled={
             Boolean(address) &&
             (isLoadingThreshold ||
@@ -717,9 +696,15 @@ export const ProposalCreationForm = ({
                 </span>
               </div>
               <div className="flex flex-col gap-3">
-                {values.actions.length > 0 && (
+                {actionsArray.fields.length > 0 && (
                   <ActionsList
+                    fields={actionsArray.fields}
+                    onMove={(from, to) => {
+                      actionsArray.move(from, to);
+                      revalidateActions();
+                    }}
                     onEditAction={openEditForAction}
+                    onDuplicateAction={duplicateAction}
                     onDeleteAction={(i) => setDeleteActionIndex(i)}
                   />
                 )}
@@ -767,12 +752,8 @@ export const ProposalCreationForm = ({
         onOpenChange={(o) => !o && setDeleteActionIndex(null)}
         onConfirm={() => {
           if (deleteActionIndex !== null) {
-            const next = [...values.actions];
-            next.splice(deleteActionIndex, 1);
-            form.setValue("actions", next, {
-              shouldDirty: true,
-              shouldValidate: true,
-            });
+            actionsArray.remove(deleteActionIndex);
+            revalidateActions();
           }
           setDeleteActionIndex(null);
         }}
diff --git a/apps/dashboard/features/create-proposal/components/actions/ActionRow.tsx b/apps/dashboard/features/create-proposal/components/actions/ActionRow.tsx
index c36a92afca..28a29b1e28 100644
--- a/apps/dashboard/features/create-proposal/components/actions/ActionRow.tsx
+++ b/apps/dashboard/features/create-proposal/components/actions/ActionRow.tsx
@@ -3,14 +3,17 @@
 import { useSortable } from "@dnd-kit/sortable";
 import { CSS } from "@dnd-kit/utilities";
 import { ArrowDown, ArrowUp, Copy, Pencil, Trash2 } from "lucide-react";
-import { erc20Abi, isAddress } from "viem";
+import { erc20Abi } from "viem";
 import { useReadContract } from "wagmi";
 
 import { BadgeStatus } from "@/shared/components/design-system/badges/badge-status/BadgeStatus";
 import { Button } from "@/shared/components/design-system/buttons/button/Button";
 import { IconButton } from "@/shared/components/design-system/buttons/icon-button/IconButton";
+import { Tooltip } from "@/shared/components/design-system/tooltips/Tooltip";
 import type { ProposalAction } from "@/features/create-proposal/types";
 import { BulletDivider } from "@/shared/components/design-system/section";
+import { isAddressLike, toChecksumAddress } from "@/shared/utils/address";
+import { cn } from "@/shared/utils/cn";
 
 interface ActionRowProps {
   id: string;
@@ -23,6 +26,7 @@ interface ActionRowProps {
   onEdit: () => void;
   onDuplicate: () => void;
   onDelete: () => void;
+  error?: string;
 }
 
 function actionTypeLabel(action: ProposalAction): string {
@@ -31,10 +35,8 @@ function actionTypeLabel(action: ProposalAction): string {
   return "Custom";
 }
 
-/** Shortens a 0x address to the conventional 0xabcd…1234 form. Pass through
- *  any value that isn't a hex address (e.g. an ENS name) unchanged. */
 function truncateAddress(value: string): string {
-  if (!isAddress(value)) return value;
+  if (!isAddressLike(value)) return value;
   return `${value.slice(0, 6)}…${value.slice(-4)}`;
 }
 
@@ -64,6 +66,7 @@ export const ActionRow = ({
   onEdit,
   onDuplicate,
   onDelete,
+  error,
 }: ActionRowProps) => {
   const { attributes, listeners, setNodeRef, transform, transition } =
     useSortable({ id });
@@ -72,12 +75,9 @@ export const ActionRow = ({
     transition,
   };
 
-  // Resolve the ERC-20 symbol at render-time so the summary shows e.g.
-  // "100 USDC" instead of "100 ERC-20". We only read when the address looks
-  // valid so wagmi doesn't fire requests for in-progress input.
   const erc20Address =
-    action.type === "erc20-transfer" && isAddress(action.tokenAddress)
-      ? (action.tokenAddress as `0x${string}`)
+    action.type === "erc20-transfer" && isAddressLike(action.tokenAddress)
+      ? toChecksumAddress(action.tokenAddress)
       : undefined;
   const { data: tokenSymbol } = useReadContract({
     abi: erc20Abi,
@@ -92,86 +92,102 @@ export const ActionRow = ({
       style={style}
       {...attributes}
       {...listeners}
-      className="border-border-default bg-surface-default flex items-center gap-2 px-3 py-2"
+      className={cn(
+        "border-border-default bg-surface-default flex flex-col px-3 py-2",
+        error && "bg-error/5",
+      )}
     >
-      <div className="flex flex-col">
-        <IconButton
-          icon={ArrowUp}
-          variant="ghost"
-          size="sm"
-          aria-label="Move up"
-          disabled={isFirst}
-          onClick={(e) => {
-            e.stopPropagation();
-            onMoveUp();
-          }}
-          onPointerDown={(e) => e.stopPropagation()}
-          className="p-0.5"
-        />
-        <IconButton
-          icon={ArrowDown}
-          variant="ghost"
-          size="sm"
-          aria-label="Move down"
-          disabled={isLast}
-          onClick={(e) => {
-            e.stopPropagation();
-            onMoveDown();
-          }}
-          onPointerDown={(e) => e.stopPropagation()}
-          className="p-0.5"
-        />
+      <div className="flex items-center gap-2">
+        <div className="flex flex-col">
+          <IconButton
+            icon={ArrowUp}
+            variant="ghost"
+            size="sm"
+            aria-label="Move up"
+            disabled={isFirst}
+            onClick={(e) => {
+              e.stopPropagation();
+              onMoveUp();
+            }}
+            onPointerDown={(e) => e.stopPropagation()}
+            className="p-0.5"
+          />
+          <IconButton
+            icon={ArrowDown}
+            variant="ghost"
+            size="sm"
+            aria-label="Move down"
+            disabled={isLast}
+            onClick={(e) => {
+              e.stopPropagation();
+              onMoveDown();
+            }}
+            onPointerDown={(e) => e.stopPropagation()}
+            className="p-0.5"
+          />
+        </div>
+        <BadgeStatus variant="outline" className="size-5 justify-center px-0">
+          {index + 1}
+        </BadgeStatus>
+        <div className="flex min-w-0 flex-1 flex-col gap-1 lg:flex-row lg:items-center">
+          <span className="text-primary truncate text-sm font-medium">
+            {actionTypeLabel(action)}
+          </span>
+          <BulletDivider className="hidden lg:block" />
+          <span className="text-secondary truncate text-sm">
+            {actionSubtitle(action, tokenSymbol)}
+          </span>
+          <BulletDivider className="hidden lg:block" />
+          <span className="text-secondary truncate text-sm">
+            {actionTarget(action)}
+          </span>
+        </div>
+        <Tooltip asChild disableMobileClick tooltipContent="Edit">
+          <Button
+            variant="ghost"
+            size="sm"
+            onClick={(e) => {
+              e.stopPropagation();
+              onEdit();
+            }}
+            aria-label="Edit action"
+          >
+            <Pencil className="size-4" />
+          </Button>
+        </Tooltip>
+        {/* Named, because the copy glyph reads as "copy to clipboard" and
+            invites repeat clicks that each add another action. */}
+        <Tooltip asChild disableMobileClick tooltipContent="Duplicate">
+          <Button
+            variant="ghost"
+            size="sm"
+            onClick={(e) => {
+              e.stopPropagation();
+              onDuplicate();
+            }}
+            onPointerDown={(e) => e.stopPropagation()}
+            aria-label="Duplicate action"
+          >
+            <Copy className="size-4" />
+          </Button>
+        </Tooltip>
+        <Tooltip asChild disableMobileClick tooltipContent="Delete">
+          <Button
+            variant="ghost"
+            size="sm"
+            onClick={(e) => {
+              e.stopPropagation();
+              onDelete();
+            }}
+            aria-label="Delete action"
+          >
+            <Trash2 className="size-4" />
+          </Button>
+        </Tooltip>
       </div>
-      <BadgeStatus variant="outline" className="size-5 justify-center px-0">
-        {index + 1}
-      </BadgeStatus>
-      <div className="flex min-w-0 flex-1 flex-col gap-1 lg:flex-row lg:items-center">
-        <span className="text-primary truncate text-sm font-medium">
-          {actionTypeLabel(action)}
-        </span>
-        <BulletDivider className="hidden lg:block" />
-        <span className="text-secondary truncate text-sm">
-          {actionSubtitle(action, tokenSymbol)}
-        </span>
-        <BulletDivider className="hidden lg:block" />
-        <span className="text-secondary truncate text-sm">
-          {actionTarget(action)}
-        </span>
-      </div>
-      <Button
-        variant="ghost"
-        size="sm"
-        onClick={(e) => {
-          e.stopPropagation();
-          onEdit();
-        }}
-        aria-label="Edit action"
-      >
-        <Pencil className="size-4" />
-      </Button>
-      <Button
-        variant="ghost"
-        size="sm"
-        onClick={(e) => {
-          e.stopPropagation();
-          onDuplicate();
-        }}
-        onPointerDown={(e) => e.stopPropagation()}
-        aria-label="Duplicate action"
-      >
-        <Copy className="size-4" />
-      </Button>
-      <Button
-        variant="ghost"
-        size="sm"
-        onClick={(e) => {
-          e.stopPropagation();
-          onDelete();
-        }}
-        aria-label="Delete action"
-      >
-        <Trash2 className="size-4" />
-      </Button>
+      {error && (
+        <span className="text-error pl-[4.25rem] text-xs">{error}</span>
+      )}
     </div>
   );
 };
diff --git a/apps/dashboard/features/create-proposal/components/actions/ActionsList.tsx b/apps/dashboard/features/create-proposal/components/actions/ActionsList.tsx
index 50bdade429..f53165c74c 100644
--- a/apps/dashboard/features/create-proposal/components/actions/ActionsList.tsx
+++ b/apps/dashboard/features/create-proposal/components/actions/ActionsList.tsx
@@ -12,30 +12,58 @@ import {
   SortableContext,
   verticalListSortingStrategy,
 } from "@dnd-kit/sortable";
-import { useFieldArray, useFormContext } from "react-hook-form";
+import { useFormContext } from "react-hook-form";
 
 import { ActionRow } from "@/features/create-proposal/components/actions/ActionRow";
 import type { ProposalFormValues } from "@/features/create-proposal/schema";
-import { cloneAction } from "@/features/create-proposal/utils/cloneAction";
+import type { ProposalAction } from "@/features/create-proposal/types";
+
+export type ActionField = ProposalFormValues["actions"][number] & {
+  id: string;
+};
 
 interface ActionsListProps {
+  fields: ActionField[];
+  onMove: (from: number, to: number) => void;
   onEditAction: (index: number) => void;
+  onDuplicateAction: (index: number) => void;
   onDeleteAction: (index: number) => void;
 }
 
+const firstErrorIn = (value: unknown, path = ""): string | undefined => {
+  if (!value || typeof value !== "object") return undefined;
+
+  const message = (value as { message?: unknown }).message;
+  if (typeof message === "string" && message) {
+    return path ? `${path}: ${message}` : message;
+  }
+
+  if (Array.isArray(value)) {
+    for (const [index, item] of value.entries()) {
+      const found = firstErrorIn(item, `${path}[${index}]`);
+      if (found) return found;
+    }
+    return undefined;
+  }
+
+  for (const [key, item] of Object.entries(value)) {
+    if (key === "ref" || key === "type" || key === "types") continue;
+    const found = firstErrorIn(item, path ? `${path}.${key}` : key);
+    if (found) return found;
+  }
+  return undefined;
+};
+
 export const ActionsList = ({
+  fields,
+  onMove,
   onEditAction,
+  onDuplicateAction,
   onDeleteAction,
 }: ActionsListProps) => {
-  const { control, getValues } = useFormContext<ProposalFormValues>();
-  const { fields, move, insert } = useFieldArray({ control, name: "actions" });
-
-  // Insert an independent deep copy directly after the source row. `getValues`
-  // returns the raw action (without RHF's internal field id) and `insert` mints
-  // a fresh id for the copy.
-  const handleDuplicate = (index: number) => {
-    insert(index + 1, cloneAction(getValues(`actions.${index}`)));
-  };
+  const {
+    formState: { errors },
+  } = useFormContext<ProposalFormValues>();
 
   const sensors = useSensors(
     useSensor(PointerSensor, { activationConstraint: { distance: 4 } }),
@@ -45,7 +73,7 @@ export const ActionsList = ({
     if (!over || active.id === over.id) return;
     const from = fields.findIndex((f) => f.id === active.id);
     const to = fields.findIndex((f) => f.id === over.id);
-    if (from >= 0 && to >= 0) move(from, to);
+    if (from >= 0 && to >= 0) onMove(from, to);
   };
 
   return (
@@ -64,14 +92,15 @@ export const ActionsList = ({
               key={field.id}
               id={field.id}
               index={index}
-              action={field}
+              action={field as ProposalAction}
               isFirst={index === 0}
               isLast={index === fields.length - 1}
-              onMoveUp={() => move(index, index - 1)}
-              onMoveDown={() => move(index, index + 1)}
+              onMoveUp={() => onMove(index, index - 1)}
+              onMoveDown={() => onMove(index, index + 1)}
               onEdit={() => onEditAction(index)}
-              onDuplicate={() => handleDuplicate(index)}
+              onDuplicate={() => onDuplicateAction(index)}
               onDelete={() => onDeleteAction(index)}
+              error={firstErrorIn(errors.actions?.[index])}
             />
           ))}
         </div>
diff --git a/apps/dashboard/features/create-proposal/components/modals/AddCustomActionModal.tsx b/apps/dashboard/features/create-proposal/components/modals/AddCustomActionModal.tsx
index eb9de84432..cb61638645 100644
--- a/apps/dashboard/features/create-proposal/components/modals/AddCustomActionModal.tsx
+++ b/apps/dashboard/features/create-proposal/components/modals/AddCustomActionModal.tsx
@@ -4,7 +4,6 @@ import { ArrowLeft, ArrowRight, Upload } from "lucide-react";
 import { useEffect, useMemo, useRef, useState } from "react";
 import {
   encodeFunctionData,
-  isAddress,
   isHex,
   toFunctionSelector,
   toFunctionSignature,
@@ -24,6 +23,7 @@ import { Modal } from "@/shared/components/design-system/modal/Modal";
 import { ProgressBar } from "@/shared/components/design-system/progress-bar/ProgressBar";
 import { Spinner } from "@/shared/components/design-system/spinner/Spinner";
 import daoConfig from "@/shared/dao-config";
+import { isAddressLike } from "@/shared/utils/address";
 import { fetchAddressFromEnsName, isEnsAddress } from "@/shared/utils/ens";
 import type { DaoIdEnum } from "@/shared/types/daos";
 import type { CustomAction } from "@/features/create-proposal/types";
@@ -34,13 +34,14 @@ import {
 import { ArgInput } from "@/features/create-proposal/components/custom-action/ArgInput";
 import {
   argsToTrees,
+  argsToTreesForDisplay,
   argToStorage,
   buildEmpty,
   decodeCalldataToArgs,
   treesToEncodeValues,
   type ArgValue,
 } from "@/features/create-proposal/utils/argTree";
-import { isArgComplete } from "@/features/create-proposal/utils/validateArg";
+import { isArgComplete } from "@/features/create-proposal/utils/argIssues";
 import ensGovernorAbi from "@/abis/ens-governor.json";
 
 type Step = 1 | 2;
@@ -64,9 +65,6 @@ const bundledAbisByAddress = (daoId: string): Record<string, Abi> => {
   if (!bundledGovernorAbi) return {};
   const governor = daoConfig[daoIdEnum]?.daoOverview?.contracts?.governor;
   if (!governor) return {};
-  // Validate the bundled JSON once at the boundary rather than casting it
-  // straight through. If the import is ever corrupted this returns null and
-  // we fall through to the remote fetch path below.
   const validated = parseAbiStrict(bundledGovernorAbi);
   if (!validated) return {};
   return { [governor.toLowerCase()]: validated };
@@ -84,10 +82,6 @@ const lookupAbi = (daoId: string, address: string): Promise<Abi | null> => {
 const parseAbiJson = (text: string): Abi | null => {
   try {
     const parsed: unknown = JSON.parse(text);
-    // Accept either a bare ABI array or a Hardhat/Foundry-style artifact
-    // object with an `abi` field. Validate the array with zod so malformed
-    // items are rejected at the boundary instead of blowing up later inside
-    // viem encoders.
     if (Array.isArray(parsed)) {
       return parseAbiStrict(parsed);
     }
@@ -120,7 +114,6 @@ export const AddCustomActionModal = ({
   );
   const [mode, setMode] = useState<ConfigMode>(initialMode);
 
-  // Fetch-ABI flow
   const [abiText, setAbiText] = useState(
     initialValue && initialValue.abi.length > 0
       ? JSON.stringify(initialValue.abi, null, 2)
@@ -131,21 +124,17 @@ export const AddCustomActionModal = ({
   const [isManualAbiEntry, setIsManualAbiEntry] = useState(false);
   const fileInputRef = useRef<HTMLInputElement>(null);
 
-  // Calldata flow
   const [calldata, setCalldata] = useState(initialValue?.calldata ?? "");
 
-  // Step 2
   const [functionName, setFunctionName] = useState(
     initialValue?.functionName ?? "",
   );
   const [args, setArgs] = useState<string[]>(initialValue?.args ?? []);
   const [addressTouched, setAddressTouched] = useState(false);
 
-  // Calldata field: shows the live encoded calldata and accepts a pasted blob to decode.
   const [calldataField, setCalldataField] = useState("");
   const [decodeError, setDecodeError] = useState<string | null>(null);
 
-  // Re-hydrate whenever the modal opens
   useEffect(() => {
     if (!open) return;
     setStep(1);
@@ -189,7 +178,7 @@ export const AddCustomActionModal = ({
 
   const isAddressValid =
     contractAddress.trim() === "" ||
-    isAddress(contractAddress.trim()) ||
+    isAddressLike(contractAddress) ||
     isEnsAddress(contractAddress.trim());
 
   const functions = useMemo<AbiFunction[]>(() => {
@@ -235,7 +224,7 @@ export const AddCustomActionModal = ({
     if (mode !== "fetch") return;
     const v = contractAddress.trim();
     if (!v) return;
-    const isRawAddress = isAddress(v, { strict: false });
+    const isRawAddress = isAddressLike(v);
     const isEns = isEnsAddress(v);
     if (!isRawAddress && !isEns) return;
     setIsFetchingAbi(true);
@@ -302,35 +291,42 @@ export const AddCustomActionModal = ({
     (mode === "fetch" ? Boolean(abi) : isCalldataValid);
 
   const argTrees = useMemo<ArgValue[]>(
-    () => (selectedFn ? argsToTrees(selectedFn.inputs, args) : []),
+    () => (selectedFn ? argsToTreesForDisplay(selectedFn.inputs, args) : []),
     [selectedFn, args],
   );
 
+  const encodableTrees = useMemo<ArgValue[] | null>(() => {
+    if (!selectedFn) return null;
+    try {
+      return argsToTrees(selectedFn.inputs, args);
+    } catch {
+      return null;
+    }
+  }, [selectedFn, args]);
+
   const allArgsFilled =
     selectedFn !== undefined &&
+    encodableTrees !== null &&
     selectedFn.inputs.every((input, i) =>
-      isArgComplete(input, argTrees[i] ?? buildEmpty(input)),
+      isArgComplete(input, encodableTrees[i] ?? buildEmpty(input)),
     );
 
   const step2Ready =
     mode === "fetch" ? Boolean(functionName) && allArgsFilled : isCalldataValid;
 
-  // Live calldata preview (form -> hex). Best-effort: only encodes once every
-  // field is concrete (addresses must already be 0x — ENS resolves at publish).
   const encodedPreview = useMemo<string | null>(() => {
     if (mode !== "fetch" || !selectedFn || !allArgsFilled) return null;
     try {
       return encodeFunctionData({
         abi: [selectedFn],
         functionName: selectedFn.name,
-        args: treesToEncodeValues(selectedFn.inputs, argTrees),
+        args: treesToEncodeValues(selectedFn.inputs, encodableTrees ?? []),
       });
     } catch {
       return null;
     }
-  }, [mode, selectedFn, allArgsFilled, argTrees]);
+  }, [mode, selectedFn, allArgsFilled, encodableTrees]);
 
-  // Mirror the live encoded output into the field as the form changes.
   useEffect(() => {
     if (encodedPreview) setCalldataField(encodedPreview);
   }, [encodedPreview]);
@@ -339,7 +335,6 @@ export const AddCustomActionModal = ({
   const calldataFieldIsEncoded =
     encodedPreview !== null && trimmedCalldataField === encodedPreview;
 
-  // Decode a pasted calldata blob into the function + args.
   const handleDecode = () => {
     const data = trimmedCalldataField;
     if (!isHex(data) || data.length < 10) {
@@ -366,7 +361,6 @@ export const AddCustomActionModal = ({
     }
   };
 
-  // Clear the field and the function/args it was driving.
   const handleClearCalldata = () => {
     setCalldataField("");
     setFunctionName("");
diff --git a/apps/dashboard/features/create-proposal/components/modals/AddTransferModal.tsx b/apps/dashboard/features/create-proposal/components/modals/AddTransferModal.tsx
index 43134e81fb..362a88dc7a 100644
--- a/apps/dashboard/features/create-proposal/components/modals/AddTransferModal.tsx
+++ b/apps/dashboard/features/create-proposal/components/modals/AddTransferModal.tsx
@@ -4,7 +4,7 @@ import { Coins } from "lucide-react";
 import Image from "next/image";
 import { useParams } from "next/navigation";
 import { useEffect, useMemo, useState } from "react";
-import { erc20Abi, formatUnits, isAddress } from "viem";
+import { erc20Abi, formatUnits } from "viem";
 import { useBalance, usePublicClient, useReadContracts } from "wagmi";
 
 import { FormLabel } from "@/shared/components/design-system/form/fields/form-label/FormLabel";
@@ -12,6 +12,7 @@ import { Input } from "@/shared/components/design-system/form/fields/input/Input
 import { RadioCard } from "@/shared/components/design-system/form/fields/radio-card/RadioCard";
 import { Modal } from "@/shared/components/design-system/modal/Modal";
 import daoConfig from "@/shared/dao-config";
+import { isAddressLike } from "@/shared/utils/address";
 import { isEnsAddress } from "@/shared/utils/ens";
 
 import { useEthPrice } from "@/shared/hooks/useEthPrice";
@@ -68,7 +69,6 @@ export const AddTransferModal = ({
   const [tokenAddressTouched, setTokenAddressTouched] = useState(false);
   const [recipientTouched, setRecipientTouched] = useState(false);
 
-  // Re-hydrate fields whenever the modal opens with a new initialValue
   useEffect(() => {
     if (!open) return;
     setDecimalsError(null);
@@ -94,14 +94,12 @@ export const AddTransferModal = ({
     governanceChainId ? { chainId: governanceChainId } : undefined,
   );
 
-  // The timelock is the treasury that actually pays when the proposal executes,
-  // so balances/limits are measured against it — not the author's wallet.
   const treasuryAddress =
     daoConfig[daoIdEnum]?.daoOverview?.contracts?.timelock;
 
   const tokenAddressTrimmed = tokenAddress.trim();
   const isErc20WithAddress =
-    tokenType === "erc20" && isAddress(tokenAddressTrimmed);
+    tokenType === "erc20" && isAddressLike(tokenAddressTrimmed);
 
   const { data: ethBalance } = useBalance({
     address: treasuryAddress,
@@ -136,7 +134,6 @@ export const AddTransferModal = ({
 
   const suggestedTokens = SUGGESTED_TRANSFER_TOKENS[daoIdEnum] ?? [];
 
-  // Available treasury balance for the selected asset (human-readable).
   const available = useMemo<{
     formatted: string;
     symbol: string;
@@ -186,17 +183,17 @@ export const AddTransferModal = ({
   const recipientTrimmed = recipient.trim();
   const recipientIsValid =
     recipientTrimmed !== "" &&
-    (isAddress(recipientTrimmed) || isEnsAddress(recipientTrimmed));
+    (isAddressLike(recipientTrimmed) || isEnsAddress(recipientTrimmed));
   const recipientError =
     recipientTouched && recipientTrimmed !== "" && !recipientIsValid;
   const tokenAddressError =
     tokenAddressTouched &&
     tokenAddress.trim() !== "" &&
-    !isAddress(tokenAddress.trim());
+    !isAddressLike(tokenAddress);
   const recipientValid = recipientIsValid;
   const tokenAddressValid =
     tokenType === "eth" ||
-    (tokenAddress.trim() !== "" && isAddress(tokenAddress.trim()));
+    (tokenAddress.trim() !== "" && isAddressLike(tokenAddress));
 
   const amountTrimmed = amount.trim();
   const amountIsValid =
diff --git a/apps/dashboard/features/create-proposal/components/modals/ImportJsonModal.tsx b/apps/dashboard/features/create-proposal/components/modals/ImportJsonModal.tsx
new file mode 100644
index 0000000000..f5070a2bfe
--- /dev/null
+++ b/apps/dashboard/features/create-proposal/components/modals/ImportJsonModal.tsx
@@ -0,0 +1,445 @@
+"use client";
+
+import {
+  CircleAlert,
+  CircleCheck,
+  CircleDashed,
+  Copy,
+  Check,
+  Upload,
+} from "lucide-react";
+import { useParams } from "next/navigation";
+import { useEffect, useRef, useState } from "react";
+import { erc20Abi } from "viem";
+import { usePublicClient } from "wagmi";
+
+import { cn } from "@/shared/utils/cn";
+import { Button } from "@/shared/components/design-system/buttons/button/Button";
+import { FormLabel } from "@/shared/components/design-system/form/fields/form-label/FormLabel";
+import { JsonTextarea } from "@/features/create-proposal/components/JsonTextarea";
+import { Modal } from "@/shared/components/design-system/modal/Modal";
+import daoConfig from "@/shared/dao-config";
+import type { DaoIdEnum } from "@/shared/types/daos";
+import {
+  PROPOSAL_IMPORT_SPEC,
+  PROPOSAL_JSON_PLACEHOLDER,
+} from "@/features/create-proposal/constants";
+import { rangeOfLine } from "@/features/create-proposal/utils/jsonSource";
+import type { ProposalFormValues } from "@/features/create-proposal/schema";
+import type { ImportedProposal } from "@/features/create-proposal/utils/importHandoff";
+import {
+  formatImportIssue,
+  parseProposalJson,
+  type ImportIssue,
+} from "@/features/create-proposal/utils/parseProposalJson";
+import {
+  needsDecimalsLookup,
+  resolveImportedDecimals,
+} from "@/features/create-proposal/utils/resolveImportedDecimals";
+
+interface ImportJsonModalProps {
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  onImport: (values: ImportedProposal) => boolean;
+}
+
+const MAX_UPLOAD_BYTES = 1_000_000;
+
+const VALIDATE_DEBOUNCE_MS = 300;
+
+const describeValid = (actionCount: number | undefined): string =>
+  actionCount === undefined
+    ? "Valid"
+    : `Valid · ${actionCount} action${actionCount === 1 ? "" : "s"}`;
+
+const describeIssues = (issues: readonly ImportIssue[]): string => {
+  const [first] = issues;
+  if (!first) return "";
+
+  const what = formatImportIssue(first);
+  if (issues.length === 1) {
+    return first.line ? `Line ${first.line} · ${what}` : what;
+  }
+  const where = first.line ? ` · first on line ${first.line}` : "";
+  return `${issues.length} problems${where} · ${what}`;
+};
+
+type ValidationState =
+  | { kind: "idle" }
+  | { kind: "valid"; actionCount: number | undefined }
+  | { kind: "invalid"; issues: ImportIssue[] };
+
+const StatusRow = ({
+  tone,
+  icon: Icon,
+  children,
+}: {
+  tone: string;
+  icon: typeof CircleCheck;
+  children: React.ReactNode;
+}) => (
+  <p className={cn("flex h-4 items-center gap-1.5 text-xs", tone)}>
+    <Icon className="size-3.5 shrink-0 fill-none stroke-current" />
+    <span className="truncate">{children}</span>
+  </p>
+);
+
+const ValidationStatus = ({ state }: { state: ValidationState }) => {
+  if (state.kind === "valid") {
+    return (
+      <StatusRow tone="text-success" icon={CircleCheck}>
+        {describeValid(state.actionCount)}
+      </StatusRow>
+    );
+  }
+
+  if (state.kind === "invalid") {
+    return (
+      <StatusRow tone="text-error" icon={CircleAlert}>
+        {describeIssues(state.issues)}
+      </StatusRow>
+    );
+  }
+
+  return (
+    <StatusRow tone="text-secondary" icon={CircleDashed}>
+      Not validated yet.
+    </StatusRow>
+  );
+};
+
+const CopyButton = ({ label, value }: { label: string; value: string }) => {
+  const [hasCopied, setHasCopied] = useState(false);
+
+  useEffect(() => {
+    if (!hasCopied) return;
+    const timer = setTimeout(() => setHasCopied(false), 2000);
+    return () => clearTimeout(timer);
+  }, [hasCopied]);
+
+  const copy = async () => {
+    try {
+      await navigator.clipboard.writeText(value);
+    } catch {
+      return;
+    }
+    setHasCopied(true);
+  };
+
+  return (
+    <Button
+      variant="outline"
+      size="sm"
+      onClick={() => void copy()}
+      className="shrink-0 gap-1.5"
+    >
+      {hasCopied ? (
+        <Check className="size-3.5" />
+      ) : (
+        <Copy className="size-3.5" />
+      )}
+      {label}
+    </Button>
+  );
+};
+
+export const ImportJsonModal = ({
+  open,
+  onOpenChange,
+  onImport,
+}: ImportJsonModalProps) => {
+  const { daoId: daoIdParam } = useParams<{ daoId: string }>();
+  const daoIdEnum = (daoIdParam ?? "").toUpperCase() as DaoIdEnum;
+  const chainId = daoConfig[daoIdEnum]?.daoOverview?.chain?.id;
+  const publicClient = usePublicClient(chainId ? { chainId } : undefined);
+
+  const [text, setText] = useState(PROPOSAL_JSON_PLACEHOLDER);
+  const [validation, setValidation] = useState<ValidationState>({
+    kind: "idle",
+  });
+
+  // The untouched template carries "0x..." where addresses go, so validating it would
+  // open the dialog on an error about a document the author never wrote.
+  const isUntouched = text === PROPOSAL_JSON_PLACEHOLDER;
+  // Tagged by scope: an upload failure belongs beside the file button, a content
+  // failure beneath the textarea. One untagged slot painted the textarea as invalid
+  // whenever a file was rejected, even though the pasted document in it was fine.
+  const [error, setError] = useState<{
+    scope: "file" | "content";
+    message: string;
+  } | null>(null);
+  const [isResolving, setIsResolving] = useState(false);
+  const [fileName, setFileName] = useState<string | null>(null);
+  const fileInputRef = useRef<HTMLInputElement>(null);
+  const textareaRef = useRef<HTMLTextAreaElement>(null);
+
+  // Cancel, Escape and the close button stay live while decimals are being read, and
+  // the lookup keeps running after the sheet is gone. Every attempt takes a ticket; a
+  // result whose ticket is no longer current is dropped, so a cancelled paste cannot
+  // land on the form later.
+  const attemptRef = useRef(0);
+
+  const clear = () => {
+    setText(PROPOSAL_JSON_PLACEHOLDER);
+    setError(null);
+    setValidation({ kind: "idle" });
+    setIsResolving(false);
+    setFileName(null);
+  };
+
+  useEffect(() => {
+    if (!open) return;
+    attemptRef.current += 1;
+    clear();
+  }, [open]);
+
+  useEffect(() => {
+    if (text === PROPOSAL_JSON_PLACEHOLDER || !text.trim()) {
+      setValidation({ kind: "idle" });
+      return;
+    }
+    const timer = setTimeout(() => {
+      const result = parseProposalJson(text);
+      setValidation(
+        result.ok
+          ? { kind: "valid", actionCount: result.value.actions?.length }
+          : { kind: "invalid", issues: result.issues },
+      );
+    }, VALIDATE_DEBOUNCE_MS);
+    return () => clearTimeout(timer);
+  }, [text]);
+
+  const close = () => {
+    attemptRef.current += 1;
+    clear();
+    onOpenChange(false);
+  };
+
+  const replaceText = (next: string) => {
+    attemptRef.current += 1;
+    setText(next);
+    setError(null);
+  };
+
+  const loadFile = async (file: File) => {
+    const attempt = ++attemptRef.current;
+
+    if (file.size > MAX_UPLOAD_BYTES) {
+      setError({
+        scope: "file",
+        message: "That file is too large to be a proposal document.",
+      });
+      return;
+    }
+
+    let contents: string;
+    try {
+      contents = await file.text();
+    } catch {
+      if (attemptRef.current !== attempt) return;
+      setError({ scope: "file", message: "Couldn't read that file." });
+      return;
+    }
+
+    if (attemptRef.current !== attempt) return;
+    setText(contents);
+    setFileName(file.name);
+    setError(null);
+  };
+
+  /** MOD-14: Import stays enabled while the document is invalid, because a greyed out
+   *  button says nothing about what is wrong. Pressing it goes to the first problem. */
+  const focusFirstIssue = (issues: readonly ImportIssue[]) => {
+    const textarea = textareaRef.current;
+    if (!textarea) return;
+    textarea.focus();
+    const line = issues.find((issue) => issue.line)?.line;
+    if (!line) return;
+    const { start, end } = rangeOfLine(text, line);
+    textarea.setSelectionRange(start, end);
+    const lineHeight =
+      textarea.scrollHeight / Math.max(1, text.split("\n").length);
+    textarea.scrollTop = Math.max(0, (line - 2) * lineHeight);
+  };
+
+  const handleConfirm = async () => {
+    const attempt = ++attemptRef.current;
+
+    const result = parseProposalJson(text);
+    if (!result.ok) {
+      setValidation({ kind: "invalid", issues: result.issues });
+      focusFirstIssue(result.issues);
+      return;
+    }
+
+    const pending = result.value.actions;
+    let actions: ProposalFormValues["actions"] | undefined;
+
+    if (pending) {
+      const needsChain = needsDecimalsLookup(pending);
+      if (needsChain && !publicClient) {
+        setError({
+          scope: "content",
+          message:
+            "No RPC client available to read the token decimals. Reconnect your wallet and try again.",
+        });
+        return;
+      }
+
+      if (needsChain) setIsResolving(true);
+      let resolved;
+      try {
+        resolved = await resolveImportedDecimals(
+          pending,
+          async (tokenAddress) => {
+            if (!publicClient) throw new Error("No RPC client");
+            return Number(
+              await publicClient.readContract({
+                abi: erc20Abi,
+                address: tokenAddress as `0x${string}`,
+                functionName: "decimals",
+              }),
+            );
+          },
+        );
+      } finally {
+        if (needsChain) setIsResolving(false);
+      }
+
+      if (attemptRef.current !== attempt) return;
+
+      if (!resolved.ok) {
+        setError({ scope: "content", message: resolved.error });
+        return;
+      }
+      actions = resolved.actions;
+    }
+
+    if (!onImport({ ...result.value, actions })) return;
+    close();
+  };
+
+  return (
+    <Modal
+      open={open}
+      onOpenChange={(o) => {
+        if (!o) {
+          close();
+          return;
+        }
+        onOpenChange(o);
+      }}
+      title="Import proposal"
+      description="Paste a proposal, or drop a file anywhere in this dialog."
+      cancelLabel="Cancel"
+      confirmLabel="Import"
+      onCancel={close}
+      onConfirm={() => {
+        void handleConfirm();
+      }}
+      isConfirmDisabled={isUntouched || text.trim().length === 0 || isResolving}
+      isConfirmLoading={isResolving}
+    >
+      {/* Anywhere in the dialog, as the subtitle promises. Without both handlers
+          the browser navigates away to the dropped file instead of handing it
+          over. */}
+      <div
+        className="flex flex-col gap-3"
+        onDragOver={(e) => e.preventDefault()}
+        onDrop={(e) => {
+          const file = e.dataTransfer.files?.[0];
+          if (!file) return;
+          e.preventDefault();
+          void loadFile(file);
+        }}
+      >
+        <div className="flex flex-col gap-1.5">
+          <div className="flex items-center justify-between gap-3">
+            {/* No asterisk: it is the only field in the dialog, and the Import
+                button's state already carries required-ness. */}
+            <FormLabel>Proposal .json</FormLabel>
+            <div className="flex items-center gap-2">
+              {/* A rejected file says so here, next to the button that picked
+                  it. Reported on the textarea it would mark content that is
+                  still perfectly valid, and still importable, as the thing at
+                  fault. */}
+              {error?.scope === "file" && (
+                <span className="text-error truncate text-xs">
+                  {error.message}
+                </span>
+              )}
+              {error?.scope !== "file" && fileName && (
+                <span className="text-secondary max-w-40 truncate text-xs">
+                  {fileName}
+                </span>
+              )}
+              <Button
+                variant="outline"
+                size="sm"
+                onClick={() => fileInputRef.current?.click()}
+                className="shrink-0 gap-1.5"
+              >
+                <Upload className="size-3.5" />
+                Upload .json
+              </Button>
+            </div>
+          </div>
+          <JsonTextarea
+            ref={textareaRef}
+            value={text}
+            onChange={(next) => {
+              replaceText(next);
+              setFileName(null);
+            }}
+            placeholder={PROPOSAL_JSON_PLACEHOLDER}
+            className="h-60"
+            showLineNumbers
+            hasError={
+              error?.scope === "content" || validation.kind === "invalid"
+            }
+            errorLine={
+              validation.kind === "invalid"
+                ? validation.issues.find((issue) => issue.line)?.line
+                : undefined
+            }
+            ariaLabel="Proposal .json"
+          />
+          <input
+            ref={fileInputRef}
+            type="file"
+            accept="application/json,.json"
+            className="hidden"
+            onChange={(e) => {
+              const file = e.target.files?.[0];
+              if (file) void loadFile(file);
+              e.target.value = "";
+            }}
+          />
+          {error?.scope === "content" ? (
+            <StatusRow tone="text-error" icon={CircleAlert}>
+              {error.message}
+            </StatusRow>
+          ) : (
+            <ValidationStatus state={validation} />
+          )}
+        </div>
+
+        {/* Two sentences, and only two. Anything validation catches is not
+            pre-announced; these two survive because validation cannot catch
+            them. The first is a consequence of correct input, and the second is
+            undetectable, since "1000000000000000000" is a legal amount string
+            and the parser has no way to know it was meant as wei. */}
+        <div className="border-border-default rounded-base flex items-center justify-between gap-3 border p-3">
+          <p className="text-secondary text-xs">
+            Only fields present in the document are replaced.
+            <br />
+            Amounts are in ETH, not wei.
+          </p>
+          {/* No companion button for the template: it is the field's own value
+              now, so it can be selected and copied where it sits. */}
+          <CopyButton label="Copy spec for AI" value={PROPOSAL_IMPORT_SPEC} />
+        </div>
+      </div>
+    </Modal>
+  );
+};
diff --git a/apps/dashboard/features/create-proposal/constants.ts b/apps/dashboard/features/create-proposal/constants.ts
index f5387b0f67..71e39919ae 100644
--- a/apps/dashboard/features/create-proposal/constants.ts
+++ b/apps/dashboard/features/create-proposal/constants.ts
@@ -2,12 +2,6 @@ import { type Address, getAddress } from "viem";
 
 import { DaoIdEnum } from "@/shared/types/daos";
 
-/**
- * Mirrors `BODY_MAX` in the user-api drafts mapper
- * (`apps/user-api/src/mappers/drafts/index.ts`). Draft save and share both
- * POST the body to that endpoint, which rejects anything longer — keep the two
- * in sync so the form fails with a field error instead of a generic toast.
- */
 export const BODY_CHAR_LIMIT = 100_000;
 export const BODY_WARNING_THRESHOLD = 95_000;
 
@@ -44,6 +38,69 @@ export const SUGGESTED_TRANSFER_TOKENS: Partial<
   ],
 };
 
+export const PROPOSAL_JSON_PLACEHOLDER = `{
+  "title": "Proposal title",
+  "discussionUrl": "https://discuss...",
+  "body": "## Synopsis\\n\\nMarkdown description.",
+  "actions": [
+    {"type": "eth-transfer", "recipient": "0x...", "amount": "600"},
+    {"type": "erc20-transfer", "tokenAddress": "0x...",
+     "recipient": "0x...", "amount": "480000"},
+    {"type": "custom", "contractAddress": "0x...",
+     "calldata": "0x..."}
+  ]
+}`;
+
+export const PROPOSAL_IMPORT_EXAMPLE = `{
+  "title": "Proposal title",
+  "discussionUrl": "https://discuss...",
+  "body": "## Synopsis\\n\\nMarkdown description.",
+  "actions": [
+    {"type": "eth-transfer", "recipient": "0x93a8f8072337F2D1Ff2D019761cE0ABa39723d7B", "amount": "600"},
+    {"type": "erc20-transfer", "tokenAddress": "0x06E98ADbc7C60fe88e7b03E927cDFF17d7D798A3", "recipient": "0x26D5EB37002152186ec86B9835ecAf32846bC0DD", "amount": "480000"},
+    {"type": "custom", "contractAddress": "0x73f9ccC34d14754dEfD9acdC9C4F4E37b184A639", "calldata": "0x1896f70a7a7b069bdf427c3e6d24c2c55ccd9fe71f5d9a6088733138764bb52de176915700000000000000000000000073f9ccc34d14754defd9acdc9c4f4e37b184a639"},
+    {"type": "custom", "contractAddress": "0x73f9ccC34d14754dEfD9acdC9C4F4E37b184A639",
+     "functionName": "createStream",
+     "abi": [{"type": "function", "name": "createStream", "stateMutability": "nonpayable", "outputs": [],
+              "inputs": [{"name": "recipient", "type": "address"},
+                         {"name": "durations", "type": "tuple",
+                          "components": [{"name": "cliff", "type": "uint256"},
+                                         {"name": "total", "type": "uint256"}]}]}],
+     "args": ["0x26D5EB37002152186ec86B9835ecAf32846bC0DD", {"cliff": "2592000", "total": "7776000"}]}
+  ]
+}`;
+
+export const PROPOSAL_IMPORT_SPEC = `Anticapture: proposal import format (v1, 2026-08)
+
+Return a single JSON object and nothing else. No prose, no markdown fences.
+
+FIELDS
+  title           the proposal title
+  discussionUrl   an http(s) link to the forum thread
+  body            the description, in markdown
+  actions         one entry per action, keyed by type:
+
+    eth-transfer    recipient, and amount in ETH
+    erc20-transfer  also tokenAddress. Its decimals are read from the token,
+                    so never supply them
+    custom          contractAddress, then either functionName with abi and
+                    args, or raw calldata. Not both, not neither
+
+RULES
+- Every field is optional. Only fields present are replaced; omitted fields
+  keep their current value in the form.
+- Every figure must be a quoted string. Unquoted numbers lose precision.
+- Amounts are human-readable, never wei. "1.5" means 1.5 ETH.
+- recipient takes an address or an ENS name.
+- args has one entry per ABI input, in order. Integers, addresses and bytesN
+  are quoted strings; booleans stay booleans. A tuple is an object keyed by
+  component name, or an array in component order.
+- Addresses below are placeholders. Substitute the real ones.
+
+EXAMPLE
+
+${PROPOSAL_IMPORT_EXAMPLE}`;
+
 export const BODY_PLACEHOLDER = `## Synopsis
 
 State what the proposal does in one sentence.
diff --git a/apps/dashboard/features/create-proposal/index.ts b/apps/dashboard/features/create-proposal/index.ts
index 4c0f391c8a..ec6fb3d944 100644
--- a/apps/dashboard/features/create-proposal/index.ts
+++ b/apps/dashboard/features/create-proposal/index.ts
@@ -4,3 +4,10 @@ export { useDrafts } from "@/features/create-proposal/hooks/useDrafts";
 export { DraftCard } from "@/features/create-proposal/components/drafts/DraftCard";
 export { DraftEmptyState } from "@/features/create-proposal/components/drafts/DraftEmptyState";
 export { DeleteDraftModal } from "@/features/create-proposal/components/modals/DeleteDraftModal";
+export { NewProposalMenu } from "@/features/create-proposal/components/NewProposalMenu";
+export { ImportJsonModal } from "@/features/create-proposal/components/modals/ImportJsonModal";
+export {
+  clearImportedProposal,
+  stashImportedProposal,
+  type ImportedProposal,
+} from "@/features/create-proposal/utils/importHandoff";
diff --git a/apps/dashboard/features/create-proposal/schema.test.ts b/apps/dashboard/features/create-proposal/schema.test.ts
index e3e919dbfd..b50bb497c3 100644
--- a/apps/dashboard/features/create-proposal/schema.test.ts
+++ b/apps/dashboard/features/create-proposal/schema.test.ts
@@ -51,4 +51,63 @@ describe("ProposalFormSchema", () => {
         .success,
     ).toBe(false);
   });
+
+  describe("address casing", () => {
+    const withRecipient = (recipient: string) =>
+      ProposalFormSchema.safeParse({
+        ...valid,
+        actions: [{ ...valid.actions[0], recipient }],
+      });
+
+    const miscased = "0x39D3F4633dE1F5E2a1e2f4d3fD6d1AAf2E9c8b71";
+
+    test.each([
+      ["a miscased address", miscased, true],
+      ["the same address lowercased", miscased.toLowerCase(), true],
+      [
+        "the same address checksummed",
+        "0x39D3f4633de1F5E2A1E2f4D3fD6D1AAF2E9C8B71",
+        true,
+      ],
+      ["an ENS name", "vitalik.eth", true],
+      ["an address one character short", miscased.slice(0, -1), false],
+      ["a non-hex address", `0xZZ${miscased.slice(4)}`, false],
+      ["an address with no 0x prefix", miscased.slice(2), false],
+    ])("%s", (_label, recipient, accepted) => {
+      expect(withRecipient(recipient).success).toBe(accepted);
+    });
+  });
+
+  describe("amount precision", () => {
+    const withAmount = (action: Record<string, unknown>) =>
+      ProposalFormSchema.safeParse({
+        title: "t",
+        body: "b",
+        discussionUrl: "",
+        actions: [action],
+      });
+
+    const eth = (amount: string) => ({
+      type: "eth-transfer",
+      recipient: "0x1111111111111111111111111111111111111111",
+      amount,
+    });
+    const usdc = (amount: string) => ({
+      type: "erc20-transfer",
+      recipient: "0x1111111111111111111111111111111111111111",
+      tokenAddress: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
+      amount,
+      decimals: 6,
+    });
+
+    test.each([
+      ["ETH at 18 places", eth("0." + "1".repeat(18)), true],
+      ["ETH at 19 places", eth("0." + "1".repeat(19)), false],
+      ["a 6-decimal token at 6 places", usdc("0.123456"), true],
+      ["a 6-decimal token at 7 places", usdc("0.1234567"), false],
+      ["a 6-decimal token rounding to zero", usdc("0.0000001"), false],
+    ])("%s", (_label, action, valid) => {
+      expect(withAmount(action).success).toBe(valid);
+    });
+  });
 });
diff --git a/apps/dashboard/features/create-proposal/schema.ts b/apps/dashboard/features/create-proposal/schema.ts
index 7f10306b4e..3a29ca56b7 100644
--- a/apps/dashboard/features/create-proposal/schema.ts
+++ b/apps/dashboard/features/create-proposal/schema.ts
@@ -1,23 +1,43 @@
 import { z } from "zod";
-import { isAddress } from "viem";
 
 import { BODY_CHAR_LIMIT } from "@/features/create-proposal/constants";
+import { isAddressLike } from "@/shared/utils/address";
 import { isEnsAddress } from "@/shared/utils/ens";
+import { customActionIssues } from "@/features/create-proposal/utils/validateCustomAction";
 
-const addressOrEnsSchema = z
+/* The rules, in one place, for every entry point. An action the import accepts but
+ * the form rejects surfaces only as a Publish button that never enables — action
+ * rows draw no field errors — so there has to be one of them. */
+export const addressOrEnsSchema = z
   .string()
   .min(1, "Required")
   .refine((v) => {
     const trimmed = v.trim();
-    return isAddress(trimmed) || isEnsAddress(trimmed);
+    return isAddressLike(trimmed) || isEnsAddress(trimmed);
   }, "Must be a valid address or ENS name");
 
-const strictAddressSchema = z
+export const strictAddressSchema = z
   .string()
   .min(1, "Required")
-  .refine((v) => isAddress(v.trim()), "Must be a valid Ethereum address");
+  .refine((v) => isAddressLike(v), "Must be a valid Ethereum address");
 
-const positiveDecimalAmountSchema = z
+export const ETH_DECIMALS = 18;
+
+const fractionDigits = (amount: string): number =>
+  (amount.trim().split(".")[1] ?? "").length;
+
+/** `parseUnits` rounds an over-precise amount instead of refusing it: `0.0000001`
+ *  of a 6-decimal token becomes 0 base units and the proposal transfers nothing,
+ *  while `0.0000009` becomes 1. Nothing downstream notices. */
+export const amountPrecisionError = (
+  amount: string,
+  scale: number,
+): string | null =>
+  fractionDigits(amount) > scale
+    ? `Has more decimal places than this asset can hold (${scale})`
+    : null;
+
+export const positiveDecimalAmountSchema = z
   .string()
   .min(1, "Required")
   .refine((v) => /^\d+(\.\d+)?$/.test(v.trim()), "Must be a valid number")
@@ -37,9 +57,6 @@ const ERC20TransferSchema = z.object({
   decimals: z.number().int().nonnegative(),
 });
 
-// `functionName` is required only when `calldata` isn't provided. The
-// cross-field check happens via `superRefine` on the outer form schema below
-// so this object stays a plain `ZodObject` (required for discriminated unions).
 const CustomActionSchema = z.object({
   type: z.literal("custom"),
   contractAddress: addressOrEnsSchema,
@@ -50,46 +67,84 @@ const CustomActionSchema = z.object({
   value: z.string().optional(),
 });
 
-export const ProposalActionSchema = z.discriminatedUnion("type", [
-  EthTransferSchema,
-  ERC20TransferSchema,
-  CustomActionSchema,
-]);
+/** Attached to the action, not the form, which is what lets the import dialog hold
+ *  a pasted action to it before the form exists. */
+const refineCustomAction = (
+  action: z.infer<typeof CustomActionSchema>,
+  ctx: z.RefinementCtx,
+): void => {
+  customActionIssues(action).forEach(({ path, message }) => {
+    ctx.addIssue({ code: z.ZodIssueCode.custom, message, path });
+  });
+};
+
+export const ProposalActionSchema = z
+  .discriminatedUnion("type", [
+    EthTransferSchema,
+    ERC20TransferSchema,
+    CustomActionSchema,
+  ])
+  .superRefine((action, ctx) => {
+    if (action.type === "custom") refineCustomAction(action, ctx);
+  });
+
+/** The form's own members, with `decimals` left open: a pasted value is a claim
+ *  about someone else's contract, settled against the token before handoff. */
+export const PendingProposalActionSchema = z
+  .discriminatedUnion("type", [
+    EthTransferSchema,
+    ERC20TransferSchema.extend({
+      decimals: z.number().int().nonnegative().optional(),
+    }),
+    CustomActionSchema,
+  ])
+  .superRefine((action, ctx) => {
+    if (action.type === "custom") refineCustomAction(action, ctx);
+  });
+
+export const titleSchema = z.string().min(1, "Required");
+
+export const discussionUrlSchema = z
+  .string()
+  .optional()
+  .refine((v) => {
+    if (!v || v.trim() === "") return true;
+    try {
+      const url = new URL(v.trim());
+      return url.protocol === "http:" || url.protocol === "https:";
+    } catch {
+      return false;
+    }
+  }, "Must be a valid URL");
+
+export const bodySchema = z
+  .string()
+  .min(1, "Required")
+  .max(BODY_CHAR_LIMIT, "100,000 character limit");
 
 export const ProposalFormSchema = z
   .object({
-    title: z.string().min(1, "Required"),
-    discussionUrl: z
-      .string()
-      .optional()
-      .refine((v) => {
-        if (!v || v.trim() === "") return true;
-        try {
-          const url = new URL(v.trim());
-          return url.protocol === "http:" || url.protocol === "https:";
-        } catch {
-          return false;
-        }
-      }, "Must be a valid URL"),
-    body: z
-      .string()
-      .min(1, "Required")
-      .max(BODY_CHAR_LIMIT, "100,000 character limit"),
+    title: titleSchema,
+    discussionUrl: discussionUrlSchema,
+    body: bodySchema,
     actions: z
       .array(ProposalActionSchema)
       .min(1, "At least one action is required"),
   })
+  // Only what needs the whole action settled first: an ERC-20's scale is known only
+  // once `decimals` is filled in. Everything else lives on `ProposalActionSchema`,
+  // so the import sees it too.
   .superRefine((form, ctx) => {
     form.actions.forEach((action, index) => {
-      if (action.type !== "custom") return;
-      const hasCalldata =
-        !!action.calldata && action.calldata.trim().length > 0;
-      const hasFunctionName = action.functionName.length > 0;
-      if (!hasCalldata && !hasFunctionName) {
+      if (action.type === "custom") return;
+      const scale =
+        action.type === "erc20-transfer" ? action.decimals : ETH_DECIMALS;
+      const precision = amountPrecisionError(action.amount, scale);
+      if (precision) {
         ctx.addIssue({
           code: z.ZodIssueCode.custom,
-          message: "Required",
-          path: ["actions", index, "functionName"],
+          message: precision,
+          path: ["actions", index, "amount"],
         });
       }
     });
diff --git a/apps/dashboard/features/create-proposal/utils/abiSchema.ts b/apps/dashboard/features/create-proposal/utils/abiSchema.ts
new file mode 100644
index 0000000000..c1742ee33f
--- /dev/null
+++ b/apps/dashboard/features/create-proposal/utils/abiSchema.ts
@@ -0,0 +1,45 @@
+import { AbiParameter as AbiParameterSchema } from "abitype/zod";
+import type { AbiFunction, AbiParameter } from "viem";
+import { z } from "zod";
+
+import { shapeOf } from "@/features/create-proposal/utils/argTree";
+
+/* The Solidity type grammar lives in `abitype`, which viem is built on: uint257,
+ * uint255, bytes33, bytes0, fixed128x18 and a tuple with no components are all
+ * refused by its parameter schema, recursively. */
+
+/** Readable, not necessarily encodable — a looser question, and a separate one.
+ *  Judging readability with the grammar would drop the offending function from the
+ *  ABI list, losing the message that names the bad type. */
+const StructuralParameter: z.ZodType<{ type: string }> = z.lazy(() =>
+  z.object({
+    type: z.string(),
+    components: z.array(StructuralParameter).optional(),
+  }),
+);
+
+/** `abitype`'s own function schema requires `outputs` and `stateMutability`; a
+ *  hand-written minimal ABI carries neither and is exactly what people paste. */
+const AbiFunctionSchema = z.object({
+  type: z.literal("function"),
+  name: z.string().min(1),
+  inputs: z.array(StructuralParameter),
+});
+
+/** Validated, never rebuilt: these schemas strip `stateMutability`, which
+ *  `findAbiFunction` needs to keep `view` functions out of the list. */
+export const isWellFormedFunction = (item: unknown): item is AbiFunction =>
+  AbiFunctionSchema.safeParse(item).success;
+
+/** `function` is legal ABI that viem's encoder refuses (`InvalidAbiEncodingType`),
+ *  so it is the one thing the grammar accepts and this form cannot. */
+const declaresFunctionType = (param: AbiParameter): boolean => {
+  const shape = shapeOf(param);
+  if (shape.kind === "array") return declaresFunctionType(shape.element);
+  if (shape.kind === "tuple")
+    return shape.components.some(declaresFunctionType);
+  return shape.type === "function";
+};
+
+export const isEncodableParam = (param: AbiParameter): boolean =>
+  AbiParameterSchema.safeParse(param).success && !declaresFunctionType(param);
diff --git a/apps/dashboard/features/create-proposal/utils/argIssues.test.ts b/apps/dashboard/features/create-proposal/utils/argIssues.test.ts
new file mode 100644
index 0000000000..ec8216a9a9
--- /dev/null
+++ b/apps/dashboard/features/create-proposal/utils/argIssues.test.ts
@@ -0,0 +1,118 @@
+import type { AbiParameter } from "viem";
+
+import {
+  argIssues,
+  isArgComplete,
+} from "@/features/create-proposal/utils/argIssues";
+import type { ArgValue } from "@/features/create-proposal/utils/argTree";
+
+const param = (type: string, extra: Record<string, unknown> = {}) =>
+  ({ name: "value", type, ...extra }) as AbiParameter;
+
+const tuple = (...components: AbiParameter[]) => param("tuple", { components });
+
+const messages = (p: AbiParameter, value: ArgValue) =>
+  argIssues(p, value).map(
+    (issue) => `${issue.path.join(".")}: ${issue.message}`,
+  );
+
+/* Replaced three passes that answered the same question and disagreed: a boolean
+ * `isArgComplete`, a `tupleArityError` that re-walked for a better message, and the
+ * JSON import's own pass. This is the contract all three callers now share. */
+describe("argIssues", () => {
+  describe("leaves", () => {
+    it("accepts a value its type can hold", () => {
+      expect(argIssues(param("uint256"), "42")).toEqual([]);
+    });
+
+    it("calls a blank Required rather than malformed", () => {
+      expect(argIssues(param("uint256"), "  ")).toEqual([
+        { path: [], message: "Required" },
+      ]);
+    });
+
+    it("reports a value its type can't hold", () => {
+      expect(messages(param("uint8"), "999")).toEqual([
+        ": Exceeds uint8 max (255)",
+      ]);
+    });
+
+    it("refuses a list where a single value belongs", () => {
+      expect(messages(param("uint256"), ["1"])).toEqual([
+        ": must be a single value for uint256",
+      ]);
+    });
+  });
+
+  describe("arrays", () => {
+    it("accepts an empty dynamic array", () => {
+      expect(argIssues(param("uint256[]"), [])).toEqual([]);
+    });
+
+    it("names the offending element, not the argument", () => {
+      expect(messages(param("uint256[]"), ["1", "nope", "3"])).toEqual([
+        "1: Must be a non-negative integer (decimal or 0x hex)",
+      ]);
+    });
+
+    it("holds a fixed array to its declared length", () => {
+      expect(messages(param("uint8[3]"), ["1", "2"])).toEqual([
+        ": must hold exactly 3 entries for uint8[3], not 2",
+      ]);
+    });
+
+    it("refuses a value where an array belongs", () => {
+      expect(messages(param("uint256[]"), "1")).toEqual([
+        ": must be a JSON array for uint256[]",
+      ]);
+    });
+  });
+
+  describe("tuples", () => {
+    const durations = tuple(
+      param("uint256", { name: "cliff" }),
+      param("uint256", { name: "total" }),
+    );
+
+    it("accepts a tuple holding exactly its components", () => {
+      expect(argIssues(durations, ["100", "500"])).toEqual([]);
+    });
+
+    test.each([
+      [["100"], ": has 2 fields for tuple but was given 1"],
+      [["100", "500", "900"], ": has 2 fields for tuple but was given 3"],
+    ])("%j is refused for its arity", (value, expected) => {
+      expect(messages(durations, value)).toEqual([expected]);
+    });
+
+    it("names children after the components the abi names", () => {
+      expect(messages(durations, ["100", ""])).toEqual(["total: Required"]);
+    });
+
+    it("reaches a leaf nested two tuples deep", () => {
+      const schedule = tuple({ ...durations, name: "durations" });
+      expect(messages(schedule, [["1", "nope"]])).toEqual([
+        "durations.total: Must be a non-negative integer (decimal or 0x hex)",
+      ]);
+    });
+
+    it("falls back to the index for an unnamed component", () => {
+      expect(messages(tuple(param("uint256", { name: "" })), [""])).toEqual([
+        "0: Required",
+      ]);
+    });
+
+    it("reports the arity instead of the children it can no longer line up", () => {
+      expect(messages(durations, ["nope"])).toEqual([
+        ": has 2 fields for tuple but was given 1",
+      ]);
+    });
+  });
+
+  describe("isArgComplete", () => {
+    it("is the same question as a boolean", () => {
+      expect(isArgComplete(param("uint256"), "42")).toBe(true);
+      expect(isArgComplete(param("uint256"), "")).toBe(false);
+    });
+  });
+});
diff --git a/apps/dashboard/features/create-proposal/utils/argIssues.ts b/apps/dashboard/features/create-proposal/utils/argIssues.ts
new file mode 100644
index 0000000000..5bbd9dc6fa
--- /dev/null
+++ b/apps/dashboard/features/create-proposal/utils/argIssues.ts
@@ -0,0 +1,58 @@
+import type { AbiParameter } from "viem";
+
+import {
+  arityError,
+  shapeOf,
+  type ArgValue,
+} from "@/features/create-proposal/utils/argTree";
+import { validateSolidityArg } from "@/features/create-proposal/utils/validateArg";
+
+import type { Issue } from "@/features/create-proposal/utils/issues";
+
+/** The single answer to "can this argument be encoded as what it claims to be".
+ *  Was three: `isArgComplete` for the editor, `tupleArityError` for a better arity
+ *  message, and the JSON import's own pass — which disagreed with each other. */
+export const argIssues = (
+  param: AbiParameter,
+  value: ArgValue,
+  path: (string | number)[] = [],
+): Issue[] => {
+  const shape = shapeOf(param);
+
+  if (shape.kind === "leaf") {
+    if (typeof value !== "string") {
+      return [{ path, message: `must be a single value for ${shape.type}` }];
+    }
+    // Blank gets its own message: "is not a valid uint256" for an empty box reads
+    // as malformed rather than missing.
+    if (value.trim().length === 0) return [{ path, message: "Required" }];
+    const invalid = validateSolidityArg(shape.type, value);
+    return invalid ? [{ path, message: invalid }] : [];
+  }
+
+  if (!Array.isArray(value)) {
+    return [{ path, message: `must be a JSON array for ${param.type}` }];
+  }
+
+  // Reported instead of the children: with the wrong number of entries, every
+  // position past the first mismatch is compared with the wrong component.
+  const arity = arityError(param, shape, value.length);
+  if (arity) return [{ path, message: arity }];
+
+  if (shape.kind === "array") {
+    return value.flatMap((item, index) =>
+      argIssues(shape.element, item, [...path, index]),
+    );
+  }
+  // Named after the components where the ABI names them, so a problem three levels
+  // deep reads `args[0].durations.total` and not `args[0].2.1`.
+  return shape.components.flatMap((component, index) =>
+    argIssues(component, value[index] ?? "", [
+      ...path,
+      component.name || index,
+    ]),
+  );
+};
+
+export const isArgComplete = (param: AbiParameter, value: ArgValue): boolean =>
+  argIssues(param, value).length === 0;
diff --git a/apps/dashboard/features/create-proposal/utils/argTree.test.ts b/apps/dashboard/features/create-proposal/utils/argTree.test.ts
index 6b85b4d27e..012de53914 100644
--- a/apps/dashboard/features/create-proposal/utils/argTree.test.ts
+++ b/apps/dashboard/features/create-proposal/utils/argTree.test.ts
@@ -6,6 +6,7 @@ import {
   buildEmpty,
   parseArrayType,
   storageToArg,
+  storageToArgForDisplay,
   argToStorage,
   argsToTrees,
   treesToArgs,
@@ -21,8 +22,6 @@ const identityResolver = async (v: string) => v as `0x${string}`;
 const ADDR_A = "0x1111111111111111111111111111111111111111";
 const ADDR_B = "0x2222222222222222222222222222222222222222";
 
-// Re-parse composite JSON so comparisons ignore incidental whitespace and the
-// number-vs-string representation of scalar leaves.
 const normalize = (stored: string): unknown => {
   const t = stored.trim();
   if (t.startsWith("[") || t.startsWith("{")) {
@@ -131,9 +130,26 @@ describe("storage <-> tree round-trip", () => {
   });
 
   it("falls back to empty container for malformed composite storage", () => {
-    expect(storageToArg({ type: "uint256[]" } as never, "not json")).toEqual(
-      [],
-    );
+    expect(
+      storageToArgForDisplay({ type: "uint256[]" } as never, "not json"),
+    ).toEqual([]);
+  });
+
+  it("refuses that same malformed storage when the answer will be encoded", () => {
+    expect(() =>
+      storageToArg({ type: "uint256[]" } as never, "not json"),
+    ).toThrow();
+  });
+
+  it("degrades a tuple short of its components to the empty struct", () => {
+    const param = {
+      type: "tuple",
+      components: [
+        { name: "to", type: "address" },
+        { name: "memo", type: "string" },
+      ],
+    } as never;
+    expect(storageToArgForDisplay(param, `["${ADDR_A}"]`)).toEqual(["", ""]);
   });
 });
 
@@ -156,7 +172,6 @@ describe("argsToTrees / treesToArgs (top-level)", () => {
     const trees = argsToTrees(fn.inputs, args);
     const back = treesToArgs(fn.inputs, trees as ArgValue[]);
 
-    // Encoding through the existing pipeline must be byte-identical (AC8).
     const make = (a: string[]): CustomAction => ({
       type: "custom",
       contractAddress: ADDR_A,
@@ -168,6 +183,20 @@ describe("argsToTrees / treesToArgs (top-level)", () => {
     const after = await encodeActions([make(back)], identityResolver);
     expect(after.calldatas[0]).toBe(before.calldatas[0]);
   });
+
+  it("refuses an arg count the inputs don't account for", () => {
+    const inputs = [
+      { name: "amount", type: "uint256" },
+      { name: "to", type: "address" },
+    ] as const;
+
+    expect(() => argsToTrees(inputs, ["100"])).toThrow(
+      /Expected 2 arguments, got 1/,
+    );
+    expect(() => argsToTrees(inputs, ["100", ADDR_B, "extra"])).toThrow(
+      /Expected 2 arguments, got 3/,
+    );
+  });
 });
 
 describe("treesToEncodeValues (live preview)", () => {
diff --git a/apps/dashboard/features/create-proposal/utils/argTree.ts b/apps/dashboard/features/create-proposal/utils/argTree.ts
index 57cd9f7663..2722ee3eb2 100644
--- a/apps/dashboard/features/create-proposal/utils/argTree.ts
+++ b/apps/dashboard/features/create-proposal/utils/argTree.ts
@@ -5,20 +5,10 @@ import {
   type Hex,
 } from "viem";
 
-/**
- * Editable value tree for a function argument. A scalar (uint, int, address,
- * bool, bytes, string) is a plain string; an array or tuple is a list of child
- * values. This mirrors exactly the JSON shape the encoder (`encodeActions` →
- * `parseArg`) already expects, so a tree serializes back to the existing
- * `CustomAction.args` (`string[]`) format with no encoding change and full
- * backwards-compat with saved drafts.
- */
 export type ArgValue = string | ArgValue[];
 
 type ArrayInfo = { elementType: string; length: number | null };
 
-/** Parses a trailing `[]` or `[k]` off a Solidity type. Returns null for
- *  non-array types (incl. bare `tuple`). */
 export const parseArrayType = (type: string): ArrayInfo | null => {
   const match = type.match(/^(.*)\[(\d*)\]$/);
   if (!match) return null;
@@ -28,26 +18,66 @@ export const parseArrayType = (type: string): ArrayInfo | null => {
 const getComponents = (param: AbiParameter): readonly AbiParameter[] =>
   (param as { components?: readonly AbiParameter[] }).components ?? [];
 
+/** What a parameter is, decided once. Every walk over an `AbiParameter` starts
+ *  with the same array/tuple/leaf question; that preamble was copied into ten
+ *  functions across four files, and the copies drifted. */
+export type ParamShape =
+  | { kind: "array"; element: AbiParameter; length: number | null }
+  | { kind: "tuple"; components: readonly AbiParameter[] }
+  | { kind: "leaf"; type: string };
+
+export const shapeOf = (param: AbiParameter): ParamShape => {
+  const array = parseArrayType(param.type);
+  if (array) {
+    return {
+      kind: "array",
+      element: { ...param, type: array.elementType } as AbiParameter,
+      length: array.length,
+    };
+  }
+  if (param.type === "tuple") {
+    return { kind: "tuple", components: getComponents(param) };
+  }
+  return { kind: "leaf", type: param.type };
+};
+
 const isComposite = (type: string): boolean =>
   parseArrayType(type) !== null || type === "tuple" || type.startsWith("tuple");
 
-/** The AbiParameter describing one element of an array param (keeps the base
- *  tuple's `components`). */
-const elementParam = (param: AbiParameter, elementType: string): AbiParameter =>
-  ({ ...param, type: elementType }) as AbiParameter;
+export const expectedLength = (shape: ParamShape): number | null => {
+  if (shape.kind === "tuple") return shape.components.length;
+  if (shape.kind === "array") return shape.length;
+  return null;
+};
 
-/** Builds the empty value for a param: "" for scalars, [] for dynamic arrays,
- *  k empties for fixed arrays, one empty per component for tuples. */
-export const buildEmpty = (param: AbiParameter): ArgValue => {
-  const arr = parseArrayType(param.type);
-  if (arr) {
-    if (arr.length === null) return [];
-    const child = elementParam(param, arr.elementType);
-    return Array.from({ length: arr.length }, () => buildEmpty(child));
+/** The one place a container's declared size is compared with what it holds. Both
+ *  halves matter: an extra entry is dropped on the way to the encoder, and a
+ *  missing one used to become "", which encodes as a real zero-length field the
+ *  document never described. Either way the calldata contradicts the row. */
+export const arityError = (
+  param: AbiParameter,
+  shape: ParamShape,
+  count: number,
+): string | null => {
+  const expected = expectedLength(shape);
+  if (expected === null || expected === count) return null;
+  if (shape.kind === "tuple") {
+    const fields = expected === 1 ? "field" : "fields";
+    return `has ${expected} ${fields} for ${param.type} but was given ${count}`;
   }
-  if (param.type === "tuple") {
-    return getComponents(param).map((c) => buildEmpty(c));
+  const entries = expected === 1 ? "entry" : "entries";
+  return `must hold exactly ${expected} ${entries} for ${param.type}, not ${count}`;
+};
+
+export const buildEmpty = (param: AbiParameter): ArgValue => {
+  const shape = shapeOf(param);
+  if (shape.kind === "array") {
+    if (shape.length === null) return [];
+    return Array.from({ length: shape.length }, () =>
+      buildEmpty(shape.element),
+    );
   }
+  if (shape.kind === "tuple") return shape.components.map(buildEmpty);
   return "";
 };
 
@@ -58,13 +88,49 @@ const scalarToString = (value: unknown): string => {
   return typeof value === "string" ? value : String(value);
 };
 
-/** Recursively coerces any parsed/decoded value into a string-leaved ArgValue
- *  so the UI always edits strings, regardless of the source representation. */
-const coerce = (value: unknown): ArgValue =>
-  Array.isArray(value) ? value.map(coerce) : scalarToString(value);
+const describeLeaf = (value: unknown): string => {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "a list";
+  return `a ${typeof value}`;
+};
+
+const coerceStrict = (
+  param: AbiParameter,
+  value: unknown,
+  subject: string,
+): ArgValue => {
+  const shape = shapeOf(param);
+
+  if (shape.kind !== "leaf") {
+    if (!Array.isArray(value)) {
+      throw new Error(
+        `${subject} must be a JSON array for ${param.type}, got ${describeLeaf(value)}.`,
+      );
+    }
+    const arity = arityError(param, shape, value.length);
+    if (arity) throw new Error(`${subject} ${arity}.`);
+
+    if (shape.kind === "array") {
+      return value.map((item) => coerceStrict(shape.element, item, subject));
+    }
+    return shape.components.map((component, i) =>
+      coerceStrict(component, value[i], subject),
+    );
+  }
+
+  if (typeof value === "string") return value;
+  if (
+    typeof value === "number" ||
+    typeof value === "bigint" ||
+    typeof value === "boolean"
+  ) {
+    return scalarToString(value);
+  }
+  throw new Error(
+    `${subject} has ${describeLeaf(value)} where ${param.type} expects a value.`,
+  );
+};
 
-/** Serializes a single top-level arg tree back to its stored string form:
- *  scalars stay as-is; composites become JSON. */
 export const argToStorage = (param: AbiParameter, value: ArgValue): string => {
   if (!isComposite(param.type)) {
     return typeof value === "string" ? value : JSON.stringify(value);
@@ -72,23 +138,63 @@ export const argToStorage = (param: AbiParameter, value: ArgValue): string => {
   return JSON.stringify(value);
 };
 
-/** Parses a stored arg string into an editable tree. Composites are JSON; a
- *  blank or malformed composite degrades to the empty container. */
+/** Strict: anything judging completeness, previewing, or encoding comes through
+ *  here. The forgiving variant below reports a malformed `uint256[]` as `[]`,
+ *  which encodes to valid calldata for an empty array. */
 export const storageToArg = (param: AbiParameter, stored: string): ArgValue => {
   if (!isComposite(param.type)) return stored;
+
   const trimmed = (stored ?? "").trim();
-  if (!trimmed) return buildEmpty(param);
+  const subject = param.name ? `Argument "${param.name}"` : "Argument";
+  const reject = (): never => {
+    throw new Error(
+      `${subject} must be a JSON array for ${param.type}, got ${trimmed || "nothing"}.`,
+    );
+  };
+
+  let parsed: unknown;
   try {
-    return coerce(JSON.parse(trimmed));
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return reject();
+  }
+  return coerceStrict(param, parsed, subject);
+};
+
+/** Rendering only. Every bug in this file's history came from a caller reaching
+ *  for this to judge completeness, preview, or encode. */
+export const storageToArgForDisplay = (
+  param: AbiParameter,
+  stored: string,
+): ArgValue => {
+  try {
+    return storageToArg(param, stored);
   } catch {
     return buildEmpty(param);
   }
 };
 
+export const argsToTreesForDisplay = (
+  inputs: readonly AbiParameter[],
+  args: readonly string[],
+): ArgValue[] =>
+  inputs.map((input, i) => storageToArgForDisplay(input, args[i] ?? ""));
+
+/** Throws rather than padding: mapping over the ABI's inputs alone reads a missing
+ *  arg as "" and drops an extra one, so `setMessage(string)` with `args: []` would
+ *  encode an empty string instead of failing. */
 export const argsToTrees = (
   inputs: readonly AbiParameter[],
   args: readonly string[],
-): ArgValue[] => inputs.map((input, i) => storageToArg(input, args[i] ?? ""));
+): ArgValue[] => {
+  if (args.length !== inputs.length) {
+    const expected = inputs.length === 1 ? "argument" : "arguments";
+    throw new Error(
+      `Expected ${inputs.length} ${expected}, got ${args.length}.`,
+    );
+  }
+  return inputs.map((input, i) => storageToArg(input, args[i] ?? ""));
+};
 
 export const treesToArgs = (
   inputs: readonly AbiParameter[],
@@ -96,36 +202,32 @@ export const treesToArgs = (
 ): string[] =>
   inputs.map((input, i) => argToStorage(input, trees[i] ?? buildEmpty(input)));
 
-/**
- * Coerces a value tree into the shape viem's encoders expect: tuples become
- * positional arrays, bools become real booleans, and scalars pass through as
- * strings (viem accepts decimal/hex strings for uint/int/bytes and 0x strings
- * for address). Used for the live calldata preview — addresses are passed
- * through verbatim (no ENS resolution), so the preview only succeeds once
- * addresses are concrete.
- */
 export const treeToEncodeValue = (
   param: AbiParameter,
   value: ArgValue,
 ): unknown => {
-  const arr = parseArrayType(param.type);
-  if (arr) {
-    const child = elementParam(param, arr.elementType);
+  const shape = shapeOf(param);
+  if (shape.kind === "array") {
     return (Array.isArray(value) ? value : []).map((v) =>
-      treeToEncodeValue(child, v),
+      treeToEncodeValue(shape.element, v),
     );
   }
-  if (param.type === "tuple") {
-    const components = getComponents(param);
+  if (shape.kind === "tuple") {
     const items = Array.isArray(value) ? value : [];
-    return components.map((c, i) => treeToEncodeValue(c, items[i] ?? ""));
+    return shape.components.map((c, i) => treeToEncodeValue(c, items[i] ?? ""));
   }
+  if (typeof value !== "string") return value;
+
+  // The one place scalar text is normalized, so validation, the preview and the
+  // published calldata cannot disagree. `string` is the exception: its whitespace
+  // is part of the value.
+  const scalar = param.type === "string" ? value : value.trim();
+
   if (param.type === "bool") {
-    if (value === "true") return true;
-    if (value === "false") return false;
-    return value;
+    if (scalar === "true") return true;
+    if (scalar === "false") return false;
   }
-  return value;
+  return scalar;
 };
 
 export const treesToEncodeValues = (
@@ -136,32 +238,62 @@ export const treesToEncodeValues = (
     treeToEncodeValue(input, trees[i] ?? buildEmpty(input)),
   );
 
-/** Converts a viem-decoded value into our string-leaved ArgValue, mapping
- *  decoded tuples (objects or arrays) back to positional component order. */
+/** Done as a separate pass so previewed and published calldata run the same
+ *  `treesToEncodeValues`; only ENS resolution differs between them. */
+export const resolveAddressLeaves = async (
+  param: AbiParameter,
+  value: ArgValue,
+  resolve: (nameOrAddress: string) => Promise<`0x${string}`>,
+): Promise<ArgValue> => {
+  const shape = shapeOf(param);
+  const items = Array.isArray(value) ? value : [];
+
+  if (shape.kind === "array") {
+    return Promise.all(
+      items.map((v) => resolveAddressLeaves(shape.element, v, resolve)),
+    );
+  }
+
+  if (shape.kind === "tuple") {
+    return Promise.all(
+      shape.components.map((c, i) =>
+        resolveAddressLeaves(c, items[i] ?? "", resolve),
+      ),
+    );
+  }
+
+  if (shape.type !== "address" || typeof value !== "string") return value;
+  return resolve(value);
+};
+
+export const resolveAddressesInTrees = (
+  inputs: readonly AbiParameter[],
+  trees: readonly ArgValue[],
+  resolve: (nameOrAddress: string) => Promise<`0x${string}`>,
+): Promise<ArgValue[]> =>
+  Promise.all(
+    inputs.map((input, i) =>
+      resolveAddressLeaves(input, trees[i] ?? buildEmpty(input), resolve),
+    ),
+  );
+
 const decodedToArgValue = (param: AbiParameter, decoded: unknown): ArgValue => {
-  const arr = parseArrayType(param.type);
-  if (arr) {
-    const child = elementParam(param, arr.elementType);
+  const shape = shapeOf(param);
+  if (shape.kind === "array") {
     return ((decoded as unknown[]) ?? []).map((d) =>
-      decodedToArgValue(child, d),
+      decodedToArgValue(shape.element, d),
     );
   }
-  if (param.type === "tuple") {
-    const components = getComponents(param);
+  if (shape.kind === "tuple") {
     if (Array.isArray(decoded)) {
-      return components.map((c, i) => decodedToArgValue(c, decoded[i]));
+      return shape.components.map((c, i) => decodedToArgValue(c, decoded[i]));
     }
     const obj = (decoded ?? {}) as Record<string, unknown>;
-    return components.map((c) => decodedToArgValue(c, obj[c.name ?? ""]));
+    return shape.components.map((c) => decodedToArgValue(c, obj[c.name ?? ""]));
   }
   return scalarToString(decoded);
 };
 
-/**
- * Decodes a raw calldata blob against a function ABI into the stored
- * `CustomAction.args` (`string[]`) format. Throws if the selector/shape doesn't
- * match the function — callers surface this as a "couldn't decode" error.
- */
 export const decodeCalldataToArgs = (
   fn: AbiFunction,
   calldata: Hex,
diff --git a/apps/dashboard/features/create-proposal/utils/encodeActions.test.ts b/apps/dashboard/features/create-proposal/utils/encodeActions.test.ts
index dfab6d8d82..b7c4adac06 100644
--- a/apps/dashboard/features/create-proposal/utils/encodeActions.test.ts
+++ b/apps/dashboard/features/create-proposal/utils/encodeActions.test.ts
@@ -2,6 +2,7 @@ import {
   encodeActions,
   makeAddressResolver,
 } from "@/features/create-proposal/utils/encodeActions";
+import { argsToTreesForDisplay } from "@/features/create-proposal/utils/argTree";
 import type { ProposalAction } from "@/features/create-proposal/types";
 import {
   parseEther,
@@ -13,6 +14,27 @@ import {
 
 const passthrough = makeAddressResolver(async () => null);
 
+describe("makeAddressResolver", () => {
+  const miscased = "0x39D3F4633dE1F5E2a1e2f4d3fD6d1AAf2E9c8b71";
+  const checksummed = "0x39D3f4633de1F5E2A1E2f4D3fD6D1AAF2E9C8B71";
+
+  test("normalizes a miscased address instead of treating it as a name", async () => {
+    const resolve = makeAddressResolver(async () => {
+      throw new Error("ENS lookup should not be reached for an address");
+    });
+    await expect(resolve(miscased)).resolves.toBe(checksummed);
+  });
+
+  test("still routes an actual name through ENS", async () => {
+    const resolve = makeAddressResolver(async () => checksummed);
+    await expect(resolve("vitalik.eth")).resolves.toBe(checksummed);
+  });
+
+  test("refuses something that is neither", async () => {
+    await expect(passthrough(miscased.slice(0, -1))).rejects.toThrow();
+  });
+});
+
 describe("encodeActions", () => {
   test("eth-transfer → target=recipient, value=wei, calldata=0x", async () => {
     const actions: ProposalAction[] = [
@@ -106,7 +128,6 @@ describe("encodeActions", () => {
         type: "custom",
         contractAddress: "0x5555555555555555555555555555555555555555",
         abi: overloadedAbi,
-        // The picker stores the full signature so overloads stay distinct.
         functionName: "execute(address,uint256)",
         args: ["0x6666666666666666666666666666666666666666", "42"],
       },
@@ -146,4 +167,276 @@ describe("encodeActions", () => {
       /Function "missing\(\)" not found/,
     );
   });
+
+  describe("arg conversion", () => {
+    const CONTRACT = "0x3333333333333333333333333333333333333333";
+    const abiWith = (type: string): Abi =>
+      [
+        {
+          type: "function",
+          name: "f",
+          stateMutability: "nonpayable",
+          inputs: [{ name: "a", type }],
+          outputs: [],
+        },
+      ] as Abi;
+
+    const encodeOne = (type: string, arg: string) =>
+      encodeActions(
+        [
+          {
+            type: "custom",
+            contractAddress: CONTRACT,
+            abi: abiWith(type),
+            functionName: "f",
+            args: [arg],
+          } as ProposalAction,
+        ],
+        passthrough,
+      );
+
+    test.each([
+      ["bool", " true ", "true"],
+      ["bytes32", ` 0x${"11".repeat(32)} `, `0x${"11".repeat(32)}`],
+      ["uint256", " 42 ", "42"],
+    ])(
+      "normalizes a %s arg the way validation reads it",
+      async (type, padded, tidy) => {
+        const [loose, exact] = await Promise.all([
+          encodeOne(type, padded),
+          encodeOne(type, tidy),
+        ]);
+        expect(loose.calldatas).toEqual(exact.calldatas);
+      },
+    );
+
+    test("keeps whitespace inside a string arg", async () => {
+      const { calldatas } = await encodeOne("string", "  urgent  ");
+      expect(calldatas[0]).toBe(
+        encodeFunctionData({
+          abi: abiWith("string"),
+          functionName: "f",
+          args: ["  urgent  "],
+        }),
+      );
+    });
+
+    test("takes a JSON bool array written with real booleans", async () => {
+      const { calldatas } = await encodeOne("bool[]", "[true, false]");
+      expect(calldatas[0]).toBe(
+        encodeFunctionData({
+          abi: abiWith("bool[]"),
+          functionName: "f",
+          args: [[true, false]],
+        }),
+      );
+    });
+
+    test("still refuses a fixed array of the wrong length", async () => {
+      await expect(encodeOne("uint256[2]", '["1"]')).rejects.toThrow();
+    });
+
+    describe("malformed composite args fail closed", () => {
+      test.each([
+        ["unparseable text", "not json"],
+        ["JSON that isn't an array", '"42"'],
+        ["JSON null", "null"],
+        ["nothing at all", ""],
+      ])("refuses a uint256[] arg holding %s", async (_case, arg) => {
+        await expect(encodeOne("uint256[]", arg)).rejects.toThrow(
+          /must be a JSON array for uint256\[\]/,
+        );
+      });
+
+      test("refuses a malformed tuple arg", async () => {
+        const tupleAbi = [
+          {
+            type: "function",
+            name: "f",
+            stateMutability: "nonpayable",
+            inputs: [
+              {
+                name: "order",
+                type: "tuple",
+                components: [
+                  { name: "id", type: "uint256" },
+                  { name: "owner", type: "address" },
+                ],
+              },
+            ],
+            outputs: [],
+          },
+        ] as Abi;
+        await expect(
+          encodeActions(
+            [
+              {
+                type: "custom",
+                contractAddress: CONTRACT,
+                abi: tupleAbi,
+                functionName: "f",
+                args: ["not json"],
+              } as ProposalAction,
+            ],
+            passthrough,
+          ),
+        ).rejects.toThrow(/must be a JSON array for tuple/);
+      });
+
+      test("an explicitly empty array is still encodable", async () => {
+        const { calldatas } = await encodeOne("uint256[]", "[]");
+        expect(calldatas[0]).toBe(
+          encodeFunctionData({
+            abi: abiWith("uint256[]"),
+            functionName: "f",
+            args: [[]],
+          }),
+        );
+      });
+
+      test.each([
+        ["a null element", "string[]", "[null]"],
+        ["an object element", "string[]", "[{}]"],
+        ["a null element", "uint256[]", "[1, null]"],
+      ])("refuses %s in a %s arg", async (_case, type, arg) => {
+        await expect(encodeOne(type, arg)).rejects.toThrow(/expects a value/);
+      });
+
+      test("refuses a nested list where the element is a scalar", async () => {
+        await expect(encodeOne("uint256[]", "[[1]]")).rejects.toThrow(
+          /expects a value/,
+        );
+      });
+
+      test("refuses a scalar where the element is a list", async () => {
+        await expect(encodeOne("uint256[][]", '["1"]')).rejects.toThrow(
+          /must be a JSON array for uint256\[\]/,
+        );
+      });
+
+      test("refuses a tuple carrying more entries than it has components", async () => {
+        const tupleAbi = [
+          {
+            type: "function",
+            name: "f",
+            stateMutability: "nonpayable",
+            inputs: [
+              {
+                name: "order",
+                type: "tuple",
+                components: [{ name: "id", type: "uint256" }],
+              },
+            ],
+            outputs: [],
+          },
+        ] as Abi;
+        await expect(
+          encodeActions(
+            [
+              {
+                type: "custom",
+                contractAddress: CONTRACT,
+                abi: tupleAbi,
+                functionName: "f",
+                args: ['["1","2"]'],
+              } as ProposalAction,
+            ],
+            passthrough,
+          ),
+        ).rejects.toThrow(/has 1 field for tuple but was given 2/);
+      });
+
+      test("refuses a tuple carrying fewer entries than it has components", async () => {
+        const tupleAbi = [
+          {
+            type: "function",
+            name: "f",
+            stateMutability: "nonpayable",
+            inputs: [
+              {
+                name: "order",
+                type: "tuple",
+                components: [{ name: "memo", type: "string" }],
+              },
+            ],
+            outputs: [],
+          },
+        ] as Abi;
+        await expect(
+          encodeActions(
+            [
+              {
+                type: "custom",
+                contractAddress: CONTRACT,
+                abi: tupleAbi,
+                functionName: "f",
+                args: ["[]"],
+              } as ProposalAction,
+            ],
+            passthrough,
+          ),
+        ).rejects.toThrow(/has 1 field for tuple but was given 0/);
+      });
+
+      test("the live preview conversion still degrades instead of throwing", () => {
+        const inputs = [{ name: "a", type: "uint256[]" }] as const;
+        expect(argsToTreesForDisplay(inputs, ["not json"])).toEqual([[]]);
+      });
+    });
+
+    describe("an arg count the function doesn't take fails closed", () => {
+      const callWithArgs = (args: string[]) =>
+        encodeActions(
+          [
+            {
+              type: "custom",
+              contractAddress: CONTRACT,
+              abi: abiWith("string"),
+              functionName: "f",
+              args,
+            } as ProposalAction,
+          ],
+          passthrough,
+        );
+
+      test("refuses a missing arg instead of encoding an empty string", async () => {
+        await expect(callWithArgs([])).rejects.toThrow(
+          /Expected 1 argument, got 0/,
+        );
+      });
+
+      test("refuses an extra arg instead of dropping it", async () => {
+        await expect(callWithArgs(["hello", "surprise"])).rejects.toThrow(
+          /Expected 1 argument, got 2/,
+        );
+      });
+    });
+
+    test("resolves an ENS name nested inside an array", async () => {
+      const resolver = makeAddressResolver(async (name) =>
+        name === "vitalik.eth"
+          ? "0x1111111111111111111111111111111111111111"
+          : null,
+      );
+      const { calldatas } = await encodeActions(
+        [
+          {
+            type: "custom",
+            contractAddress: CONTRACT,
+            abi: abiWith("address[]"),
+            functionName: "f",
+            args: ['["vitalik.eth"]'],
+          } as ProposalAction,
+        ],
+        resolver,
+      );
+      expect(calldatas[0]).toBe(
+        encodeFunctionData({
+          abi: abiWith("address[]"),
+          functionName: "f",
+          args: [["0x1111111111111111111111111111111111111111"]],
+        }),
+      );
+    });
+  });
 });
diff --git a/apps/dashboard/features/create-proposal/utils/encodeActions.ts b/apps/dashboard/features/create-proposal/utils/encodeActions.ts
index 44127f20fe..0992a037d5 100644
--- a/apps/dashboard/features/create-proposal/utils/encodeActions.ts
+++ b/apps/dashboard/features/create-proposal/utils/encodeActions.ts
@@ -1,77 +1,21 @@
 import {
   encodeFunctionData,
   erc20Abi,
-  isAddress,
   parseEther,
   parseUnits,
   toFunctionSignature,
   type AbiFunction,
-  type AbiParameter,
   type Hex,
 } from "viem";
+import { isAddressLike, toChecksumAddress } from "@/shared/utils/address";
+import {
+  argsToTrees,
+  resolveAddressesInTrees,
+  treesToEncodeValues,
+} from "@/features/create-proposal/utils/argTree";
 import type { ProposalAction } from "@/features/create-proposal/types";
 
 export type AddressResolver = (nameOrAddress: string) => Promise<`0x${string}`>;
-const parseArg = async (
-  type: string,
-  components: readonly AbiParameter[] | undefined,
-  value: unknown,
-  resolve: AddressResolver,
-): Promise<unknown> => {
-  const arrayMatch = type.match(/^(.*)\[(\d*)\]$/);
-  if (arrayMatch) {
-    const elementType = arrayMatch[1];
-    const fixedLength = arrayMatch[2] ? Number(arrayMatch[2]) : null;
-
-    const arr = typeof value === "string" ? JSON.parse(value) : value;
-    if (!Array.isArray(arr)) {
-      throw new Error(`Expected JSON array for type "${type}".`);
-    }
-
-    if (fixedLength !== null && arr.length !== fixedLength) {
-      throw new Error(
-        `Expected array of length ${fixedLength} for type "${type}", got ${arr.length}.`,
-      );
-    }
-
-    return Promise.all(
-      arr.map((item) => parseArg(elementType, components, item, resolve)),
-    );
-  }
-
-  if (type.startsWith("tuple")) {
-    const obj = typeof value === "string" ? JSON.parse(value) : value;
-    if (!Array.isArray(obj) || !components) {
-      throw new Error(`Expected JSON array for tuple type "${type}".`);
-    }
-    return Promise.all(
-      components.map((c, i) =>
-        parseArg(
-          c.type,
-          (c as { components?: readonly AbiParameter[] }).components,
-          obj[i],
-          resolve,
-        ),
-      ),
-    );
-  }
-
-  if (type === "address") {
-    if (typeof value !== "string") {
-      throw new Error(`Expected string for address, got ${typeof value}.`);
-    }
-    return resolve(value);
-  }
-
-  if (type === "bool") {
-    if (typeof value === "boolean") return value;
-    if (value === "true") return true;
-    if (value === "false") return false;
-    throw new Error(`Expected boolean, got "${String(value)}".`);
-  }
-
-  return value;
-};
 
 export const encodeActions = async (
   actions: ProposalAction[],
@@ -131,17 +75,16 @@ export const encodeActions = async (
         `Function "${action.functionName}" not found in the action's ABI.`,
       );
     }
-    const resolvedArgs = await Promise.all(
-      action.args.map((arg, i) => {
-        const input = fn.inputs[i];
-        if (!input) return Promise.resolve(arg);
-        return parseArg(
-          input.type,
-          (input as { components?: readonly AbiParameter[] }).components,
-          arg,
-          resolve,
-        );
-      }),
+    // The strict variant of the conversion the preview runs: the preview may degrade a
+    // half-typed array to an empty one, and an action from a shared or API draft never
+    // passed `ProposalFormSchema`, so this is the last place to catch a malformed arg.
+    const resolvedArgs = treesToEncodeValues(
+      fn.inputs,
+      await resolveAddressesInTrees(
+        fn.inputs,
+        argsToTrees(fn.inputs, action.args),
+        resolve,
+      ),
     );
     targets.push(target);
     values.push(ethValue);
@@ -162,7 +105,10 @@ export const makeAddressResolver = (
 ): AddressResolver => {
   return async (input) => {
     const trimmed = input.trim();
-    if (isAddress(trimmed)) return trimmed;
+    // Checksum-agnostic: matched strictly, a miscased address falls through to the ENS
+    // branch and fails with `Could not resolve ENS name 0x39D3…` mid-publish, for
+    // something that was never a name and that the form accepted.
+    if (isAddressLike(trimmed)) return toChecksumAddress(trimmed);
     const resolved = await getEnsAddress(trimmed);
     if (!resolved) throw new Error(`Could not resolve ENS name "${trimmed}"`);
     return resolved;
diff --git a/apps/dashboard/features/create-proposal/utils/importHandoff.test.ts b/apps/dashboard/features/create-proposal/utils/importHandoff.test.ts
new file mode 100644
index 0000000000..98b4176868
--- /dev/null
+++ b/apps/dashboard/features/create-proposal/utils/importHandoff.test.ts
@@ -0,0 +1,190 @@
+import {
+  clearImportedProposal,
+  stashImportedProposal,
+  takeImportedProposal,
+  type ImportedProposal,
+} from "@/features/create-proposal/utils/importHandoff";
+
+const createMemoryStorage = (): Storage => {
+  const data = new Map<string, string>();
+  return {
+    get length() {
+      return data.size;
+    },
+    clear: () => data.clear(),
+    getItem: (k) => (data.has(k) ? data.get(k)! : null),
+    key: (i) => Array.from(data.keys())[i] ?? null,
+    removeItem: (k) => {
+      data.delete(k);
+    },
+    setItem: (k, v) => {
+      data.set(k, v);
+    },
+  };
+};
+
+const proposal: ImportedProposal = {
+  title: "Fund the thing",
+  body: "## Synopsis",
+  actions: [
+    {
+      type: "eth-transfer",
+      recipient: "0x39D3F4633dE1F5E2a1e2f4d3fD6d1AAf2E9c8b71",
+      amount: "600",
+    },
+  ],
+};
+
+describe("the import handoff", () => {
+  beforeEach(() => {
+    (globalThis as { localStorage?: Storage }).localStorage =
+      createMemoryStorage();
+  });
+
+  it("carries the values across", () => {
+    expect(stashImportedProposal("ens", proposal)).toBe(true);
+    expect(takeImportedProposal("ens")).toEqual(proposal);
+  });
+
+  it("hands them over exactly once", () => {
+    stashImportedProposal("ens", proposal);
+    expect(takeImportedProposal("ens")).toEqual(proposal);
+    expect(takeImportedProposal("ens")).toBeNull();
+  });
+
+  it("keeps one DAO's import off another's form", () => {
+    stashImportedProposal("ens", proposal);
+    expect(takeImportedProposal("shu")).toBeNull();
+    expect(takeImportedProposal("ens")).toEqual(proposal);
+  });
+
+  it("reports nothing when no import is pending", () => {
+    expect(takeImportedProposal("ens")).toBeNull();
+  });
+
+  describe("whatever case the route param arrives in", () => {
+    it("reads a mixed-case stash back with a lowercase id", () => {
+      expect(stashImportedProposal("ENS", proposal)).toBe(true);
+      expect(takeImportedProposal("ens")).toEqual(proposal);
+    });
+
+    it("reads a lowercase stash back with a mixed-case id", () => {
+      expect(stashImportedProposal("ens", proposal)).toBe(true);
+      expect(takeImportedProposal("EnS")).toEqual(proposal);
+    });
+
+    it("still hands them over exactly once across cases", () => {
+      stashImportedProposal("ENS", proposal);
+      expect(takeImportedProposal("ens")).toEqual(proposal);
+      expect(takeImportedProposal("ENS")).toBeNull();
+    });
+
+    it("keeps one DAO's import off another's form", () => {
+      stashImportedProposal("ENS", proposal);
+      expect(takeImportedProposal("SHU")).toBeNull();
+      expect(takeImportedProposal("ens")).toEqual(proposal);
+    });
+  });
+
+  const KEY = "anticapture:pending-import:ens";
+
+  it("drops a corrupted stash instead of throwing", () => {
+    localStorage.setItem(KEY, "{not json");
+    expect(takeImportedProposal("ens")).toBeNull();
+    expect(localStorage.getItem(KEY)).toBeNull();
+  });
+
+  it("drops a record that isn't the shape it writes", () => {
+    localStorage.setItem(KEY, JSON.stringify({ title: "no wrapper" }));
+    expect(takeImportedProposal("ens")).toBeNull();
+    expect(localStorage.getItem(KEY)).toBeNull();
+  });
+
+  it("is readable from a context that never wrote it", () => {
+    stashImportedProposal("ens", proposal);
+    const carried = localStorage.getItem(KEY);
+
+    (globalThis as { localStorage?: Storage }).localStorage =
+      createMemoryStorage();
+    localStorage.setItem(KEY, carried!);
+
+    expect(takeImportedProposal("ens")).toEqual(proposal);
+  });
+
+  describe("a stash that sat too long", () => {
+    const writtenAt = (ms: number) =>
+      localStorage.setItem(KEY, JSON.stringify({ at: ms, values: proposal }));
+
+    it("is refused once it is older than the window", () => {
+      writtenAt(Date.now() - 61 * 60 * 1000);
+      expect(takeImportedProposal("ens")).toBeNull();
+    });
+
+    it("is cleared rather than left to be refused again", () => {
+      writtenAt(Date.now() - 61 * 60 * 1000);
+      takeImportedProposal("ens");
+      expect(localStorage.getItem(KEY)).toBeNull();
+    });
+
+    it("still arrives after a plausible mail round trip", () => {
+      writtenAt(Date.now() - 10 * 60 * 1000);
+      expect(takeImportedProposal("ens")).toEqual(proposal);
+    });
+  });
+
+  it("survives an empty actions list", () => {
+    stashImportedProposal("ens", { actions: [] });
+    expect(takeImportedProposal("ens")).toEqual({ actions: [] });
+  });
+
+  describe("abandoning the handoff", () => {
+    it("drops a stash whose navigation never happened", () => {
+      stashImportedProposal("ens", proposal);
+      clearImportedProposal("ens");
+      expect(takeImportedProposal("ens")).toBeNull();
+    });
+
+    it("normalizes the id the same way the write did", () => {
+      stashImportedProposal("ENS", proposal);
+      clearImportedProposal("EnS");
+      expect(takeImportedProposal("ens")).toBeNull();
+    });
+
+    it("leaves another DAO's pending import alone", () => {
+      stashImportedProposal("ens", proposal);
+      stashImportedProposal("shu", proposal);
+      clearImportedProposal("ens");
+      expect(takeImportedProposal("ens")).toBeNull();
+      expect(takeImportedProposal("shu")).toEqual(proposal);
+    });
+
+    it("is a no-op when nothing is pending", () => {
+      expect(() => clearImportedProposal("ens")).not.toThrow();
+    });
+  });
+
+  describe("when storage is unavailable", () => {
+    const refuse = (method: "getItem" | "setItem" | "removeItem") => {
+      const storage = createMemoryStorage();
+      storage[method] = () => {
+        throw new Error("blocked");
+      };
+      (globalThis as { localStorage?: Storage }).localStorage = storage;
+    };
+
+    it("reports a refused write", () => {
+      refuse("setItem");
+      expect(stashImportedProposal("ens", proposal)).toBe(false);
+    });
+
+    it("reads nothing on a refused read", () => {
+      refuse("getItem");
+      expect(takeImportedProposal("ens")).toBeNull();
+    });
+
+    it("swallows a refused clear", () => {
+      refuse("removeItem");
+      expect(() => clearImportedProposal("ens")).not.toThrow();
+    });
+  });
+});
diff --git a/apps/dashboard/features/create-proposal/utils/importHandoff.ts b/apps/dashboard/features/create-proposal/utils/importHandoff.ts
new file mode 100644
index 0000000000..9f1759db50
--- /dev/null
+++ b/apps/dashboard/features/create-proposal/utils/importHandoff.ts
@@ -0,0 +1,68 @@
+import type { ProposalFormValues } from "@/features/create-proposal/schema";
+
+export type ImportedProposal = {
+  title?: string;
+  discussionUrl?: string;
+  body?: string;
+  actions?: ProposalFormValues["actions"];
+};
+
+/* `localStorage`, not `sessionStorage`: the magic link mails an absolute URL back to
+ * the form, and following it from a mail client opens a new browsing context where a
+ * per-tab stash is invisible. The cost is the expiry below. Lowercased because the
+ * two sides read the route param with different casing. */
+const keyFor = (daoId: string) =>
+  `anticapture:pending-import:${daoId.toLowerCase()}`;
+
+const MAX_AGE_MS = 60 * 60 * 1000;
+
+type StoredHandoff = { at: number; values: ImportedProposal };
+
+const isStoredHandoff = (value: unknown): value is StoredHandoff => {
+  if (typeof value !== "object" || value === null) return false;
+  const record = value as { at?: unknown; values?: unknown };
+  return (
+    typeof record.at === "number" &&
+    typeof record.values === "object" &&
+    record.values !== null
+  );
+};
+
+export const stashImportedProposal = (
+  daoId: string,
+  values: ImportedProposal,
+): boolean => {
+  try {
+    const record: StoredHandoff = { at: Date.now(), values };
+    localStorage.setItem(keyFor(daoId), JSON.stringify(record));
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+export const clearImportedProposal = (daoId: string): void => {
+  try {
+    localStorage.removeItem(keyFor(daoId));
+  } catch {
+    // Nothing to undo: storage that refuses this refused the write too.
+  }
+};
+
+/** Reads and clears, so a reload cannot re-apply an import the author has since
+ *  edited away. Clears even when refusing a stale record. */
+export const takeImportedProposal = (
+  daoId: string,
+): ImportedProposal | null => {
+  try {
+    const raw = localStorage.getItem(keyFor(daoId));
+    if (raw === null) return null;
+    localStorage.removeItem(keyFor(daoId));
+    const record: unknown = JSON.parse(raw);
+    if (!isStoredHandoff(record)) return null;
+    if (Date.now() - record.at > MAX_AGE_MS) return null;
+    return record.values;
+  } catch {
+    return null;
+  }
+};
diff --git a/apps/dashboard/features/create-proposal/utils/importSpec.test.ts b/apps/dashboard/features/create-proposal/utils/importSpec.test.ts
new file mode 100644
index 0000000000..14bcf3930e
--- /dev/null
+++ b/apps/dashboard/features/create-proposal/utils/importSpec.test.ts
@@ -0,0 +1,70 @@
+import {
+  PROPOSAL_IMPORT_EXAMPLE,
+  PROPOSAL_IMPORT_SPEC,
+} from "@/features/create-proposal/constants";
+import {
+  formatImportIssue,
+  parseProposalJson,
+} from "@/features/create-proposal/utils/parseProposalJson";
+
+const reasons = (text: string) => {
+  const result = parseProposalJson(text);
+  return result.ok ? "" : result.issues.map(formatImportIssue).join("; ");
+};
+
+describe("the copyable spec", () => {
+  it("embeds an example the parser accepts", () => {
+    expect(reasons(PROPOSAL_IMPORT_EXAMPLE)).toBe("");
+  });
+
+  it("embeds that example verbatim, so there is one copy of it", () => {
+    expect(PROPOSAL_IMPORT_SPEC).toContain(PROPOSAL_IMPORT_EXAMPLE);
+  });
+
+  it("keeps the version stamp a model can quote back", () => {
+    expect(PROPOSAL_IMPORT_SPEC).toMatch(/\(v\d+, \d{4}-\d{2}\)/);
+  });
+
+  it("opens with the instruction that keeps the output parseable", () => {
+    expect(PROPOSAL_IMPORT_SPEC).toContain(
+      "Return a single JSON object and nothing else",
+    );
+  });
+
+  it("shows the abi and args branch, not only raw calldata", () => {
+    const example = JSON.parse(PROPOSAL_IMPORT_EXAMPLE) as {
+      actions: Record<string, unknown>[];
+    };
+    const custom = example.actions.filter((a) => a.type === "custom");
+    expect(custom.some((a) => "calldata" in a)).toBe(true);
+    expect(custom.some((a) => "abi" in a && "args" in a)).toBe(true);
+  });
+
+  it.each([
+    ["the quoting rule", "Every figure must be a quoted string"],
+    ["the wei warning", "Amounts are human-readable, never wei"],
+    ["the ENS allowance", "recipient takes an address or an ENS name"],
+    [
+      "the tuple shapes",
+      "A tuple is an object keyed by component name, or an array in component order.",
+    ],
+    ["the placeholder warning", "Addresses below are placeholders"],
+  ])("states %s", (_label, sentence) => {
+    expect(PROPOSAL_IMPORT_SPEC.replace(/\s+/g, " ")).toContain(sentence);
+  });
+
+  it("uses no real, well-known contract address", () => {
+    const realContracts = [
+      "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48", // USDC
+      "0xdac17f958d2ee523a2206206994597c13d831ec7", // USDT
+      "0x6b175474e89094c44da98b954eedeac495271d0f", // DAI
+      "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2", // WETH
+      "0xc18360217d8f7ab5e7c516566761ea12ce7f9d72", // ENS
+      "0x00000000000c2e074ec69a0dfb2997ba6c7d2e1e", // ENS registry
+    ];
+    const lowered = PROPOSAL_IMPORT_SPEC.toLowerCase();
+    realContracts.forEach((address) => {
+      expect(lowered).not.toContain(address);
+    });
+  });
+});
diff --git a/apps/dashboard/features/create-proposal/utils/importedArgs.ts b/apps/dashboard/features/create-proposal/utils/importedArgs.ts
new file mode 100644
index 0000000000..5b50965b68
--- /dev/null
+++ b/apps/dashboard/features/create-proposal/utils/importedArgs.ts
@@ -0,0 +1,158 @@
+import type { AbiParameter } from "viem";
+
+import {
+  argToStorage,
+  shapeOf,
+  type ArgValue,
+} from "@/features/create-proposal/utils/argTree";
+import type { Issue } from "@/features/create-proposal/utils/issues";
+
+export type ImportedArgIssue = Issue;
+
+export type ImportedArgResult =
+  | { ok: true; storage: string }
+  | { ok: false; issues: ImportedArgIssue[] };
+
+type Translated = { value: ArgValue; issues: ImportedArgIssue[] };
+
+const isPlainObject = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null && !Array.isArray(value);
+
+const describe = (value: unknown): string => {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "an array";
+  if (isPlainObject(value)) return "an object";
+  return typeof value;
+};
+
+const ok = (value: ArgValue): Translated => ({ value, issues: [] });
+
+const bad = (path: (string | number)[], message: string): Translated => ({
+  value: "",
+  issues: [{ path, message }],
+});
+
+const merge = (parts: Translated[]): Translated => ({
+  value: parts.map((part) => part.value),
+  issues: parts.flatMap((part) => part.issues),
+});
+
+/* Translation only: a document writes a tuple keyed by name or positionally, and
+ * the form stores it positionally with every leaf a string. Whether the result is a
+ * legal `uint256`, holds the right number of entries, or is filled in at all is
+ * `argIssues`' answer. What stays here is what stops a value from being
+ * representable at all — invisible later, because the tree could not be built. */
+const translate = (
+  param: AbiParameter,
+  value: unknown,
+  path: (string | number)[],
+): Translated => {
+  const shape = shapeOf(param);
+
+  if (shape.kind === "array") {
+    if (!Array.isArray(value)) {
+      return bad(
+        path,
+        `must be an array for ${param.type}, not ${describe(value)}`,
+      );
+    }
+    return merge(
+      value.map((item, index) =>
+        translate(shape.element, item, [...path, index]),
+      ),
+    );
+  }
+
+  if (shape.kind === "tuple") {
+    if (Array.isArray(value)) {
+      return merge(
+        value.map((item, index) =>
+          translate(shape.components[index] ?? param, item, [...path, index]),
+        ),
+      );
+    }
+
+    if (isPlainObject(value)) {
+      const declared = new Set(shape.components.map((c) => c.name ?? ""));
+      // An extra key is a value the encoder maps nothing to, so the proposal would
+      // send something narrower than the document described. Invisible to any later
+      // pass, which only sees the positional tree.
+      const extras = Object.keys(value)
+        .filter((key) => !declared.has(key))
+        .map((key) => bad([...path, key], "isn't a field of this tuple"));
+
+      const named = shape.components.map((component, index) => {
+        const key = component.name ?? "";
+        if (!key) {
+          return bad(
+            path,
+            `declares an unnamed field at position ${index}, so it can only be given as an array in component order`,
+          );
+        }
+        if (!(key in value)) return ok("");
+        return translate(component, value[key], [...path, key]);
+      });
+
+      const { issues } = merge([...extras, ...named]);
+      return { value: named.map((n) => n.value), issues };
+    }
+
+    return bad(
+      path,
+      `must be an object keyed by component name, or an array in component order, not ${describe(value)}`,
+    );
+  }
+
+  // Gated on the declared type, not the value: a bare `true` given for a `string`
+  // would otherwise be stored as the text "true" and pass every later check, having
+  // quietly become a different value than the document wrote.
+  if (shape.type === "bool") {
+    if (typeof value === "boolean") return ok(value ? "true" : "false");
+    if (typeof value === "string" && ["true", "false"].includes(value.trim())) {
+      return ok(value);
+    }
+    return bad(
+      path,
+      `must be true or false for ${param.type}, not ${describe(value)}`,
+    );
+  }
+
+  if (typeof value === "string") return ok(value);
+
+  return bad(path, `must be a value for ${param.type}, not ${describe(value)}`);
+};
+
+export const convertImportedArg = (
+  input: AbiParameter,
+  value: unknown,
+): ImportedArgResult => {
+  const { value: tree, issues } = translate(input, value, []);
+  if (issues.length > 0) return { ok: false, issues };
+  return { ok: true, storage: argToStorage(input, tree) };
+};
+
+/** No ABI to check against, for an action whose function did not resolve. Only a
+ *  keyed tuple is refused, since ordering it without the components is a guess. */
+export const convertUntypedArg = (value: unknown): ImportedArgResult => {
+  const walk = (current: unknown, path: (string | number)[]): Translated => {
+    if (typeof current === "string") return ok(current);
+    if (typeof current === "boolean") return ok(current ? "true" : "false");
+    if (Array.isArray(current)) {
+      return merge(current.map((item, i) => walk(item, [...path, i])));
+    }
+    if (isPlainObject(current)) {
+      return bad(
+        path,
+        "can only be ordered once the function it belongs to resolves in the abi; name the function, or give the tuple as an array in component order",
+      );
+    }
+    return bad(path, `must be a value, not ${describe(current)}`);
+  };
+
+  const { value: tree, issues } = walk(value, []);
+  if (issues.length > 0) return { ok: false, issues };
+  return {
+    ok: true,
+    storage: typeof tree === "string" ? tree : JSON.stringify(tree),
+  };
+};
diff --git a/apps/dashboard/features/create-proposal/utils/issues.ts b/apps/dashboard/features/create-proposal/utils/issues.ts
new file mode 100644
index 0000000000..da5c880bbc
--- /dev/null
+++ b/apps/dashboard/features/create-proposal/utils/issues.ts
@@ -0,0 +1,6 @@
+/** One thing wrong, and where. Paths compose: an arg issue at `durations.total`
+ *  is re-rooted at `args[0].durations.total`, then `actions[2].args[0]…`. */
+export type Issue = {
+  path: (string | number)[];
+  message: string;
+};
diff --git a/apps/dashboard/features/create-proposal/utils/jsonSource.test.ts b/apps/dashboard/features/create-proposal/utils/jsonSource.test.ts
new file mode 100644
index 0000000000..4c1bce92f7
--- /dev/null
+++ b/apps/dashboard/features/create-proposal/utils/jsonSource.test.ts
@@ -0,0 +1,120 @@
+import {
+  formatJsonPath,
+  parseJsonDocument,
+  rangeOfLine,
+} from "@/features/create-proposal/utils/jsonSource";
+
+const expectParsed = (text: string) => {
+  const result = parseJsonDocument(text);
+  if (!result.ok) throw new Error(`expected a parse, got line ${result.line}`);
+  return result.document;
+};
+
+describe("formatJsonPath", () => {
+  test.each([
+    [[], ""],
+    [["title"], "title"],
+    [["actions", 1, "amount"], "actions[1].amount"],
+    [
+      ["actions", 9, "args", 0, "durations", "total"],
+      "actions[9].args[0].durations.total",
+    ],
+  ])("%j", (path, expected) => {
+    expect(formatJsonPath(path as (string | number)[])).toBe(expected);
+  });
+});
+
+describe("parseJsonDocument", () => {
+  // The reason this file exists. Spliced as raw text: written as TS literals the
+  // compiler rounds them first.
+  describe("numbers", () => {
+    test.each([
+      ["an integer past 2^53", "1000000000000000001"],
+      ["a fraction a double collapses", "1.000000000000000001"],
+      ["a fraction beyond a double", "0.123456789123456789"],
+      ["a figure a double carries exactly", "1.5"],
+      ["a negative", "-42"],
+      ["exponent notation, as written", "1e3"],
+    ])("keeps %s as the text it was written as", (_label, literal) => {
+      expect(expectParsed(`{"n": ${literal}}`).value).toEqual({ n: literal });
+    });
+
+    it("keeps a number nested in arrays and objects", () => {
+      expect(expectParsed('{"a": [[1], {"b": 2}], "c": "x"}').value).toEqual({
+        a: [["1"], { b: "2" }],
+        c: "x",
+      });
+    });
+
+    it("leaves the other JSON kinds alone", () => {
+      expect(expectParsed('{"t": true, "n": null, "s": "1"}').value).toEqual({
+        t: true,
+        n: null,
+        s: "1",
+      });
+    });
+  });
+
+  describe("lines", () => {
+    const document = `{
+  "title": "Proposal title",
+  "actions": [
+    {"type": "eth-transfer", "recipient": "0x0", "amount": "600"},
+    {"type": "erc20-transfer",
+     "recipient": "0x1",
+     "tokenAddress": "0x2",
+     "amount": 480000}
+  ]
+}`;
+
+    test.each([
+      [[], 1],
+      [["title"], 2],
+      [["actions"], 3],
+      [["actions", 0, "amount"], 4],
+      [["actions", 1], 5],
+      [["actions", 1, "tokenAddress"], 7],
+      [["actions", 1, "amount"], 8],
+    ])("%j is on line %i", (path, expected) => {
+      expect(expectParsed(document).lineOf(path as (string | number)[])).toBe(
+        expected,
+      );
+    });
+
+    it("has nothing to say about a path the document doesn't carry", () => {
+      expect(expectParsed(document).lineOf(["body"])).toBeUndefined();
+    });
+
+    it("counts from the start of what was pasted, blank lines included", () => {
+      expect(
+        expectParsed(`\n\n${document}`).lineOf(["actions", 1, "amount"]),
+      ).toBe(10);
+    });
+  });
+
+  describe("refusals", () => {
+    test.each([
+      ["a missing value", '{"a":}', 1],
+      ["a trailing comma", '{"a":1,}', 1],
+      ["a comment", '{\n  "a": 1 // note\n}', 2],
+      ["single quotes", "{'a':1}", 1],
+      ["a truncated document", '{"a": [1, 2', 1],
+    ])("refuses %s, and says which line", (_label, text, line) => {
+      const result = parseJsonDocument(text);
+      expect(result).toMatchObject({ ok: false, line });
+    });
+  });
+});
+
+describe("rangeOfLine", () => {
+  const text = "a\nbb\nccc";
+
+  test.each([
+    [1, { start: 0, end: 1 }],
+    [2, { start: 2, end: 4 }],
+    [3, { start: 5, end: 8 }],
+    [99, { start: 5, end: 8 }],
+  ])("line %i", (line, expected) => {
+    expect(rangeOfLine(text, line)).toEqual(expected);
+  });
+});
diff --git a/apps/dashboard/features/create-proposal/utils/jsonSource.ts b/apps/dashboard/features/create-proposal/utils/jsonSource.ts
new file mode 100644
index 0000000000..558cbd4083
--- /dev/null
+++ b/apps/dashboard/features/create-proposal/utils/jsonSource.ts
@@ -0,0 +1,88 @@
+import { parseTree, type Node, type ParseError } from "jsonc-parser";
+
+export const formatJsonPath = (path: readonly (string | number)[]): string =>
+  path.reduce<string>(
+    (acc, segment) =>
+      typeof segment === "number"
+        ? `${acc}[${segment}]`
+        : acc
+          ? `${acc}.${segment}`
+          : String(segment),
+    "",
+  );
+
+const lineAt = (text: string, offset: number): number =>
+  text.slice(0, Math.max(0, Math.min(offset, text.length))).split("\n").length;
+
+export type JsonDocument = {
+  value: unknown;
+  lineOf: (path: readonly (string | number)[]) => number | undefined;
+};
+
+export type ParseJsonDocumentResult =
+  | { ok: true; document: JsonDocument }
+  | { ok: false; line: number | undefined };
+
+const collect = (
+  node: Node,
+  path: (string | number)[],
+  text: string,
+  lines: Map<string, number>,
+): unknown => {
+  lines.set(formatJsonPath(path), lineAt(text, node.offset));
+
+  switch (node.type) {
+    case "object": {
+      const result: Record<string, unknown> = {};
+      for (const property of node.children ?? []) {
+        const [key, value] = property.children ?? [];
+        if (typeof key?.value !== "string" || !value) continue;
+        result[key.value] = collect(value, [...path, key.value], text, lines);
+      }
+      return result;
+    }
+    case "array":
+      return (node.children ?? []).map((child, index) =>
+        collect(child, [...path, index], text, lines),
+      );
+    // The point of this file: the digits as written. `JSON.parse` hands back a
+    // double, so 1000000000000000001 arrives as …000 and every figure in a
+    // proposal ends up at `parseUnits` or the ABI encoder, both of which take text.
+    case "number":
+      return text.slice(node.offset, node.offset + node.length);
+    default:
+      return node.value;
+  }
+};
+
+export const parseJsonDocument = (text: string): ParseJsonDocumentResult => {
+  const errors: ParseError[] = [];
+  // Strict: a pasted proposal is machine-generated, so tolerating a comment or a
+  // trailing comma would accept a document other tools reject.
+  const root = parseTree(text, errors, {
+    allowTrailingComma: false,
+    disallowComments: true,
+  });
+
+  if (!root || errors.length > 0) {
+    const first = errors[0];
+    return { ok: false, line: first ? lineAt(text, first.offset) : undefined };
+  }
+
+  const lines = new Map<string, number>();
+  const value = collect(root, [], text, lines);
+  return {
+    ok: true,
+    document: { value, lineOf: (path) => lines.get(formatJsonPath(path)) },
+  };
+};
+
+export const rangeOfLine = (
+  text: string,
+  line: number,
+): { start: number; end: number } => {
+  const lines = text.split("\n");
+  const index = Math.max(0, Math.min(line - 1, lines.length - 1));
+  const start = lines.slice(0, index).reduce((n, l) => n + l.length + 1, 0);
+  return { start, end: start + lines[index].length };
+};
diff --git a/apps/dashboard/features/create-proposal/utils/parseProposalJson.test.ts b/apps/dashboard/features/create-proposal/utils/parseProposalJson.test.ts
new file mode 100644
index 0000000000..f29b5b8412
--- /dev/null
+++ b/apps/dashboard/features/create-proposal/utils/parseProposalJson.test.ts
@@ -0,0 +1,578 @@
+import { PROPOSAL_JSON_PLACEHOLDER } from "@/features/create-proposal/constants";
+import {
+  formatImportIssue,
+  parseProposalJson,
+  type ParseProposalJsonResult,
+} from "@/features/create-proposal/utils/parseProposalJson";
+
+const USDC = "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48";
+const CONTRACT = "0x3333333333333333333333333333333333333333";
+
+const parse = (...actions: unknown[]) =>
+  parseProposalJson(JSON.stringify({ actions }));
+
+const reasons = (result: ParseProposalJsonResult) =>
+  result.ok ? "" : result.issues.map(formatImportIssue).join("; ");
+
+const expectOk = (result: ParseProposalJsonResult) => {
+  if (!result.ok)
+    throw new Error(`expected a valid document, got: ${reasons(result)}`);
+  return result.value;
+};
+
+const expectRejected = (
+  result: ParseProposalJsonResult,
+  ...fragments: string[]
+) => {
+  if (result.ok) throw new Error("expected a rejection, got a valid document");
+  const text = reasons(result);
+  fragments.forEach((fragment) => expect(text).toContain(fragment));
+  return text;
+};
+
+const eth = (overrides: Record<string, unknown> = {}) => ({
+  type: "eth-transfer",
+  recipient: "vitalik.eth",
+  amount: "1.5",
+  ...overrides,
+});
+
+const erc20 = (overrides: Record<string, unknown> = {}) => ({
+  type: "erc20-transfer",
+  recipient: "vitalik.eth",
+  tokenAddress: USDC,
+  amount: "1",
+  ...overrides,
+});
+
+const custom = (overrides: Record<string, unknown> = {}) => ({
+  type: "custom",
+  contractAddress: CONTRACT,
+  ...overrides,
+});
+
+const abiOf = (inputs: unknown[], name = "call") => [
+  {
+    type: "function",
+    name,
+    stateMutability: "nonpayable",
+    inputs,
+    outputs: [],
+  },
+];
+
+describe("parseProposalJson", () => {
+  describe("the document", () => {
+    describe("the format hint", () => {
+      // MOD-8 supplies this text exactly, wrapping included, because the wrapping is
+      // the point: it renders with `white-space: pre`.
+      it("is the text the design specifies, wrapping included", () => {
+        expect(PROPOSAL_JSON_PLACEHOLDER).toBe(
+          `{
+  "title": "Proposal title",
+  "discussionUrl": "https://discuss...",
+  "body": "## Synopsis\\n\\nMarkdown description.",
+  "actions": [
+    {"type": "eth-transfer", "recipient": "0x...", "amount": "600"},
+    {"type": "erc20-transfer", "tokenAddress": "0x...",
+     "recipient": "0x...", "amount": "480000"},
+    {"type": "custom", "contractAddress": "0x...",
+     "calldata": "0x..."}
+  ]
+}`,
+        );
+      });
+
+      it("is valid JSON carrying the fields the parser reads", () => {
+        const hint = JSON.parse(PROPOSAL_JSON_PLACEHOLDER) as {
+          actions: { type: string }[];
+        };
+        expect(Object.keys(hint)).toEqual([
+          "title",
+          "discussionUrl",
+          "body",
+          "actions",
+        ]);
+        expect(hint.actions.map((a) => a.type)).toEqual([
+          "eth-transfer",
+          "erc20-transfer",
+          "custom",
+        ]);
+      });
+
+      // MOD-8 describes its longest line as 66 characters; the text it supplies is 68.
+      // The bound is here to catch a new line that overflows, not to relitigate these.
+      it("stays inside the width it was wrapped for", () => {
+        PROPOSAL_JSON_PLACEHOLDER.split("\n").forEach((line) => {
+          expect(line.length).toBeLessThanOrEqual(68);
+        });
+      });
+    });
+
+    it("fills only the fields it carries", () => {
+      expect(parseProposalJson('{"title":"Only a title"}')).toEqual({
+        ok: true,
+        value: {
+          title: "Only a title",
+          discussionUrl: undefined,
+          body: undefined,
+          actions: undefined,
+        },
+      });
+    });
+
+    it("ignores unknown keys, so a saved draft pastes in as-is", () => {
+      const value = expectOk(
+        parseProposalJson(
+          JSON.stringify({
+            id: "draft-1",
+            daoId: "ens",
+            createdAt: 1234,
+            title: "From a draft",
+            actions: [],
+          }),
+        ),
+      );
+
+      expect(value).toEqual({
+        title: "From a draft",
+        discussionUrl: undefined,
+        body: undefined,
+        actions: [],
+      });
+    });
+
+    it.each([
+      ["an empty paste", "   ", "Paste the proposal JSON first."],
+      ["text that isn't JSON", "{ title: nope }", "valid JSON"],
+      ["a top-level array", "[]", "Expected a JSON object"],
+      ["an object with no known field", '{"foo":"bar"}', "No known fields"],
+      ["a title that isn't text", '{"title":true}', "title:"],
+    ])("rejects %s", (_label, input, fragment) => {
+      expectRejected(parseProposalJson(input), fragment);
+    });
+
+    it("reads a numeric title as the digits it was written as", () => {
+      expect(expectOk(parseProposalJson('{"title":42}'))).toMatchObject({
+        title: "42",
+      });
+    });
+
+    // Every issue, not the first three: the status row leads with the count, and a
+    // capped list would make that count wrong on exactly the documents it matters on.
+    it("reports every issue it found", () => {
+      const error = expectRejected(
+        parseProposalJson(
+          JSON.stringify({
+            title: true,
+            body: true,
+            discussionUrl: true,
+            actions: true,
+          }),
+        ),
+      );
+
+      expect(error.split("; ")).toHaveLength(4);
+    });
+
+    it("rejects an unknown action type", () => {
+      expectRejected(parse({ type: "bridge" }), "actions[0].type");
+    });
+  });
+
+  describe("figures", () => {
+    // Spliced as raw text, not TS numbers: the compiler rounds them exactly like
+    // `JSON.parse` does, which is what eslint's no-loss-of-precision flags.
+    it.each([
+      ["a fraction beyond a double", "0.123456789123456789"],
+      ["a fraction that collapses to an integer", "1.000000000000000001"],
+      ["an integer past 2^53", "1000000000000000001"],
+      ["a figure a double carries exactly", "1.5"],
+    ])("keeps %s written unquoted, digit for digit", (_label, literal) => {
+      expect(
+        expectOk(
+          parseProposalJson(
+            `{"actions":[{"type":"eth-transfer","recipient":"vitalik.eth","amount":${literal}}]}`,
+          ),
+        ).actions?.[0],
+      ).toMatchObject({ amount: literal });
+    });
+
+    it("takes the same figure quoted", () => {
+      expect(
+        expectOk(parse(eth({ amount: "0.123456789123456789" }))).actions?.[0],
+      ).toMatchObject({ amount: "0.123456789123456789" });
+    });
+
+    it("still holds an unquoted figure to the form's own rule", () => {
+      expectRejected(
+        parseProposalJson(
+          '{"actions":[{"type":"eth-transfer","recipient":"vitalik.eth","amount":0}]}',
+        ),
+        "actions[0].amount",
+        "greater than 0",
+      );
+    });
+
+    describe("inside a composite arg", () => {
+      const withArg = (arg: unknown) =>
+        parse(
+          custom({
+            abi: abiOf([{ name: "values", type: "uint256[]" }], "setMany"),
+            functionName: "setMany",
+            args: [arg],
+          }),
+        );
+
+      it.each([
+        ["null", [null], "actions[0].args[0][0]"],
+        ["a boolean", [true], "actions[0].args[0][0]"],
+        ["a nested object", [{ a: "1" }], "actions[0].args[0][0]"],
+      ])("rejects %s leaf, at its own path", (_label, arg, path) => {
+        expectRejected(withArg(arg), path);
+      });
+
+      it.each([
+        ["a plain number", [1, 2, 3]],
+        ["a number after quoted leaves", ["1", "2", 3]],
+      ])("takes %s leaf, as the text it was written as", (_label, arg) => {
+        expect(expectOk(withArg(arg)).actions?.[0]).toMatchObject({
+          args: ['["1","2","3"]'],
+        });
+      });
+
+      it("keeps a leaf whose digits a double can't hold", () => {
+        const abi = JSON.stringify(
+          abiOf([{ name: "values", type: "uint256[]" }], "setMany"),
+        );
+        expect(
+          expectOk(
+            parseProposalJson(
+              `{"actions":[{"type":"custom","contractAddress":"${CONTRACT}","abi":${abi},"functionName":"setMany","args":[[1000000000000000001]]}]}`,
+            ),
+          ).actions?.[0],
+        ).toMatchObject({ args: ['["1000000000000000001"]'] });
+      });
+
+      it("takes the same leaves quoted", () => {
+        expect(expectOk(withArg(["1", "2", "3"])).actions?.[0]).toMatchObject({
+          args: ['["1","2","3"]'],
+        });
+      });
+
+      it("keeps a nested array nested", () => {
+        const value = expectOk(
+          parse(
+            custom({
+              abi: abiOf([{ name: "grid", type: "uint256[][]" }], "setGrid"),
+              functionName: "setGrid",
+              args: [[["1", "2"], ["3"]]],
+            }),
+          ),
+        );
+        expect(value.actions?.[0]).toMatchObject({
+          args: ['[["1","2"],["3"]]'],
+        });
+      });
+    });
+  });
+
+  describe("transfers", () => {
+    it("accepts an ETH transfer", () => {
+      expect(expectOk(parse(eth())).actions).toEqual([
+        { type: "eth-transfer", recipient: "vitalik.eth", amount: "1.5" },
+      ]);
+    });
+
+    it("leaves an omitted decimals undefined rather than guessing", () => {
+      expect(expectOk(parse(erc20())).actions?.[0]).not.toHaveProperty(
+        "decimals",
+      );
+    });
+
+    it("rejects a token address that isn't an address", () => {
+      expectRejected(
+        parse(erc20({ tokenAddress: "usdc.eth" })),
+        "actions[0].tokenAddress",
+      );
+    });
+  });
+
+  describe("custom actions", () => {
+    it("fills the unused fields of a calldata-only action", () => {
+      expect(
+        expectOk(parse(custom({ calldata: "0xa9059cbb" }))).actions,
+      ).toEqual([
+        {
+          type: "custom",
+          contractAddress: CONTRACT,
+          abi: [],
+          functionName: "",
+          args: [],
+          calldata: "0xa9059cbb",
+        },
+      ]);
+    });
+
+    it("stores a bare function name as the full signature", () => {
+      const value = expectOk(
+        parse(
+          custom({
+            abi: abiOf([{ name: "value", type: "uint256" }], "setValue"),
+            functionName: "setValue",
+            args: ["1"],
+          }),
+        ),
+      );
+
+      expect(value.actions?.[0]).toMatchObject({
+        functionName: "setValue(uint256)",
+      });
+    });
+
+    it("stores args exactly as pasted", () => {
+      const value = expectOk(
+        parse(
+          custom({
+            abi: abiOf([{ name: "flag", type: "bool" }], "setFlag"),
+            functionName: "setFlag",
+            args: [" true "],
+          }),
+        ),
+      );
+
+      expect(value.actions?.[0]).toMatchObject({ args: [" true "] });
+    });
+
+    it("rejects an abi that isn't an array", () => {
+      expectRejected(
+        parse(custom({ abi: "not an abi", functionName: "f" })),
+        "actions[0].abi",
+      );
+    });
+
+    it.each([
+      ["a wei amount", "1000000000000000000"],
+      ["zero", "0"],
+    ])("refuses %s in value", (_label, value) => {
+      expectRejected(
+        parse(custom({ calldata: "0xa9059cbb", value })),
+        "actions[0].value",
+        "isn't supported yet",
+      );
+    });
+  });
+
+  /* Each of these used to pass the import and turn up on the creation page instead,
+   * as a Publish button that would not enable. They are caught here now not because
+   * the import restates them, but because `ProposalActionSchema` owns them. */
+  describe("the form's rules, in the dialog", () => {
+    const setValueAbi = abiOf([{ name: "value", type: "uint256" }], "setValue");
+
+    it.each([
+      [
+        "a function that isn't in the abi",
+        custom({ abi: setValueAbi, functionName: "mystery", args: [] }),
+        "is not a function in this ABI",
+      ],
+      [
+        "a function name with no abi to resolve it",
+        custom({ functionName: "setValue", args: ["1"] }),
+        "Required when a function name is used",
+      ],
+      [
+        "raw calldata and a function name at once",
+        custom({
+          abi: setValueAbi,
+          functionName: "setValue",
+          args: ["1"],
+          calldata: "0xa9059cbb",
+        }),
+        "Can't be combined with a function name",
+      ],
+      [
+        "the wrong number of args for the signature",
+        custom({
+          abi: setValueAbi,
+          functionName: "setValue",
+          args: ["1", "2"],
+        }),
+        "takes 1, got 2",
+      ],
+      [
+        "a read-only function",
+        custom({
+          abi: [
+            {
+              type: "function",
+              name: "peek",
+              stateMutability: "view",
+              inputs: [],
+              outputs: [],
+            },
+          ],
+          functionName: "peek",
+          args: [],
+        }),
+        "only reads state",
+      ],
+      [
+        "a contract address that is neither an address nor an ENS name",
+        custom({ contractAddress: "not-an-address", calldata: "0x00" }),
+        "Must be a valid address or ENS name",
+      ],
+      [
+        "an arg its declared type can't hold",
+        custom({ abi: setValueAbi, functionName: "setValue", args: ["nope"] }),
+        "Must be a non-negative integer",
+      ],
+    ])("rejects %s", (_label, action, fragment) => {
+      expectRejected(parse(action), fragment);
+    });
+
+    it.each([
+      ["a recipient that is neither an address nor an ENS name", "not-a-name"],
+      ["an empty recipient", ""],
+    ])("rejects a transfer with %s", (_label, recipient) => {
+      expectRejected(parse(eth({ recipient })), "actions[0].recipient");
+    });
+
+    it("rejects an ETH amount finer than 18 decimals", () => {
+      expectRejected(
+        parse(eth({ amount: `0.${"0".repeat(18)}1` })),
+        "actions[0].amount",
+        "more decimal places",
+      );
+    });
+  });
+
+  describe("tuple args", () => {
+    const durations = {
+      name: "durations",
+      type: "tuple",
+      components: [
+        { name: "cliff", type: "uint256" },
+        { name: "total", type: "uint256" },
+      ],
+    };
+
+    const stream = (args: unknown[]) =>
+      parse(
+        custom({
+          abi: abiOf([durations], "createStream"),
+          functionName: "createStream",
+          args,
+        }),
+      );
+
+    it("takes a tuple keyed by component name", () => {
+      expect(
+        expectOk(stream([{ cliff: "100", total: "500" }])).actions?.[0],
+      ).toMatchObject({ args: ['["100","500"]'] });
+    });
+
+    it("takes the same tuple as an array in component order", () => {
+      expect(expectOk(stream([["100", "500"]])).actions?.[0]).toMatchObject({
+        args: ['["100","500"]'],
+      });
+    });
+
+    it("reorders a keyed tuple into component order", () => {
+      expect(
+        expectOk(stream([{ total: "500", cliff: "100" }])).actions?.[0],
+      ).toMatchObject({ args: ['["100","500"]'] });
+    });
+
+    it("names the field that is missing", () => {
+      expectRejected(
+        stream([{ cliff: "100" }]),
+        "actions[0].args[0].total: Required",
+      );
+    });
+
+    it("names a field the tuple doesn't declare", () => {
+      expectRejected(
+        stream([{ cliff: "100", total: "500", bonus: "1" }]),
+        "actions[0].args[0].bonus",
+      );
+    });
+
+    it("rejects a tuple given the wrong number of positional fields", () => {
+      expectRejected(stream([["100", "500", "900"]]), "actions[0].args[0]");
+    });
+
+    // VAL-6, verbatim: an imprecise path cost about a week of back-and-forth on a
+    // document that was already correct.
+    it("points inside a nested tuple, not at the argument", () => {
+      const nested = {
+        name: "schedule",
+        type: "tuple",
+        components: [{ ...durations }],
+      };
+      const text = expectRejected(
+        parse(
+          custom({
+            abi: abiOf([nested], "createStream"),
+            functionName: "createStream",
+            args: [{ durations: { cliff: "1", total: null } }],
+          }),
+        ),
+      );
+      expect(text).toContain("actions[0].args[0].durations.total");
+    });
+
+    it("takes a real boolean where the abi declares bool", () => {
+      const value = expectOk(
+        parse(
+          custom({
+            abi: abiOf([{ name: "on", type: "bool" }], "setOn"),
+            functionName: "setOn",
+            args: [true],
+          }),
+        ),
+      );
+      expect(value.actions?.[0]).toMatchObject({ args: ["true"] });
+    });
+
+    it("refuses a keyed tuple it has no abi to order", () => {
+      expectRejected(
+        parse(custom({ functionName: "mystery", args: [{ cliff: "1" }] })),
+        "actions[0].args[0]",
+      );
+    });
+  });
+
+  describe("locating a problem in the text", () => {
+    const document = `{
+  "title": "Proposal title",
+  "actions": [
+    {"type": "eth-transfer", "recipient": "vitalik.eth", "amount": "600"},
+    {"type": "erc20-transfer",
+     "recipient": "vitalik.eth",
+     "tokenAddress": "${USDC}",
+     "amount": -480000}
+  ]
+}`;
+
+    it("reports the line the offending value was written on", () => {
+      const result = parseProposalJson(document);
+      if (result.ok) throw new Error("expected a rejection");
+      expect(result.issues[0]).toMatchObject({
+        path: ["actions", 1, "amount"],
+        line: 8,
+      });
+    });
+
+    it("counts from the start of what was pasted, blank lines included", () => {
+      const result = parseProposalJson(`\n\n${document}`);
+      if (result.ok) throw new Error("expected a rejection");
+      expect(result.issues[0].line).toBe(10);
+    });
+
+    it("reports a line for a document that isn't JSON at all", () => {
+      const result = parseProposalJson('{\n  "title": "x",\n  "body" nope\n}');
+      if (result.ok) throw new Error("expected a rejection");
+      expect(result.issues[0].line).toBe(3);
+    });
+  });
+});
diff --git a/apps/dashboard/features/create-proposal/utils/parseProposalJson.ts b/apps/dashboard/features/create-proposal/utils/parseProposalJson.ts
new file mode 100644
index 0000000000..aebeb52de7
--- /dev/null
+++ b/apps/dashboard/features/create-proposal/utils/parseProposalJson.ts
@@ -0,0 +1,342 @@
+import { z } from "zod";
+
+import {
+  amountPrecisionError,
+  bodySchema,
+  discussionUrlSchema,
+  ETH_DECIMALS,
+  PendingProposalActionSchema,
+  titleSchema,
+  type ProposalFormValues,
+} from "@/features/create-proposal/schema";
+import { parseAbiStrict } from "@/features/create-proposal/utils/fetchAbi";
+import {
+  convertImportedArg,
+  convertUntypedArg,
+  type ImportedArgIssue,
+} from "@/features/create-proposal/utils/importedArgs";
+import type { Issue } from "@/features/create-proposal/utils/issues";
+import {
+  formatJsonPath,
+  parseJsonDocument,
+} from "@/features/create-proposal/utils/jsonSource";
+import {
+  findAbiFunction,
+  signatureOf,
+} from "@/features/create-proposal/utils/validateCustomAction";
+
+type FormAction = ProposalFormValues["actions"][number];
+type Erc20FormAction = Extract<FormAction, { type: "erc20-transfer" }>;
+
+/** An ERC-20 transfer before its decimals are confirmed against the token. A pasted
+ *  `decimals` reaches `parseUnits`, so believing it would let "1 USDC" encode as
+ *  1e18 base units while the row still reads 1. */
+export type PendingErc20Transfer = Omit<Erc20FormAction, "decimals"> & {
+  decimals?: number;
+};
+
+export type PendingAction =
+  | Exclude<FormAction, { type: "erc20-transfer" }>
+  | PendingErc20Transfer;
+
+export type ParsedProposalJson = {
+  title?: string;
+  discussionUrl?: string;
+  body?: string;
+  actions?: PendingAction[];
+};
+
+export type ImportIssue = Issue & {
+  line?: number;
+};
+
+export type ParseProposalJsonResult =
+  | { ok: true; value: ParsedProposalJson }
+  | { ok: false; issues: ImportIssue[] };
+
+/* Three steps, and only the first two are this file's own: transport (which keys,
+ * which JSON kind), translation (arg shapes into what the form stores), then rules —
+ * which are `schema.ts`'s, run rather than restated. The import used to restate a
+ * subset, so a paste could be accepted here and then sit on the form with Publish
+ * disabled and nothing on screen explaining why. */
+
+/** Every figure is read as the text it was written as, so text is all this needs. */
+const documentText = z.string({ invalid_type_error: "must be text" });
+
+const documentDecimals = z
+  .string()
+  .regex(/^\d+$/, "must be a whole number")
+  .transform(Number);
+
+const EthTransferTransport = z.object({
+  type: z.literal("eth-transfer"),
+  recipient: documentText.trim(),
+  amount: documentText.trim(),
+});
+
+const Erc20TransferTransport = z.object({
+  type: z.literal("erc20-transfer"),
+  recipient: documentText.trim(),
+  tokenAddress: documentText.trim(),
+  amount: documentText.trim(),
+  decimals: documentDecimals.optional(),
+});
+
+const CustomTransport = z.object({
+  type: z.literal("custom"),
+  contractAddress: documentText.trim(),
+  abi: z.unknown().optional(),
+  functionName: documentText.trim().optional(),
+  args: z.array(z.unknown()).optional(),
+  calldata: documentText.trim().optional(),
+  value: z.unknown().optional(),
+});
+
+const ActionTransport = z.discriminatedUnion("type", [
+  EthTransferTransport,
+  Erc20TransferTransport,
+  CustomTransport,
+]);
+
+// Unknown keys are stripped rather than rejected, so a saved draft (carrying `id`,
+// `daoId`, timestamps) pastes in unchanged.
+const ProposalJsonTransport = z.object({
+  title: documentText.optional(),
+  discussionUrl: documentText.optional(),
+  body: documentText.optional(),
+  actions: z.array(ActionTransport).optional(),
+});
+
+type ImportedAction = z.infer<typeof ActionTransport>;
+type ImportedCustomAction = Extract<ImportedAction, { type: "custom" }>;
+
+const translateCustomAction = (
+  action: ImportedCustomAction,
+  index: number,
+): { action: PendingAction; issues: ImportIssue[] } => {
+  const abi =
+    action.abi === undefined ? [] : [...(parseAbiStrict(action.abi) ?? [])];
+  const pastedName = action.functionName ?? "";
+  const lookup = pastedName ? findAbiFunction(abi, pastedName) : undefined;
+  const fn = lookup?.kind === "found" ? lookup.fn : undefined;
+
+  // A bare name is accepted but stored as the full signature: the edit modal matches
+  // its select on signatures alone, so a bare name would leave an imported row unable
+  // to hydrate its function or its args.
+  const functionName = fn ? (signatureOf(fn) ?? pastedName) : pastedName;
+
+  const supplied = action.args ?? [];
+  const issues: ImportIssue[] = [];
+  const args: string[] = [];
+
+  // The args the document supplied, not the ABI's inputs: a count mismatch is
+  // `customActionIssues`' to report, and dropping the extras here would hide it.
+  supplied.forEach((value, argIndex) => {
+    const input = fn?.inputs[argIndex];
+    const result = input
+      ? convertImportedArg(input, value)
+      : convertUntypedArg(value);
+
+    if (result.ok) {
+      args.push(result.storage);
+      return;
+    }
+    args.push("");
+    issues.push(
+      ...result.issues.map((issue: ImportedArgIssue) => ({
+        path: ["actions", index, "args", argIndex, ...issue.path],
+        message: issue.message,
+      })),
+    );
+  });
+
+  return {
+    action: {
+      type: "custom",
+      contractAddress: action.contractAddress,
+      abi,
+      functionName,
+      args,
+      ...(action.calldata ? { calldata: action.calldata } : {}),
+    },
+    issues,
+  };
+};
+
+const translateAction = (
+  action: ImportedAction,
+  index: number,
+): { action: PendingAction; issues: ImportIssue[] } => {
+  if (action.type !== "custom") return { action, issues: [] };
+
+  const issues: ImportIssue[] = [];
+
+  // Nothing in the form shows or clears an ETH value. Refused by name rather than
+  // stripped as an unknown key: dropping it quietly would publish 0 wei instead of
+  // what the document asked for.
+  if (action.value !== undefined) {
+    issues.push({
+      path: ["actions", index, "value"],
+      message:
+        "isn't supported yet: nothing in the form can show or clear an ETH value, so it can't be imported",
+    });
+  }
+
+  if (action.abi !== undefined && parseAbiStrict(action.abi) === null) {
+    issues.push({
+      path: ["actions", index, "abi"],
+      message: "must be an array of ABI items",
+    });
+  }
+
+  const translated = translateCustomAction(action, index);
+  return {
+    action: translated.action,
+    issues: [...issues, ...translated.issues],
+  };
+};
+
+const issuesFor = (
+  schema: z.ZodTypeAny,
+  value: unknown,
+  path: (string | number)[],
+): ImportIssue[] => {
+  const result = schema.safeParse(value);
+  if (result.success) return [];
+  return result.error.issues.map((issue) => ({
+    path: [...path, ...issue.path],
+    message: issue.message,
+  }));
+};
+
+/** Completeness is deliberately not checked: a document may legitimately carry
+ *  actions and no title, and the author fills the rest in on the form. */
+const ruleIssues = (action: PendingAction, index: number): ImportIssue[] => {
+  const issues = issuesFor(PendingProposalActionSchema, action, [
+    "actions",
+    index,
+  ]);
+  if (issues.length > 0) return issues;
+
+  if (action.type === "eth-transfer") {
+    const precision = amountPrecisionError(action.amount, ETH_DECIMALS);
+    return precision
+      ? [{ path: ["actions", index, "amount"], message: precision }]
+      : [];
+  }
+  return [];
+};
+
+export const formatImportIssue = (issue: ImportIssue): string => {
+  const path = formatJsonPath(issue.path);
+  return path ? `${path}: ${issue.message}` : issue.message;
+};
+
+export const parseProposalJson = (text: string): ParseProposalJsonResult => {
+  if (!text.trim()) {
+    return {
+      ok: false,
+      issues: [{ path: [], message: "Paste the proposal JSON first." }],
+    };
+  }
+
+  const parsed = parseJsonDocument(text);
+  if (!parsed.ok) {
+    return {
+      ok: false,
+      issues: [
+        {
+          path: [],
+          message:
+            "This isn't valid JSON. Check for a missing comma, quote, or bracket.",
+          line: parsed.line,
+        },
+      ],
+    };
+  }
+
+  const { value: document, lineOf } = parsed.document;
+  if (
+    document === null ||
+    typeof document !== "object" ||
+    Array.isArray(document)
+  ) {
+    return {
+      ok: false,
+      issues: [
+        {
+          path: [],
+          message:
+            'Expected a JSON object with "title", "discussionUrl", "body" or "actions".',
+        },
+      ],
+    };
+  }
+
+  const locate = (issues: ImportIssue[]): ImportIssue[] =>
+    issues.map((issue) => {
+      const line = lineOf(issue.path);
+      return line === undefined ? issue : { ...issue, line };
+    });
+
+  const result = ProposalJsonTransport.safeParse(document);
+  if (!result.success) {
+    return {
+      ok: false,
+      issues: locate(
+        result.error.issues.map((issue) => ({
+          path: [...issue.path],
+          message: issue.message,
+        })),
+      ),
+    };
+  }
+
+  const { title, discussionUrl, body, actions } = result.data;
+  if (
+    title === undefined &&
+    discussionUrl === undefined &&
+    body === undefined &&
+    actions === undefined
+  ) {
+    return {
+      ok: false,
+      issues: [
+        {
+          path: [],
+          message:
+            'No known fields found. Use "title", "discussionUrl", "body" or "actions".',
+        },
+      ],
+    };
+  }
+
+  const translated = actions?.map(translateAction);
+
+  // Before the rules: a value that could not even be rewritten in the form's shape
+  // would fail every rule downstream, in vaguer words.
+  const translationIssues = translated?.flatMap((t) => t.issues) ?? [];
+  if (translationIssues.length > 0) {
+    return { ok: false, issues: locate(translationIssues) };
+  }
+
+  const issues: ImportIssue[] = [
+    ...(title === undefined ? [] : issuesFor(titleSchema, title, ["title"])),
+    ...(discussionUrl === undefined
+      ? []
+      : issuesFor(discussionUrlSchema, discussionUrl, ["discussionUrl"])),
+    ...(body === undefined ? [] : issuesFor(bodySchema, body, ["body"])),
+    ...(translated?.flatMap((t, index) => ruleIssues(t.action, index)) ?? []),
+  ];
+  if (issues.length > 0) return { ok: false, issues: locate(issues) };
+
+  return {
+    ok: true,
+    value: {
+      title,
+      discussionUrl,
+      body,
+      actions: translated?.map((t) => t.action),
+    },
+  };
+};
diff --git a/apps/dashboard/features/create-proposal/utils/resolveImportedDecimals.test.ts b/apps/dashboard/features/create-proposal/utils/resolveImportedDecimals.test.ts
new file mode 100644
index 0000000000..3684f9008d
--- /dev/null
+++ b/apps/dashboard/features/create-proposal/utils/resolveImportedDecimals.test.ts
@@ -0,0 +1,120 @@
+import type { PendingAction } from "@/features/create-proposal/utils/parseProposalJson";
+import {
+  needsDecimalsLookup,
+  resolveImportedDecimals,
+} from "@/features/create-proposal/utils/resolveImportedDecimals";
+
+const USDC = "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48";
+const DAI = "0x6b175474e89094c44da98b954eedeac495271d0f";
+
+const erc20 = (overrides: Record<string, unknown> = {}) =>
+  ({
+    type: "erc20-transfer",
+    recipient: "0x1111111111111111111111111111111111111111",
+    tokenAddress: USDC,
+    amount: "1",
+    ...overrides,
+  }) as PendingAction;
+
+const ethTransfer: PendingAction = {
+  type: "eth-transfer",
+  recipient: "0x1111111111111111111111111111111111111111",
+  amount: "1.5",
+};
+
+const reads = (decimals: number) => async () => decimals;
+
+describe("needsDecimalsLookup", () => {
+  it("is false without an ERC-20 transfer, so no RPC is required", () => {
+    expect(needsDecimalsLookup([ethTransfer])).toBe(false);
+    expect(needsDecimalsLookup([])).toBe(false);
+  });
+
+  it("is true as soon as one is present", () => {
+    expect(needsDecimalsLookup([ethTransfer, erc20()])).toBe(true);
+  });
+});
+
+describe("resolveImportedDecimals", () => {
+  it("fills decimals from the token when the document omits them", async () => {
+    const result = await resolveImportedDecimals([erc20()], reads(6));
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.actions[0]).toMatchObject({
+      tokenAddress: USDC,
+      decimals: 6,
+    });
+  });
+
+  it("accepts a supplied value the token agrees with", async () => {
+    const result = await resolveImportedDecimals(
+      [erc20({ decimals: 6 })],
+      reads(6),
+    );
+
+    expect(result.ok).toBe(true);
+  });
+
+  it("rejects a supplied value the token disagrees with", async () => {
+    const result = await resolveImportedDecimals(
+      [erc20({ decimals: 18 })],
+      reads(6),
+    );
+
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.error).toContain("actions[0].decimals");
+    expect(result.error).toContain("reports 6, not 18");
+  });
+
+  it.each([
+    [
+      "the read throws",
+      async () => {
+        throw new Error("execution reverted");
+      },
+      "couldn't read decimals",
+    ],
+    ["the contract answers with nonsense", reads(Number.NaN), "tokenAddress"],
+  ])("refuses the import when %s", async (_label, read, fragment) => {
+    const result = await resolveImportedDecimals([ethTransfer, erc20()], read);
+
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.error).toContain("actions[1]");
+    expect(result.error).toContain(fragment);
+  });
+
+  it("passes other action types through untouched and never reads", async () => {
+    const read = jest.fn();
+    const custom: PendingAction = {
+      type: "custom",
+      contractAddress: "0x3333333333333333333333333333333333333333",
+      abi: [],
+      functionName: "",
+      args: [],
+      calldata: "0xa9059cbb",
+    };
+
+    const result = await resolveImportedDecimals([ethTransfer, custom], read);
+
+    expect(read).not.toHaveBeenCalled();
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.actions).toEqual([ethTransfer, custom]);
+  });
+
+  it("resolves each transfer against its own token", async () => {
+    const result = await resolveImportedDecimals(
+      [erc20(), erc20({ tokenAddress: DAI })],
+      async (token) => (token === USDC ? 6 : 18),
+    );
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.actions.map((a) => "decimals" in a && a.decimals)).toEqual([
+      6, 18,
+    ]);
+  });
+});
diff --git a/apps/dashboard/features/create-proposal/utils/resolveImportedDecimals.ts b/apps/dashboard/features/create-proposal/utils/resolveImportedDecimals.ts
new file mode 100644
index 0000000000..06ca4e3fb7
--- /dev/null
+++ b/apps/dashboard/features/create-proposal/utils/resolveImportedDecimals.ts
@@ -0,0 +1,59 @@
+import type { ProposalFormValues } from "@/features/create-proposal/schema";
+import type { PendingAction } from "@/features/create-proposal/utils/parseProposalJson";
+
+type FormAction = ProposalFormValues["actions"][number];
+
+export type DecimalsReader = (tokenAddress: string) => Promise<number>;
+
+export type ResolveDecimalsResult =
+  | { ok: true; actions: FormAction[] }
+  | { ok: false; error: string };
+
+/** Settles every imported ERC-20 transfer's `decimals` against the token contract.
+ *  A pasted value goes straight to `parseUnits`: `{ amount: "1", decimals: 18 }`
+ *  against USDC displays as 1 token and encodes 1e18 base units. So it is accepted
+ *  only when the contract agrees, and supplied by it when absent. */
+export const resolveImportedDecimals = async (
+  actions: PendingAction[],
+  readDecimals: DecimalsReader,
+): Promise<ResolveDecimalsResult> => {
+  const resolved: FormAction[] = [];
+
+  for (const [index, action] of actions.entries()) {
+    if (action.type !== "erc20-transfer") {
+      resolved.push(action);
+      continue;
+    }
+
+    let onchain: number;
+    try {
+      onchain = await readDecimals(action.tokenAddress);
+    } catch {
+      return {
+        ok: false,
+        error: `actions[${index}].tokenAddress: couldn't read decimals from ${action.tokenAddress}. Check the address points to an ERC-20 on this network.`,
+      };
+    }
+
+    if (!Number.isInteger(onchain) || onchain < 0) {
+      return {
+        ok: false,
+        error: `actions[${index}].tokenAddress: ${action.tokenAddress} reported decimals of "${String(onchain)}", which isn't a token this form can encode.`,
+      };
+    }
+
+    if (action.decimals !== undefined && action.decimals !== onchain) {
+      return {
+        ok: false,
+        error: `actions[${index}].decimals: the token reports ${onchain}, not ${action.decimals}. Publishing this would transfer the wrong amount.`,
+      };
+    }
+
+    resolved.push({ ...action, decimals: onchain });
+  }
+
+  return { ok: true, actions: resolved };
+};
+
+export const needsDecimalsLookup = (actions: PendingAction[]): boolean =>
+  actions.some((action) => action.type === "erc20-transfer");
diff --git a/apps/dashboard/features/create-proposal/utils/validateArg.ts b/apps/dashboard/features/create-proposal/utils/validateArg.ts
index 78ee9ff5ce..c2e5688847 100644
--- a/apps/dashboard/features/create-proposal/utils/validateArg.ts
+++ b/apps/dashboard/features/create-proposal/utils/validateArg.ts
@@ -1,10 +1,5 @@
-import { isAddress, type AbiParameter } from "viem";
-
+import { isAddressLike } from "@/shared/utils/address";
 import { isEnsAddress } from "@/shared/utils/ens";
-import {
-  parseArrayType,
-  type ArgValue,
-} from "@/features/create-proposal/utils/argTree";
 
 export type AbiTypeCategory =
   | "bool"
@@ -53,7 +48,6 @@ export function getArgPlaceholder(abiType: string): string {
   }
 }
 
-/** Validates a single scalar leaf value. Returns an error message or null. */
 export function validateSolidityArg(
   abiType: string,
   value: string,
@@ -88,7 +82,7 @@ export function validateSolidityArg(
       return null;
     }
     case "address":
-      return !isAddress(v, { strict: false }) && !isEnsAddress(v)
+      return !isAddressLike(v) && !isEnsAddress(v)
         ? "Must be a valid address or ENS name"
         : null;
     case "bytes_dynamic":
@@ -105,35 +99,3 @@ export function validateSolidityArg(
       return null;
   }
 }
-
-const getComponents = (param: AbiParameter): readonly AbiParameter[] =>
-  (param as { components?: readonly AbiParameter[] }).components ?? [];
-
-/**
- * Recursively checks whether an argument value tree is complete and valid:
- * every scalar leaf is non-empty and passes `validateSolidityArg`; arrays honor
- * their fixed length (an empty dynamic array is valid); tuples require every
- * component complete.
- */
-export const isArgComplete = (
-  param: AbiParameter,
-  value: ArgValue,
-): boolean => {
-  const arr = parseArrayType(param.type);
-  if (arr) {
-    if (!Array.isArray(value)) return false;
-    if (arr.length !== null && value.length !== arr.length) return false;
-    const child = { ...param, type: arr.elementType } as AbiParameter;
-    return value.every((v) => isArgComplete(child, v));
-  }
-  if (param.type === "tuple") {
-    if (!Array.isArray(value)) return false;
-    return getComponents(param).every((c, i) =>
-      isArgComplete(c, value[i] ?? ""),
-    );
-  }
-  if (typeof value !== "string") return false;
-  return (
-    value.trim().length > 0 && validateSolidityArg(param.type, value) === null
-  );
-};
diff --git a/apps/dashboard/features/create-proposal/utils/validateCustomAction.test.ts b/apps/dashboard/features/create-proposal/utils/validateCustomAction.test.ts
new file mode 100644
index 0000000000..4ae9e24da2
--- /dev/null
+++ b/apps/dashboard/features/create-proposal/utils/validateCustomAction.test.ts
@@ -0,0 +1,367 @@
+import { customActionIssues } from "@/features/create-proposal/utils/validateCustomAction";
+
+const abiOf = (inputs: unknown[], name = "call", extra: object = {}) => [
+  {
+    type: "function",
+    name,
+    stateMutability: "nonpayable",
+    inputs,
+    outputs: [],
+    ...extra,
+  },
+];
+
+const action = (overrides: Record<string, unknown> = {}) => ({
+  abi: [] as unknown[],
+  functionName: "",
+  args: [] as string[],
+  ...overrides,
+});
+
+const call = (overrides: Record<string, unknown> = {}) =>
+  action({
+    abi: abiOf(
+      [
+        { name: "who", type: "address" },
+        { name: "value", type: "uint256" },
+      ],
+      "setValue",
+    ),
+    functionName: "setValue(address,uint256)",
+    args: ["vitalik.eth", "1"],
+    ...overrides,
+  });
+
+const callTaking = (type: string, arg: string) =>
+  action({
+    abi: abiOf([{ name: "value", type }], "fine"),
+    functionName: "fine",
+    args: [arg],
+  });
+
+const expectIssue = (
+  issues: ReturnType<typeof customActionIssues>,
+  path: (string | number)[],
+  fragment?: string,
+) => {
+  expect(issues.length).toBeGreaterThan(0);
+  expect(issues[0].path).toEqual(path);
+  if (fragment) expect(issues[0].message).toContain(fragment);
+};
+
+/* The rules every entry point is held to. The JSON import runs these rather than
+ * restating them, so this file is where they are specified. */
+describe("customActionIssues", () => {
+  it("passes a well-formed call", () => {
+    expect(customActionIssues(call())).toEqual([]);
+  });
+
+  it("requires one of functionName or calldata", () => {
+    expectIssue(customActionIssues(action()), ["functionName"], "Required");
+  });
+
+  describe("calldata", () => {
+    it("accepts hex, and skips the rest of the abi checks", () => {
+      expect(
+        customActionIssues(
+          action({ calldata: "0xa9059cbb", abi: ["garbage"] }),
+        ),
+      ).toEqual([]);
+    });
+
+    it("still reports a malformed function entry", () => {
+      expectIssue(
+        customActionIssues(
+          action({ calldata: "0xa9059cbb", abi: [{ type: "function" }] }),
+        ),
+        ["abi"],
+      );
+    });
+
+    it("accepts a bare 0x, the empty-calldata form viem produces", () => {
+      expect(customActionIssues(action({ calldata: "0x" }))).toEqual([]);
+    });
+
+    it.each([
+      ["a function signature", "transfer(address,uint256)"],
+      ["a non-hex string", "not calldata"],
+      ["hex without the 0x prefix", "a9059cbb"],
+      ["an odd number of characters", "0xa9059cb"],
+    ])("rejects calldata that is %s", (_label, calldata) => {
+      expectIssue(customActionIssues(action({ calldata })), ["calldata"]);
+    });
+
+    describe("mixed with an ABI call", () => {
+      it("rejects a function name alongside valid calldata", () => {
+        expectIssue(
+          customActionIssues(call({ calldata: "0xa9059cbb" })),
+          ["calldata"],
+          "keep either",
+        );
+      });
+
+      it("rejects a bare function name alongside valid calldata", () => {
+        expectIssue(
+          customActionIssues(
+            action({ calldata: "0x", functionName: "transfer" }),
+          ),
+          ["calldata"],
+          "keep either",
+        );
+      });
+
+      it("takes whitespace as absent, not as a second half", () => {
+        expect(
+          customActionIssues(action({ calldata: "0x", functionName: "   " })),
+        ).toEqual([]);
+        expect(customActionIssues(call({ calldata: "   " }))).toEqual([]);
+      });
+    });
+  });
+
+  describe("resolving the function", () => {
+    it("requires an abi when a function name is used", () => {
+      expectIssue(
+        customActionIssues(action({ functionName: "setValue(uint256)" })),
+        ["abi"],
+      );
+    });
+
+    it("accepts a bare name that resolves to one function", () => {
+      expect(customActionIssues(call({ functionName: "setValue" }))).toEqual(
+        [],
+      );
+    });
+
+    it("rejects a function that isn't in the abi", () => {
+      expectIssue(
+        customActionIssues(call({ functionName: "missing()", args: [] })),
+        ["functionName"],
+        "missing()",
+      );
+    });
+
+    it.each(["view", "pure"])("rejects a %s function", (stateMutability) => {
+      expectIssue(
+        customActionIssues(
+          action({
+            abi: abiOf([{ name: "who", type: "address" }], "balanceOf", {
+              stateMutability,
+              outputs: [{ name: "", type: "uint256" }],
+            }),
+            functionName: "balanceOf(address)",
+            args: ["vitalik.eth"],
+          }),
+        ),
+        ["functionName"],
+        "only reads state",
+      );
+    });
+
+    it("accepts a function with no stateMutability, as the modal does", () => {
+      expect(
+        customActionIssues(
+          action({
+            abi: [
+              {
+                type: "function",
+                name: "legacy",
+                inputs: [{ name: "value", type: "uint256" }],
+                outputs: [],
+              },
+            ],
+            functionName: "legacy(uint256)",
+            args: ["1"],
+          }),
+        ),
+      ).toEqual([]);
+    });
+
+    describe("overloads", () => {
+      const overloaded = (functionName: string) =>
+        action({
+          abi: [
+            ...abiOf([{ name: "a", type: "uint256" }], "foo"),
+            ...abiOf([{ name: "a", type: "address" }], "foo"),
+          ],
+          functionName,
+          args: ["0x1111111111111111111111111111111111111111"],
+        });
+
+      it("rejects a bare name several functions share", () => {
+        const issues = customActionIssues(overloaded("foo"));
+        expectIssue(issues, ["functionName"], "foo(uint256)");
+        expect(issues[0].message).toContain("foo(address)");
+      });
+
+      it.each(["foo(uint256)", "foo(address)"])("takes %s", (signature) => {
+        expect(customActionIssues(overloaded(signature))).toEqual([]);
+      });
+    });
+  });
+
+  describe("malformed entries", () => {
+    it.each([
+      ["no name", { type: "function", inputs: [], outputs: [] }],
+      ["no inputs", { type: "function", name: "setValue", outputs: [] }],
+      [
+        "a non-string name",
+        { type: "function", name: 42, inputs: [], outputs: [] },
+      ],
+      [
+        "an input with no type",
+        { type: "function", name: "x", inputs: [{}], outputs: [] },
+      ],
+    ])("reports an entry with %s instead of throwing", (_label, entry) => {
+      const run = () =>
+        customActionIssues(
+          action({
+            abi: [...abiOf([], "setValue"), entry],
+            functionName: "setValue",
+          }),
+        );
+
+      expect(run).not.toThrow();
+      expectIssue(run(), ["abi"]);
+    });
+  });
+
+  describe("parameter types", () => {
+    it.each([
+      ["an out-of-range integer width", "uint257"],
+      ["an unaligned integer width", "uint7"],
+      ["an out-of-range bytes width", "bytes33"],
+      ["a broken array suffix", "uint256[abc]"],
+      ["a type viem cannot encode", "function"],
+      ["a fixed-point type", "fixed128x18"],
+      ["a nonsense type", "notAType"],
+    ])("rejects %s", (_label, type) => {
+      expectIssue(customActionIssues(callTaking(type, "1")), ["abi"], type);
+    });
+
+    it.each([
+      ["address", "vitalik.eth"],
+      ["bool", "true"],
+      ["bytes", "0xdeadbeef"],
+      ["uint", "1"],
+      ["int128", "-1"],
+      ["uint256[]", "[]"],
+    ])("accepts %s", (type, arg) => {
+      expect(customActionIssues(callTaking(type, arg))).toEqual([]);
+    });
+
+    it("ignores an unencodable type in a function it isn't calling", () => {
+      expect(
+        customActionIssues(
+          action({
+            abi: [
+              ...abiOf([{ name: "cb", type: "function" }], "exotic"),
+              ...abiOf([{ name: "value", type: "uint256" }], "plain"),
+            ],
+            functionName: "plain",
+            args: ["1"],
+          }),
+        ),
+      ).toEqual([]);
+    });
+
+    it.each([
+      ["a bare tuple", "tuple"],
+      ["a tuple array", "tuple[]"],
+    ])("rejects %s with no components", (_label, type) => {
+      expectIssue(customActionIssues(callTaking(type, "[]")), ["abi"]);
+    });
+  });
+
+  describe("arguments", () => {
+    it.each([
+      ["too few", []],
+      ["too many", ["vitalik.eth", "1", "2"]],
+    ])("rejects %s for the function", (_label, args) => {
+      expectIssue(customActionIssues(call({ args })), ["args"], "takes 2");
+    });
+
+    it.each([
+      ["one that doesn't fit its type", ["not-an-address", "1"], 0],
+      ["a blank one", ["vitalik.eth", "  "], 1],
+    ])("rejects %s", (_label, args, index) => {
+      expectIssue(customActionIssues(call({ args })), ["args", index]);
+    });
+
+    describe("composites", () => {
+      const withArg = (arg: string) =>
+        customActionIssues(callTaking("uint256[]", arg));
+
+      it("accepts a JSON array", () => {
+        expect(withArg('["1", "2"]')).toEqual([]);
+      });
+
+      it.each([
+        ["isn't JSON", "not json"],
+        ["is JSON but not an array", '{"nope":1}'],
+      ])("rejects a composite that %s", (_label, arg) => {
+        expectIssue(withArg(arg), ["args", 0], "must be a JSON array");
+      });
+
+      it("rejects an array whose elements don't fit the type", () => {
+        expectIssue(withArg('["not a number"]'), ["args", 0, 0]);
+      });
+
+      it.each([
+        ["an object leaf", "[{}]"],
+        ["a null leaf", "[null]"],
+        ["a list where a value goes", "[[1]]"],
+      ])("rejects a dynamic composite with %s", (_label, arg) => {
+        expectIssue(withArg(arg), ["args", 0]);
+      });
+
+      describe("tuple field counts", () => {
+        const pair = (type: string, arg: string) =>
+          customActionIssues(
+            action({
+              abi: abiOf(
+                [
+                  {
+                    name: "data",
+                    type,
+                    components: [
+                      { name: "who", type: "address" },
+                      { name: "value", type: "uint256" },
+                    ],
+                  },
+                ],
+                "setPair",
+              ),
+              functionName: "setPair",
+              args: [arg],
+            }),
+          );
+
+        it("accepts a tuple with exactly its components", () => {
+          expect(pair("tuple", '["vitalik.eth", "1"]')).toEqual([]);
+        });
+
+        it.each([
+          ["one field too many", '["vitalik.eth", "1", "unexpected"]'],
+          ["one field short", '["vitalik.eth"]'],
+        ])("rejects a tuple with %s", (_label, arg) => {
+          expectIssue(pair("tuple", arg), ["args", 0]);
+        });
+
+        it("rejects an object where an array wants a tuple", () => {
+          expectIssue(pair("tuple[]", "[{}]"), ["args", 0]);
+        });
+
+        it("rejects an over-filled tuple nested in an array", () => {
+          expectIssue(
+            pair(
+              "tuple[]",
+              '[["vitalik.eth", "1"], ["vitalik.eth", "1", "x"]]',
+            ),
+            ["args", 0],
+          );
+        });
+      });
+    });
+  });
+});
diff --git a/apps/dashboard/features/create-proposal/utils/validateCustomAction.ts b/apps/dashboard/features/create-proposal/utils/validateCustomAction.ts
new file mode 100644
index 0000000000..aba954feeb
--- /dev/null
+++ b/apps/dashboard/features/create-proposal/utils/validateCustomAction.ts
@@ -0,0 +1,204 @@
+import { isHex, toFunctionSignature, type AbiFunction } from "viem";
+
+import {
+  isEncodableParam,
+  isWellFormedFunction,
+} from "@/features/create-proposal/utils/abiSchema";
+import { argIssues } from "@/features/create-proposal/utils/argIssues";
+import type { Issue } from "@/features/create-proposal/utils/issues";
+import {
+  storageToArg,
+  type ArgValue,
+} from "@/features/create-proposal/utils/argTree";
+
+export type ActionIssue = Issue;
+
+type CustomActionLike = {
+  abi: readonly unknown[];
+  functionName: string;
+  args: readonly string[];
+  calldata?: string;
+};
+
+export const signatureOf = (fn: AbiFunction): string | null => {
+  try {
+    return toFunctionSignature(fn);
+  } catch {
+    return null;
+  }
+};
+
+export type AbiFunctionLookup =
+  | { kind: "found"; fn: AbiFunction }
+  | { kind: "missing" }
+  | { kind: "ambiguous"; signatures: string[] }
+  | { kind: "readOnly"; signature: string };
+
+/** The modal keeps `view` and `pure` out of its function list, so one of those
+ *  could never be selected there, let alone hydrated on edit. */
+const isStateChanging = (fn: AbiFunction): boolean =>
+  fn.stateMutability !== "view" && fn.stateMutability !== "pure";
+
+export const findAbiFunction = (
+  abi: readonly unknown[],
+  functionName: string,
+): AbiFunctionLookup => {
+  const functions = abi.filter(isWellFormedFunction);
+  const named = (item: AbiFunction) =>
+    signatureOf(item) === functionName || item.name === functionName;
+
+  const candidates = functions.filter(isStateChanging);
+
+  const bySignature = candidates.find(
+    (item) => signatureOf(item) === functionName,
+  );
+  if (bySignature) return { kind: "found", fn: bySignature };
+
+  // A bare name shared by overloads is reported, not resolved: the args do not
+  // narrow it either, since the uint validator accepts 0x hex.
+  const sharingName = candidates.filter((item) => item.name === functionName);
+  if (sharingName.length === 1) return { kind: "found", fn: sharingName[0] };
+  if (sharingName.length > 1) {
+    return {
+      kind: "ambiguous",
+      signatures: sharingName.map((fn) => signatureOf(fn) ?? fn.name),
+    };
+  }
+
+  const readOnly = functions.find(named);
+  if (readOnly) {
+    return {
+      kind: "readOnly",
+      signature: signatureOf(readOnly) ?? readOnly.name,
+    };
+  }
+  return { kind: "missing" };
+};
+
+const isFunctionEntry = (item: unknown): boolean =>
+  typeof item === "object" &&
+  item !== null &&
+  (item as { type?: unknown }).type === "function";
+
+const messageOf = (error: unknown): string =>
+  error instanceof Error ? error.message : "could not be read";
+
+/** Everything that has to be true for a custom action to produce the calldata it
+ *  claims. One place, because a paste, a hand-built action and an API draft all
+ *  pass through it. */
+export const customActionIssues = (action: CustomActionLike): ActionIssue[] => {
+  const hasCalldata = Boolean(action.calldata?.trim());
+  const hasFunctionName = action.functionName.trim().length > 0;
+
+  if (!hasCalldata && !hasFunctionName) {
+    return [{ path: ["functionName"], message: "Required" }];
+  }
+
+  // Exclusive: the encoder returns on the calldata before it looks at the ABI,
+  // while the row's subtitle is the `functionName` — so a row reading
+  // `transfer(address,uint256)` could carry arbitrary bytes.
+  if (hasCalldata && hasFunctionName) {
+    return [
+      {
+        path: ["calldata"],
+        message:
+          "Can't be combined with a function name; keep either the raw calldata or the ABI call",
+      },
+    ];
+  }
+
+  if (
+    // Checked whichever half produces the calldata: the ABI is stored either way and
+    // the edit modal formats every function in it to fill its select.
+    action.abi.some(
+      (item) => isFunctionEntry(item) && !isWellFormedFunction(item),
+    )
+  ) {
+    return [
+      {
+        path: ["abi"],
+        message:
+          'Has a "function" entry without a name, or with a malformed input',
+      },
+    ];
+  }
+
+  if (hasCalldata) {
+    const calldata = action.calldata!.trim();
+    if (!isHex(calldata) || calldata.length % 2 !== 0) {
+      return [
+        {
+          path: ["calldata"],
+          message: "Must be 0x-prefixed hex with an even number of characters",
+        },
+      ];
+    }
+    return [];
+  }
+
+  if (action.abi.length === 0) {
+    return [
+      { path: ["abi"], message: "Required when a function name is used" },
+    ];
+  }
+
+  const lookup = findAbiFunction(action.abi, action.functionName.trim());
+
+  if (lookup.kind === "missing") {
+    return [
+      {
+        path: ["functionName"],
+        message: `"${action.functionName}" is not a function in this ABI`,
+      },
+    ];
+  }
+  if (lookup.kind === "readOnly") {
+    return [
+      {
+        path: ["functionName"],
+        message: `${lookup.signature} only reads state, so it can't be a proposal action`,
+      },
+    ];
+  }
+  if (lookup.kind === "ambiguous") {
+    return [
+      {
+        path: ["functionName"],
+        message: `"${action.functionName}" is overloaded here (${lookup.signatures.join(", ")}); name the one you mean in full`,
+      },
+    ];
+  }
+
+  const fn = lookup.fn;
+
+  // Scoped to the selected function: an exotic type in an unrelated entry of a real
+  // contract's ABI is none of our business.
+  const unencodable = fn.inputs.filter((input) => !isEncodableParam(input));
+  if (unencodable.length > 0) {
+    return unencodable.map((input) => ({
+      path: ["abi"],
+      message: `Declares "${input.type}" for ${input.name || "an argument"}, which isn't an encodable ABI type`,
+    }));
+  }
+
+  if (action.args.length !== fn.inputs.length) {
+    return [
+      {
+        path: ["args"],
+        message: `${signatureOf(fn) ?? fn.name} takes ${fn.inputs.length}, got ${action.args.length}`,
+      },
+    ];
+  }
+
+  // Reported at the exact leaf. What to do with that precision is the caller's: the
+  // import dialog prints the path, the form only counts them.
+  return fn.inputs.flatMap<ActionIssue>((input, i) => {
+    let tree: ArgValue;
+    try {
+      tree = storageToArg(input, action.args[i] ?? "");
+    } catch (error) {
+      return [{ path: ["args", i], message: messageOf(error) }];
+    }
+    return argIssues(input, tree, ["args", i]);
+  });
+};
diff --git a/apps/dashboard/features/governance/components/governance-overview/GovernanceSection.tsx b/apps/dashboard/features/governance/components/governance-overview/GovernanceSection.tsx
index 0ac1bf4b90..ddb4415ad7 100644
--- a/apps/dashboard/features/governance/components/governance-overview/GovernanceSection.tsx
+++ b/apps/dashboard/features/governance/components/governance-overview/GovernanceSection.tsx
@@ -9,7 +9,7 @@ import {
   useOffchainSearchProposals,
   useSearchProposals,
 } from "@anticapture/client/hooks";
-import { Building2, Landmark, MessageSquare, Plus, Search } from "lucide-react";
+import { Building2, Landmark, MessageSquare, Search } from "lucide-react";
 import { parseAsString, parseAsStringEnum, useQueryState } from "nuqs";
 import { useParams, usePathname, useRouter } from "next/navigation";
 import {
@@ -26,7 +26,12 @@ import {
   DraftCard,
   DraftEmptyState,
   DeleteDraftModal,
+  ImportJsonModal,
+  NewProposalMenu,
+  clearImportedProposal,
+  stashImportedProposal,
   useDrafts,
+  type ImportedProposal,
 } from "@/features/create-proposal";
 import { showCustomToast } from "@/features/governance/utils/showCustomToast";
 import { copyDraftShareUrl } from "@/features/create-proposal/utils/draftShareUrl";
@@ -108,7 +113,6 @@ const toGovernanceProposal = (
       against: againstVotes.toFixed(2),
       abstain: abstainVotes.toFixed(2),
       total: total.toFixed(2),
-      // Keep precision for bar widths; consumers round for display
       forPercentage: forPercentage.toFixed(2),
       againstPercentage: againstPercentage.toFixed(2),
       abstainPercentage: abstainPercentage.toFixed(2),
@@ -133,8 +137,6 @@ export const GovernanceSection = () => {
   const canCreateProposal = canCreateProposalForDao(daoIdEnum);
   const { decimals } = daoConfig[daoIdEnum];
   const router = useRouter();
-  // Drafts are platform-account data: gates run on the session (email and
-  // Google authors have no wallet), not on the wallet connection.
   const { data: session, isPending: isSessionPending } = useAuthSession();
   const hasSession = !!session;
   const { openLogin } = useLogin();
@@ -153,6 +155,7 @@ export const GovernanceSection = () => {
     ]).withDefault("all"),
   );
 
+  const [importOpen, setImportOpen] = useState(false);
   const [draftToDelete, setDraftToDelete] = useState<string | null>(null);
   const {
     drafts,
@@ -229,8 +232,6 @@ export const GovernanceSection = () => {
     return tabs;
   }, [canCreateProposal, hasSession]);
 
-  // DAOs without offchain proposals ignore the source filter — otherwise a
-  // stale ?source=snapshot in the URL would render an empty, unrecoverable list
   const effectiveSource = hasOffchain ? sourceFilter : "all";
   const showOnchain = effectiveSource !== "snapshot";
   const showOffchain = hasOffchain && effectiveSource !== "governor";
@@ -242,9 +243,6 @@ export const GovernanceSection = () => {
     (showOnchain && isOnchainPaginationLoading) ||
     (showOffchain && isOffchainPaginationLoading);
 
-  // Both sources are paginated independently, so the merged list is only
-  // chronologically safe down to the older of the two loaded frontiers —
-  // items below that line could still interleave with unfetched pages.
   const mergedProposals = useMemo<MergedProposalItem[]>(() => {
     const onchainList = showOnchain
       ? isSearchActive
@@ -328,8 +326,6 @@ export const GovernanceSection = () => {
   ]);
 
   useEffect(() => {
-    // Only reset after the session RESOLVES signed-out — resetting during the
-    // initial pending state would eat a legitimate ?tab=drafts deep link.
     if (
       activeTab === "drafts" &&
       (!canCreateProposal || (!isSessionPending && !hasSession))
@@ -363,12 +359,25 @@ export const GovernanceSection = () => {
     return () => observer.disconnect();
   }, [handleLoadMore, isSearchActive]);
 
-  const handleNewProposal = () => {
+  const goToNewProposal = () => {
+    const target = `${basePath}/proposals/new`;
     if (!hasSession) {
-      openLogin({ redirectTo: `${basePath}/proposals/new` });
-    } else {
-      router.push(`${basePath}/proposals/new`);
+      openLogin({
+        redirectTo: target,
+        onDismiss: () => clearImportedProposal(daoId),
+      });
+      return;
     }
+    router.push(target);
+  };
+
+  const handleImported = (values: ImportedProposal): boolean => {
+    if (!stashImportedProposal(daoId, values)) {
+      showCustomToast("Could not carry the import to the form", "error");
+      return false;
+    }
+    goToNewProposal();
+    return true;
   };
 
   const forumLink = daoConfig[daoIdEnum]?.forumLink;
@@ -389,20 +398,28 @@ export const GovernanceSection = () => {
         </Button>
       )}
       {canCreateProposal && (
-        <Button
-          variant="primary"
-          size="md"
-          onClick={handleNewProposal}
-          className="flex-1 whitespace-nowrap lg:w-fit lg:flex-none"
-          data-umami-event="proposal_create_click"
-          data-umami-event-dao={daoId}
-          data-ph-event="proposal_create_click"
-          data-ph-source="governance_overview"
-          data-ph-dao={daoId}
-        >
-          <Plus className="size-4" />
-          New Proposal
-        </Button>
+        <NewProposalMenu
+          onCreateNew={goToNewProposal}
+          onImportJson={() => setImportOpen(true)}
+          triggerProps={{
+            "data-umami-event": "proposal_create_click",
+            "data-umami-event-dao": daoId,
+            "data-ph-event": "proposal_create_click",
+            "data-ph-source": "governance_overview",
+            "data-ph-dao": daoId,
+          }}
+        />
+      )}
+      {/* Mounted beside the trigger rather than in the page body: the dialog
+          portals out anyway, and the header is rendered from more than one branch
+          below, so this is the one place it is guaranteed to exist wherever the
+          menu that opens it does. */}
+      {canCreateProposal && (
+        <ImportJsonModal
+          open={importOpen}
+          onOpenChange={setImportOpen}
+          onImport={handleImported}
+        />
       )}
       <ReportPanelButton panel="Proposals" />
     </div>
diff --git a/apps/dashboard/package.json b/apps/dashboard/package.json
index a94b8a1267..d1e0309e7c 100644
--- a/apps/dashboard/package.json
+++ b/apps/dashboard/package.json
@@ -47,6 +47,7 @@
     "@snapshot-labs/snapshot.js": "^0.12.62",
     "@tanstack/react-query": "^5.59.16",
     "@tanstack/react-table": "^8.20.5",
+    "abitype": "1.2.3",
     "axios": "^1.9.0",
     "better-auth": "^1.3.7",
     "class-variance-authority": "^0.7.1",
@@ -55,6 +56,7 @@
     "echarts": "^6.0.0",
     "echarts-for-react": "^3.0.6",
     "ethers": "^6.13.5",
+    "jsonc-parser": "3.2.0",
     "lottie-react": "^2.4.1",
     "lucide-react": "^0.511.0",
     "markdown-to-jsx": "^7.7.13",
diff --git a/apps/dashboard/shared/services/auth/LoginProvider.tsx b/apps/dashboard/shared/services/auth/LoginProvider.tsx
index 42b1143de5..c068693024 100644
--- a/apps/dashboard/shared/services/auth/LoginProvider.tsx
+++ b/apps/dashboard/shared/services/auth/LoginProvider.tsx
@@ -20,12 +20,11 @@ import { isWalletSessionStale } from "@/shared/services/auth/walletSession";
 import type { DaoIdEnum } from "@/shared/types/daos";
 
 export type OpenLoginOptions = {
-  /** Route to navigate to once the user authenticates. */
   redirectTo?: string;
+  onDismiss?: () => void;
 };
 
 type LoginContextValue = {
-  /** Opens the sign-in modal. */
   openLogin: (options?: OpenLoginOptions) => void;
   isOpen: boolean;
 };
@@ -46,36 +45,18 @@ export function LoginProvider({
   const { status: walletStatus, address } = useAccount();
   const { connectModalOpen } = useConnectModal();
   const [isOpen, setIsOpen] = useState(false);
-  // Where to land after sign-in (login-gated pages pass their own route).
-  // Cleared when the modal is dismissed without authenticating.
   const [redirectTo, setRedirectTo] = useState<string | null>(null);
 
+  const onDismissRef = useRef<(() => void) | null>(null);
+
   const openLogin = useCallback((options?: OpenLoginOptions) => {
     setRedirectTo(options?.redirectTo ?? null);
+    onDismissRef.current = options?.onDismiss ?? null;
     setIsOpen(true);
   }, []);
 
-  // Wallet ⟷ session coherence. Stands down while the sign-in modal OR
-  // RainbowKit's connect modal is up: the ceremony legitimately passes
-  // through connected-without-a-session and must never be yanked mid-flight.
   const authFlowActive = isOpen || connectModalOpen;
 
-  // Wallet-born sessions (SIWE stores the wallet address as the user name)
-  // stay bound to that wallet: disconnecting it, now or on a later visit,
-  // means signed out, and switching to a DIFFERENT account signs the old
-  // session out, so on-chain actions and the platform identity can't diverge.
-  // Email/Google sessions are wallet-independent.
-  //
-  // The reverse does NOT hold: a connected wallet without a session is a
-  // perfectly valid state. Connecting is not signing in, and everything
-  // on-chain (vote, delegate, publish) works from the connection alone, so
-  // nothing here disconnects the wallet and nothing re-opens the sign-in
-  // modal on its own. Signing in is always something the user asks for.
-  //
-  // Sign-out is the cleanup, not the gate. It is a request: it can be in
-  // flight, and it can fail. What actually keeps the old account safe is
-  // `isWalletSessionStale`, which every session-backed surface reads through
-  // `useAuthSession` and which is true from the render the mismatch appears.
   useEffect(() => {
     if (authFlowActive || !session) return;
     const stale = isWalletSessionStale({
@@ -88,15 +69,13 @@ export function LoginProvider({
 
   const handleOpenChange = useCallback((open: boolean) => {
     setIsOpen(open);
-    if (!open) setRedirectTo(null);
+    if (open) return;
+    setRedirectTo(null);
+    const onDismiss = onDismissRef.current;
+    onDismissRef.current = null;
+    onDismiss?.();
   }, []);
 
-  // Sign-in completion: a session for a NEW user appearing while the modal
-  // is open (SIWE verify refreshed the store, a magic link opened in this
-  // tab, a gated click that raced session loading, or an email session being
-  // replaced by a SIWE one) closes the modal and honors the redirect.
-  // Keyed by user id, so an already-signed-in user opening the modal (e.g.
-  // to connect a wallet) doesn't get it self-closed.
   const prevUserId = useRef<string | null>(null);
   useEffect(() => {
     const userId = session?.user.id ?? null;
@@ -104,6 +83,7 @@ export function LoginProvider({
       setIsOpen(false);
       if (redirectTo) router.push(redirectTo);
       setRedirectTo(null);
+      onDismissRef.current = null;
     }
     prevUserId.current = userId;
   }, [session, isOpen, redirectTo, router]);
diff --git a/apps/dashboard/shared/utils/address.ts b/apps/dashboard/shared/utils/address.ts
new file mode 100644
index 0000000000..b702db4a61
--- /dev/null
+++ b/apps/dashboard/shared/utils/address.ts
@@ -0,0 +1,7 @@
+import { getAddress, isAddress } from "viem";
+
+export const isAddressLike = (value: string): boolean =>
+  isAddress(value.trim(), { strict: false });
+
+export const toChecksumAddress = (value: string): `0x${string}` =>
+  getAddress(value.trim());
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 0ee859d42a..d0306cbb41 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -379,6 +379,9 @@ importers:
       "@tanstack/react-table":
         specifier: ^8.20.5
         version: 8.21.3(react-dom@19.2.3(react@19.2.3))(react@19.2.3)
+      abitype:
+        specifier: 1.2.3
+        version: 1.2.3(typescript@5.9.3)(zod@3.25.76)
       axios:
         specifier: ^1.9.0
         version: 1.13.6
@@ -403,6 +406,9 @@ importers:
       ethers:
         specifier: ^6.13.5
         version: 6.16.0(bufferutil@4.0.9)(utf-8-validate@5.0.10)
+      jsonc-parser:
+        specifier: 3.2.0
+        version: 3.2.0
       lottie-react:
         specifier: ^2.4.1
         version: 2.4.1(react-dom@19.2.3(react@19.2.3))(react@19.2.3)
@@ -992,7 +998,7 @@ importers:
         version: 4.9.6
       forge-std:
         specifier: github:foundry-rs/forge-std
-        version: https://codeload.github.com/foundry-rs/forge-std/tar.gz/6e8c4a92c9a8b31c1b0f0c39296d1fa4695c7df8
+        version: https://codeload.github.com/foundry-rs/forge-std/tar.gz/74302c55493479410b143d9dd08a60690c726ffe
 
   packages/observability:
     dependencies:
@@ -7741,7 +7747,7 @@ packages:
       {
         integrity: sha512-IHnV6A+zxU7XwmKFinmYjUcwlyK9+xkG3/s9KcQhI9BjQKycrJ1JRO+FbNYPwZiPKW3je/DR0k7w8/gLa5eaxQ==,
       }
-    deprecated: 'Switch to "qr" (new package name) for security updates: npm install qr'
+    deprecated: 'The package is now available as "qr": npm install qr'
 
   "@peculiar/asn1-cms@2.7.0":
     resolution:
@@ -16416,10 +16422,10 @@ packages:
       }
     engines: { node: ">=14" }
 
-  forge-std@https://codeload.github.com/foundry-rs/forge-std/tar.gz/6e8c4a92c9a8b31c1b0f0c39296d1fa4695c7df8:
+  forge-std@https://codeload.github.com/foundry-rs/forge-std/tar.gz/74302c55493479410b143d9dd08a60690c726ffe:
     resolution:
       {
-        tarball: https://codeload.github.com/foundry-rs/forge-std/tar.gz/6e8c4a92c9a8b31c1b0f0c39296d1fa4695c7df8,
+        tarball: https://codeload.github.com/foundry-rs/forge-std/tar.gz/74302c55493479410b143d9dd08a60690c726ffe,
       }
     version: 1.16.2
 
@@ -39990,7 +39996,7 @@ snapshots:
       "@next/eslint-plugin-next": 16.2.6
       eslint: 9.39.4(jiti@2.6.1)
       eslint-import-resolver-node: 0.3.9
-      eslint-import-resolver-typescript: 3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.53.0(eslint@9.39.4(jiti@2.6.1))(typescript@5.9.3))(eslint-import-resolver-typescript@4.4.4(eslint-plugin-import@2.32.0)(eslint@9.39.4(jiti@2.6.1)))(eslint@9.39.4(jiti@2.6.1)))(eslint@9.39.4(jiti@2.6.1))
+      eslint-import-resolver-typescript: 3.10.1(eslint-plugin-import@2.32.0)(eslint@9.39.4(jiti@2.6.1))
       eslint-plugin-import: 2.32.0(@typescript-eslint/parser@8.53.0(eslint@9.39.4(jiti@2.6.1))(typescript@5.9.3))(eslint-import-resolver-typescript@3.10.1)(eslint@9.39.4(jiti@2.6.1))
       eslint-plugin-jsx-a11y: 6.10.2(eslint@9.39.4(jiti@2.6.1))
       eslint-plugin-react: 7.37.5(eslint@9.39.4(jiti@2.6.1))
@@ -40024,7 +40030,7 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.53.0(eslint@9.39.4(jiti@2.6.1))(typescript@5.9.3))(eslint-import-resolver-typescript@4.4.4(eslint-plugin-import@2.32.0)(eslint@9.39.4(jiti@2.6.1)))(eslint@9.39.4(jiti@2.6.1)))(eslint@9.39.4(jiti@2.6.1)):
+  eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0)(eslint@9.39.4(jiti@2.6.1)):
     dependencies:
       "@nolyfill/is-core-module": 1.0.39
       debug: 4.4.3
@@ -40054,14 +40060,14 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  eslint-module-utils@2.12.1(@typescript-eslint/parser@8.53.0(eslint@9.39.4(jiti@2.6.1))(typescript@5.9.3))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.53.0(eslint@9.39.4(jiti@2.6.1))(typescript@5.9.3))(eslint-import-resolver-typescript@4.4.4(eslint-plugin-import@2.32.0)(eslint@9.39.4(jiti@2.6.1)))(eslint@9.39.4(jiti@2.6.1)))(eslint@9.39.4(jiti@2.6.1)))(eslint@9.39.4(jiti@2.6.1)):
+  eslint-module-utils@2.12.1(@typescript-eslint/parser@8.53.0(eslint@9.39.4(jiti@2.6.1))(typescript@5.9.3))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@4.4.4)(eslint@9.39.4(jiti@2.6.1)):
     dependencies:
       debug: 3.2.7
     optionalDependencies:
       "@typescript-eslint/parser": 8.53.0(eslint@9.39.4(jiti@2.6.1))(typescript@5.9.3)
       eslint: 9.39.4(jiti@2.6.1)
       eslint-import-resolver-node: 0.3.9
-      eslint-import-resolver-typescript: 3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.53.0(eslint@9.39.4(jiti@2.6.1))(typescript@5.9.3))(eslint-import-resolver-typescript@4.4.4(eslint-plugin-import@2.32.0)(eslint@9.39.4(jiti@2.6.1)))(eslint@9.39.4(jiti@2.6.1)))(eslint@9.39.4(jiti@2.6.1))
+      eslint-import-resolver-typescript: 4.4.4(eslint-plugin-import@2.32.0)(eslint@9.39.4(jiti@2.6.1))
     transitivePeerDependencies:
       - supports-color
 
@@ -40087,7 +40093,7 @@ snapshots:
       doctrine: 2.1.0
       eslint: 9.39.4(jiti@2.6.1)
       eslint-import-resolver-node: 0.3.9
-      eslint-module-utils: 2.12.1(@typescript-eslint/parser@8.53.0(eslint@9.39.4(jiti@2.6.1))(typescript@5.9.3))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.53.0(eslint@9.39.4(jiti@2.6.1))(typescript@5.9.3))(eslint-import-resolver-typescript@4.4.4(eslint-plugin-import@2.32.0)(eslint@9.39.4(jiti@2.6.1)))(eslint@9.39.4(jiti@2.6.1)))(eslint@9.39.4(jiti@2.6.1)))(eslint@9.39.4(jiti@2.6.1))
+      eslint-module-utils: 2.12.1(@typescript-eslint/parser@8.53.0(eslint@9.39.4(jiti@2.6.1))(typescript@5.9.3))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@4.4.4)(eslint@9.39.4(jiti@2.6.1))
       hasown: 2.0.2
       is-core-module: 2.16.1
       is-glob: 4.0.3
@@ -40762,7 +40768,7 @@ snapshots:
       cross-spawn: 7.0.6
       signal-exit: 4.1.0
 
-  forge-std@https://codeload.github.com/foundry-rs/forge-std/tar.gz/6e8c4a92c9a8b31c1b0f0c39296d1fa4695c7df8:
+  forge-std@https://codeload.github.com/foundry-rs/forge-std/tar.gz/74302c55493479410b143d9dd08a60690c726ffe:
     {}
 
   fork-ts-checker-webpack-plugin@9.1.0(typescript@5.9.3)(webpack@5.105.4):