              (or (not forfeit-cost) (not (empty? scored))))
       {:costs costs, :forfeit-cost forfeit-cost, :scored scored})))
 
+(defn cost-names [value attr]
+  (when (> value 0)
+    (case attr
+      :credit (str value " [$]")
+      :click  (->> "[Click]" repeat (take value) (apply str)))))
+
 (defn deduce [state side [attr value]]
   (swap! state update-in [side attr] (if (= attr :memory)
                                        #(- % value) ;; memoryunits may be negative
                                        #(max 0 (- % value))))
   (when (and (= attr :credit) (= side :runner) (get-in @state [:runner :run-credit]))
-    (swap! state update-in [:runner :run-credit] #(max 0 (- % value)))))
+    (swap! state update-in [:runner :run-credit] #(max 0 (- % value))))
+  (when-let [cost-name (cost-names value attr)]
+    cost-name))
 
 (defn pay [state side card & args]
   (when-let [{:keys [costs forfeit-cost scored]} (apply can-pay? state side args)]

(defn init-trace [state side card {:keys [base] :as ability} boost]
  (trigger-event state side :pre-init-trace card)
  (let [bonus (or (get-in @state [:bonus :trace]) 0)
        base (if (fn? base) (base state side card nil) base) 
        total (+ base boost bonus)]
    (system-msg state :corp (str "uses " (:title card) 
                                 " to initiate a trace with strength " total 
                                 " (" base
                                 (when (> bonus 0) (str " + " bonus " bonus")) 
                                 " + " boost " [Credits])"))
    (swap! state update-in [:bonus] dissoc :trace)
    (show-prompt state :runner card (str "Boost link strength?") :credit #(resolve-trace state side %))

                                        (when memoryunits [:memory memoryunits])))]
         (when (and (or (not uniqueness) (not (in-play? state card)) facedown)
                    (if-let [req (:req (card-def card))]
                      (or facedown (req state side card nil)) true))
           (when-let [cost-str (pay state side card cost)]
             (let [c (if host-card
                       (host state side host-card card)
                       (move state side card [:rig (if facedown :facedown (to-keyword type))]))
                   installed-card (card-init state side (assoc c :installed true) (not facedown))]
               (if facedown
                 (system-msg state side "installs a card facedown" )
               (if custom-message
                 (system-msg state side custom-message)
                 (system-msg state side (str (if (= "" cost-str) "installs " (str "spends " cost-str " to install ")) title
                                          (when host-card (str " on " (:title host-card)))
                                          (when no-cost " at no cost")))))
               (trigger-event state side :runner-install installed-card)
               (when (has? c :subtype "Icebreaker") (update-breaker-strength state side c))))))))
   (when (has? card :type "Resource") (swap! state assoc-in [:runner :register :installed-resource] true))
   (swap! state update-in [:bonus] dissoc :install-cost)))

