         (util/info "Writing %s and %s...\n" (.getName xmlfile) (.getName propfile))
         (pod/with-call-worker
           (boot.pom/spit-pom! ~(.getPath xmlfile) ~(.getPath propfile) ~opts))
-        (-> fileset (core/add-resource tgt) core/commit!))))))
+        (-> fs (core/add-resource tgt) core/commit!))))))
 
 (core/deftask sift
   "Transform the fileset, matching paths against regexes.

   V ensure-version VER   str      "The version the jar's pom must contain."]

  (let [tgt (core/tmp-dir!)]
    (core/with-pre-wrap fileset
      (util/with-let [_ fileset]
        (core/empty-dir! tgt)
        (let [jarfiles (or (and file [(io/file file)])
                           (->> (core/output-files fileset)
                                (core/by-ext [".jar"])
                                ((if (seq file-regex) #(core/by-re file-regex %) identity))
                                (map core/tmp-file)))
              ; Get options from Boot env by repo name
              r        (get (->> (core/get-env :repositories) (into {})) repo)
              repo-map (merge
                         ; Repo option in env might be given as only url instead of map
                         (if (map? r) r {:url r})
                         repo-map)]
          (when-not (and repo-map (seq jarfiles))
            (throw (Exception. "missing jar file or repo not found")))
          (doseq [f jarfiles]
            (let [{{t :tag} :scm
                   v :version} (pod/with-call-worker (boot.pom/pom-xml-parse ~(.getPath f)))
                  b            (util/guard (git/branch-current))
                  commit       (util/guard (git/last-commit))
                  tags         (util/guard (git/ls-tags))
                  clean?       (util/guard (git/clean?))
                  snapshot?    (.endsWith v "-SNAPSHOT")
                  artifact-map (when gpg-sign
                                 (util/info "Signing %s...\n" (.getName f))
                                 (gpg/sign-jar tgt f {:gpg-key gpg-user-id
                                                      :gpg-passphrase gpg-passphrase}))]
              (assert (or (not ensure-branch) (= b ensure-branch))
                      (format "current git branch is %s but must be %s" b ensure-branch))
              (assert (or (not ensure-clean) clean?)
                      "project repo is not clean")
              (assert (or (not ensure-release) (not snapshot?))
                      (format "not a release version (%s)" v))
              (assert (or (not ensure-snapshot) snapshot?)
                      (format "not a snapshot version (%s)" v))
              (assert (or (not ensure-tag) (not t) (= t ensure-tag))
                      (format "scm tag in pom doesn't match (%s, %s)" t ensure-tag))
              (when (and ensure-tag (not t))
                (util/warn "The --ensure-tag option was specified but scm info is missing from pom.xml\n"))
              (assert (or (not ensure-version) (= v ensure-version))
                      (format "jar version doesn't match project version (%s, %s)" v ensure-version))
              (util/info "Deploying %s...\n" (.getName f))
              (pod/with-call-worker
                (boot.aether/deploy ~(core/get-env) ~[repo repo-map] ~(.getPath f) ~artifact-map))
              (when tag
                (if (and tags (= commit (get tags tag)))
                  (util/info "Tag %s already created for %s\n" tag commit)
                  (do
                    (util/info "Creating tag %s...\n" v)
                    (git/tag v "release")))))))))))

  (let [usage      (delay (*usage*))
        pretty-str #(with-out-str (pp/pprint %))
        updates    (or updates update-snapshots)]
    (core/with-pass-thru [fs]
      (cond fileset        (helpers/print-fileset fs)
            classpath      (println (or (System/getProperty "boot.class.path") ""))
            fake-classpath (println (or (System/getProperty "fake.class.path") ""))
            :else
            (let [pattern (or pods #"^core$")]
              (doseq [p (->> pod/pods (map key) (sort-by (memfn getName)))
                      :let  [pod-name (.getName p)]
                      :when (and (re-find pattern pod-name)
                                 (not (#{"worker" "aether"} pod-name)))]
                (let [pod-env (if (= pod-name "core")
                                (core/get-env)
                                (pod/with-eval-in p boot.pod/env))]
                  (when pods (util/info "\nPod: %s\n\n" pod-name))
                  (cond deps     (print (pod/with-call-worker (boot.aether/dep-tree ~pod-env)))
                        env      (println (pretty-str (assoc pod-env :config (boot.App/config))))
                        updates  (mapv prn (pod/outdated pod-env :snapshots update-snapshots))
                        pedantic (pedantic/prn-conflicts pod-env)
                        :else    @usage))))))))

(core/deftask wait
  "Wait before calling the next handler.
